package common

import (
	"image"
	"image/color"
	"math/bits"
	"math/rand"
	"testing"
)

func noiseImg(seed int64) *image.Gray {
	rng := rand.New(rand.NewSource(seed))
	img := image.NewGray(image.Rect(0, 0, 160, 120))
	for i := range img.Pix {
		img.Pix[i] = uint8(rng.Intn(256))
	}
	return img
}

func hamming(a, b uint64) int {
	return bits.OnesCount64(a ^ b)
}

// TestImageDHash64：同图哈希恒等，异噪声图哈希距离应远超相似阈值(8)
func TestImageDHash64(t *testing.T) {
	h1, err := hashOf(noiseImg(1))
	if err != nil {
		t.Fatalf("hashOf noise: %v", err)
	}
	h2, err := hashOf(noiseImg(1))
	if err != nil {
		t.Fatalf("hashOf same noise: %v", err)
	}
	if h1 != h2 {
		t.Fatalf("same image hash mismatch: %d vs %d", h1, h2)
	}
	h3, err := hashOf(noiseImg(2))
	if err != nil {
		t.Fatalf("hashOf other noise: %v", err)
	}
	if d := hamming(h1, h3); d <= 8 { // 64 位随机噪声期望距离 ~32
		t.Fatalf("unrelated images too close: hamming=%d", d)
	}
}

// TestImageDHash64Uniform：纯色图哈希为 0（全等帧），与另一纯色图判为同图属预期
func TestImageDHash64Uniform(t *testing.T) {
	u := image.NewGray(image.Rect(0, 0, 64, 64))
	for i := range u.Pix {
		u.Pix[i] = 128
	}
	h, err := hashOf(u)
	if err != nil {
		t.Fatalf("hashOf uniform: %v", err)
	}
	if h != 0 {
		t.Fatalf("uniform image hash = %d, want 0", h)
	}
}

// 灰度渐变图（列渐变：左暗右亮）
func gradientImg() *image.Gray {
	img := image.NewGray(image.Rect(0, 0, 90, 80))
	for y := 0; y < 80; y++ {
		for x := 0; x < 90; x++ {
			img.SetGray(x, y, color.Gray{Y: uint8(x * 255 / 89)})
		}
	}
	return img
}

// TestImageDHash64Gradient：行渐变每对相邻列左<右，64 位全 1
func TestImageDHash64Gradient(t *testing.T) {
	h, err := hashOf(gradientImg())
	if err != nil {
		t.Fatalf("hashOf gradient: %v", err)
	}
	if bits.OnesCount64(h) != 64 {
		t.Fatalf("gradient hash bits = %d, want 64 (all 1s)", bits.OnesCount64(h))
	}
}