package diff

import (
	"bytes"
	"image"
	"image/png"
	"math"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.skia.org/infra/go/testutils"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/golden/go/image/text"
	one_by_five "go.skia.org/infra/golden/go/testutils/data_one_by_five"
)

func TestDiffMetrics(t *testing.T) {
	unittest.MediumTest(t)
	// Assert different images with the same dimensions.
	assertDiffs(t, "4029959456464745507", "16465366847175223174",
		&DiffMetrics{
			NumDiffPixels:    16,
			CombinedMetric:   0.04604,
			PixelDiffPercent: 0.0064,
			MaxRGBADiffs:     [4]int{54, 100, 125, 0},
			DimDiffer:        false})
	assertDiffs(t, "5024150605949408692", "11069776588985027208",
		&DiffMetrics{
			NumDiffPixels:    2233,
			CombinedMetric:   0.04185,
			PixelDiffPercent: 0.8932,
			MaxRGBADiffs:     [4]int{0, 0, 1, 0},
			DimDiffer:        false})
	// Assert the same image.
	assertDiffs(t, "5024150605949408692", "5024150605949408692",
		&DiffMetrics{
			NumDiffPixels:    0,
			CombinedMetric:   0,
			PixelDiffPercent: 0,
			MaxRGBADiffs:     [4]int{0, 0, 0, 0},
			DimDiffer:        false})
	// Assert different images with different dimensions.
	assertDiffs(t, "ffce5042b4ac4a57bd7c8657b557d495", "fffbcca7e8913ec45b88cc2c6a3a73ad",
		&DiffMetrics{
			NumDiffPixels:    571674,
			CombinedMetric:   8.79528,
			PixelDiffPercent: 89.32407,
			MaxRGBADiffs:     [4]int{255, 255, 255, 0},
			DimDiffer:        true})
	// Assert with images that match in dimensions but where all pixels differ.
	assertDiffs(t, "4029959456464745507", "4029959456464745507-inverted",
		&DiffMetrics{
			NumDiffPixels:    250000,
			CombinedMetric:   9.30605,
			PixelDiffPercent: 100.0,
			MaxRGBADiffs:     [4]int{255, 255, 255, 0},
			DimDiffer:        false})

	// Assert different images where neither fits into the other.
	assertDiffs(t, "fffbcca7e8913ec45b88cc2c6a3a73ad", "fffbcca7e8913ec45b88cc2c6a3a73ad-rotated",
		&DiffMetrics{
			NumDiffPixels:    172466,
			CombinedMetric:   8.05148,
			PixelDiffPercent: 74.85503,
			MaxRGBADiffs:     [4]int{255, 255, 255, 0},
			DimDiffer:        true})
	// Make sure the metric is symmetric.
	assertDiffs(t, "fffbcca7e8913ec45b88cc2c6a3a73ad-rotated", "fffbcca7e8913ec45b88cc2c6a3a73ad",
		&DiffMetrics{
			NumDiffPixels:    172466,
			CombinedMetric:   8.05148,
			PixelDiffPercent: 74.85503,
			MaxRGBADiffs:     [4]int{255, 255, 255, 0},
			DimDiffer:        true})

	// Compare two images where one has an alpha channel and the other doesn't.
	assertDiffs(t, "b716a12d5b98d04b15db1d9dd82c82ea", "df1591dde35907399734ea19feb76663",
		&DiffMetrics{
			NumDiffPixels:    8750,
			CombinedMetric:   1.41919,
			PixelDiffPercent: 2.84831,
			MaxRGBADiffs:     [4]int{255, 2, 255, 0},
			DimDiffer:        false})

	// Compare two images where the alpha differs.
	assertDiffs(t, "df1591dde35907399734ea19feb76663", "df1591dde35907399734ea19feb76663-6-alpha-diff",
		&DiffMetrics{
			NumDiffPixels:    6,
			CombinedMetric:   0.03,
			PixelDiffPercent: 0.00195,
			MaxRGBADiffs:     [4]int{0, 0, 0, 235},
			DimDiffer:        false})
}

// lineDiff lists the differences in the lines of a and b.
func lineDiff(t *testing.T, a, b string) {
	aslice := strings.Split(a, "\n")
	bslice := strings.Split(b, "\n")
	if len(aslice) != len(bslice) {
		t.Fatal("Can't diff text, mismatched number of lines.\n")
		return
	}
	for i, s := range aslice {
		if s != bslice[i] {
			t.Errorf("Line %d: %q != %q\n", i+1, s, bslice[i])
		}
	}
}

// assertImagesEqual asserts that the two images are identical.
func assertImagesEqual(t *testing.T, got, want *image.NRGBA) {
	// Do the compare by converting them to sktext format and doing a string
	// compare.
	gotbuf := &bytes.Buffer{}
	if err := text.Encode(gotbuf, got); err != nil {
		t.Fatalf("Failed to encode: %s", err)
	}
	wantbuf := &bytes.Buffer{}
	if err := text.Encode(wantbuf, want); err != nil {
		t.Fatalf("Failed to encode: %s", err)
	}
	if gotbuf.String() != wantbuf.String() {
		t.Errorf("Pixel mismatch:\nGot:\n\n%v\n\nWant:\n\n%v\n", gotbuf, wantbuf)
		// Also print out the lines that are different, to make debugging easier.
		lineDiff(t, gotbuf.String(), wantbuf.String())
	}
}

// assertDiffMatch asserts that you get expected when you diff
// src1 and src2.
//
// Note that all images are in sktext format as strings.
func assertDiffMatch(t *testing.T, expected, src1, src2 string, expectedDiffMetrics ...*DiffMetrics) {
	dm, got := PixelDiff(text.MustToNRGBA(src1), text.MustToNRGBA(src2))
	want := text.MustToNRGBA(expected)
	assertImagesEqual(t, got, want)

	for _, expDM := range expectedDiffMetrics {
		assert.Equal(t, expDM, dm)
	}
}

// TestDiffImages tests that the diff images produced are correct.
func TestDiffImages(t *testing.T) {
	unittest.MediumTest(t)
	assertDiffMatch(t, one_by_five.DiffNone, one_by_five.ImageOne, one_by_five.ImageOne)
	assertDiffMatch(t, one_by_five.DiffNone, one_by_five.ImageTwo, one_by_five.ImageTwo)
	assertDiffMatch(t, one_by_five.DiffImageOneAndTwo, one_by_five.ImageOne, one_by_five.ImageTwo)
	assertDiffMatch(t, one_by_five.DiffImageOneAndTwo, one_by_five.ImageTwo, one_by_five.ImageOne)
	assertDiffMatch(t, one_by_five.DiffImageOneAndThree, one_by_five.ImageThree, one_by_five.ImageOne)
	assertDiffMatch(t, one_by_five.DiffImageOneAndThree, one_by_five.ImageOne, one_by_five.ImageThree)
	assertDiffMatch(t, one_by_five.DiffImageOneAndFour, one_by_five.ImageOne, one_by_five.ImageFour)
	assertDiffMatch(t, one_by_five.DiffImageOneAndFour, one_by_five.ImageFour, one_by_five.ImageOne)
	assertDiffMatch(t, one_by_five.DiffImageTwoAndFive, one_by_five.ImageTwo, one_by_five.ImageFive, &DiffMetrics{
		NumDiffPixels:    24,
		PixelDiffPercent: (24.0 / 25.0) * 100,
		MaxRGBADiffs:     [4]int{0, 0, 0, 0},
		DimDiffer:        true,
	})
}

// assertDiffs asserts that the DiffMetrics reported by Diffing the two images
// matches the expected DiffMetrics.
func assertDiffs(t *testing.T, d1, d2 string, expectedDiffMetrics *DiffMetrics) {
	img1 := openNRGBAFromFile(t, d1+".png")
	img2 := openNRGBAFromFile(t, d2+".png")
	diffMetrics := ComputeDiffMetrics(img1, img2)
	diffMetrics.PixelDiffPercent = roundToDecimalPlace(diffMetrics.PixelDiffPercent, 5)
	diffMetrics.CombinedMetric = roundToDecimalPlace(diffMetrics.CombinedMetric, 5)
	assert.Equal(t, expectedDiffMetrics, diffMetrics)
}

func roundToDecimalPlace(num float32, places int) float32 {
	exp := math.Pow(10, float64(places))
	scaledUp := float64(num) * exp
	scaledUp = math.Round(scaledUp)
	return float32(scaledUp / exp)
}

func TestDeltaOffset(t *testing.T) {
	unittest.SmallTest(t)
	testCases := []struct {
		offset int
		want   int
	}{
		{
			offset: 1,
			want:   0,
		},
		{
			offset: 2,
			want:   1,
		},
		{
			offset: 5,
			want:   1,
		},
		{
			offset: 6,
			want:   2,
		},
		{
			offset: 100,
			want:   4,
		},
		{
			offset: 1024,
			want:   6,
		},
	}

	for _, tc := range testCases {
		if got, want := deltaOffset(tc.offset), tc.want; got != want {
			t.Errorf("deltaOffset(%d): Got %v Want %v", tc.offset, got, want)
		}
	}

}

func TestCombinedDiffMetric(t *testing.T) {
	unittest.SmallTest(t)
	assert.InDelta(t, 10.0, CombinedDiffMetric([4]int{255, 255, 255, 255}, 100.0), 0.000001)
	assert.InDelta(t, 1.0, CombinedDiffMetric([4]int{255, 255, 255, 255}, 1.0), 0.000001)
	assert.InDelta(t, math.Sqrt(0.5), CombinedDiffMetric([4]int{255, 255, 255, 255}, 0.5), 0.000001)
}

func benchmarkDiff(b *testing.B, img1, img2 image.Image) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		PixelDiff(img1, img2)
	}
}

const (
	img1 = "4029959456464745507.png"              // 500x500.
	img2 = "4029959456464745507-inverted.png"     // 500x500.
	img3 = "b716a12d5b98d04b15db1d9dd82c82ea.png" // 640x480.
)

func BenchmarkDiffIdentical(b *testing.B) {
	benchmarkDiff(b, openNRGBAFromFile(b, img1), openNRGBAFromFile(b, img1))
}

func BenchmarkDiffSameSize(b *testing.B) {
	benchmarkDiff(b, openNRGBAFromFile(b, img1), openNRGBAFromFile(b, img2))
}

func BenchmarkDiffDifferentSize(b *testing.B) {
	benchmarkDiff(b, openNRGBAFromFile(b, img1), openNRGBAFromFile(b, img3))
}

// openNRGBAFromFile opens the given file path to a PNG file and returns the image as image.NRGBA.
func openNRGBAFromFile(t testing.TB, fileName string) *image.NRGBA {
	b := testutils.ReadFileBytes(t, fileName)
	im, err := png.Decode(bytes.NewReader(b))
	require.NoError(t, err, "invalid png file %s", fileName)
	return GetNRGBA(im)
}