package imgmatching

import (
	"fmt"
	"math"
	"testing"

	"github.com/stretchr/testify/assert"
	"go.skia.org/infra/gold-client/go/imgmatching/exact"
	"go.skia.org/infra/gold-client/go/imgmatching/fuzzy"
	"go.skia.org/infra/gold-client/go/imgmatching/positive_if_only_image"
	"go.skia.org/infra/gold-client/go/imgmatching/sample_area"
	"go.skia.org/infra/gold-client/go/imgmatching/sobel"
)

func TestMakeMatcher_UnknownAlgorithm_ReturnsError(t *testing.T) {
	_, _, err := MakeMatcher(map[string]string{
		AlgorithmNameOptKey: "FakeAlgorithm",
	})

	assert.Error(t, err)
	assert.Contains(t, err.Error(), `unrecognized image matching algorithm: "FakeAlgorithm"`)
}

func TestMakeMatcher_NoAlgorithmSpecified_ReturnsExactMatching(t *testing.T) {
	algorithmName, matcher, err := MakeMatcher(map[string]string{})

	assert.NoError(t, err)
	assert.Equal(t, ExactMatching, algorithmName)
	assert.Equal(t, matcher, &exact.Matcher{})
}

func TestMakeMatcher_ExactMatchingExplicitlySpecified_ReturnsExactMatching(t *testing.T) {
	algorithmName, matcher, err := MakeMatcher(map[string]string{
		AlgorithmNameOptKey: string(ExactMatching),
	})

	assert.NoError(t, err)
	assert.Equal(t, ExactMatching, algorithmName)
	assert.Equal(t, matcher, &exact.Matcher{})
}

// missing is a sentinel value used to represent missing parameter values.
const missing = "missing value"

// fuzzyMatchingTestCase represents a test case for MakeMatcher() where a fuzzy.Matcher is
// instantiated.
type fuzzyMatchingTestCase struct {
	name                          string
	maxDifferentPixels            string
	pixelDeltaThreshold           string
	pixelPerChannelDeltaThreshold string
	ignoredBorderThickness        string
	want                          fuzzy.Matcher
	error                         string
}

// commonMaxDifferentPixelsTestCases returns test cases for the MaxDifferentPixels
// optional key.
//
// These tests are shared between TestMakeMatcher_FuzzyMatching and
// TestMakeMatcher_SobelFuzzyMatching.
func commonMaxDifferentPixelsTestCases() []fuzzyMatchingTestCase {
	return []fuzzyMatchingTestCase{
		{
			name:                          "max different pixels: missing, returns error",
			maxDifferentPixels:            missing,
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `required image matching parameter not found: "fuzzy_max_different_pixels"`,
		},
		{
			name:                          "max different pixels: empty, returns error",
			maxDifferentPixels:            "",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_max_different_pixels" cannot be empty`,
		},
		{
			name:                          "max different pixels: non-integer value, returns error",
			maxDifferentPixels:            "not an integer",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "invalid syntax",
		},
		{
			name:                          "max different pixels: non-32-bit integer (math.MinInt32 - 1), returns error",
			maxDifferentPixels:            fmt.Sprintf("%d", math.MinInt32-1),
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "max different pixels: non-32-bit integer (math.MaxInt32 + 1), returns error",
			maxDifferentPixels:            fmt.Sprintf("%d", math.MaxInt32+1),
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "max different pixels: value = -1, returns error",
			maxDifferentPixels:            "-1",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_max_different_pixels" must be at least 0, was: -1`,
		},
		{
			name:                          "max different pixels: value = 0, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "max different pixels: value = math.MaxInt32, success",
			maxDifferentPixels:            fmt.Sprintf("%d", math.MaxInt32),
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            math.MaxInt32,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
	}
}

// commonPixelDeltaThresholdTestCases returns test cases for the PixelDeltaThreshold
// and PixelPerChannelDeltaThreshold optional keys.
//
// These tests are shared between TestMakeMatcher_FuzzyMatching and
// TestMakeMatcher_SobelFuzzyMatching.
func commonPixelDeltaThresholdTestCases() []fuzzyMatchingTestCase {
	return []fuzzyMatchingTestCase{
		{
			name:                          "pixel delta thresholds: both missing, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           missing,
			pixelPerChannelDeltaThreshold: missing,
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel delta thresholds: both unset, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel delta thresholds: both set, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "1",
			pixelPerChannelDeltaThreshold: "1",
			ignoredBorderThickness:        missing,
			error:                         `only one of fuzzy_pixel_delta_threshold and fuzzy_pixel_per_channel_delta_threshold can be set`,
		},
		{
			name:                          "pixel delta threshold: empty, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_delta_threshold" cannot be empty`,
		},
		{
			name:                          "pixel per channel delta threshold: empty, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_per_channel_delta_threshold" cannot be empty`,
		},
		{
			name:                          "pixel delta threshold: non-integer value, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "not an integer",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "invalid syntax",
		},
		{
			name:                          "pixel per channel delta threshold: non-integer value, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "not an integer",
			ignoredBorderThickness:        missing,
			error:                         "invalid syntax",
		},
		{
			name:                          "pixel delta threshold: non-32-bit integer (math.MinInt32 - 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           fmt.Sprintf("%d", math.MinInt32-1),
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "pixel per channel delta threshold: non-32-bit integer (math.MinInt32 - 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: fmt.Sprintf("%d", math.MinInt32-1),
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "pixel delta threshold: non-32-bit integer (math.MaxInt32 + 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           fmt.Sprintf("%d", math.MaxInt32+1),
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "pixel per channel delta threshold: per-channel non-32-bit integer (math.MaxInt32 + 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: fmt.Sprintf("%d", math.MaxInt32+1),
			ignoredBorderThickness:        missing,
			error:                         "out of range",
		},
		{
			name:                          "pixel delta threshold: value = -1, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "-1",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_delta_threshold" must be between 0 and 1020, was: -1`,
		},
		{
			name:                          "pixel per channel delta threshold: value = -1, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "-1",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_per_channel_delta_threshold" must be between 0 and 255, was: -1`,
		},
		{
			name:                          "pixel delta threshold: value = 0, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel per channel delta threshold: value = 0, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "1",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           1,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel delta threshold: value = 1020, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "1020",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           1020,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel per channel delta threshold: value = 255, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "255",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 255,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "pixel delta threshold: value = 1021, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "1021",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_delta_threshold" must be between 0 and 1020, was: 1021`,
		},
		{
			name:                          "pixel per channel delta threshold: value = 256, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "256",
			ignoredBorderThickness:        missing,
			error:                         `image matching parameter "fuzzy_pixel_per_channel_delta_threshold" must be between 0 and 255, was: 256`,
		},
	}
}

// commonIgnoredBorderThicknessTestCases returns test cases for the IgnoredBorderThickness
// optional key.
//
// These tests are shared between TestMakeMatcher_FuzzyMatching and
// TestMakeMatcher_SobelFuzzyMatching.
func commonIgnoredBorderThicknessTestCases() []fuzzyMatchingTestCase {
	return []fuzzyMatchingTestCase{
		{
			name:                          "ignored border thickness: missing, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        missing,
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "ignored border thickness: empty, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "",
			error:                         `image matching parameter "fuzzy_ignored_border_thickness" cannot be empty`,
		},
		{
			name:                          "ignored border thickness: non-integer value, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "not an integer",
			error:                         "invalid syntax",
		},
		{
			name:                          "ignored border thickness: non-32-bit integer (math.MinInt32 - 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        fmt.Sprintf("%d", math.MinInt32-1),
			error:                         "out of range",
		},
		{
			name:                          "ignored border thickness: non-32-bit integer (math.MaxInt32 + 1), returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        fmt.Sprintf("%d", math.MaxInt32+1),
			error:                         "out of range",
		},
		{
			name:                          "ignored border thickness: value = -1, returns error",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "-1",
			error:                         `image matching parameter "fuzzy_ignored_border_thickness" must be at least 0, was: -1`,
		},
		{
			name:                          "ignored border thickness: value = 0, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        0,
			},
		},
		{
			name:                          "ignored border thickness: value = 1, success",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "1",
			want: fuzzy.Matcher{
				MaxDifferentPixels:            0,
				PixelDeltaThreshold:           0,
				PixelPerChannelDeltaThreshold: 0,
				IgnoredBorderThickness:        1,
			},
		},
	}
}

func TestMakeMatcher_FuzzyMatching(t *testing.T) {
	tests := []fuzzyMatchingTestCase{
		{
			name:                   "all parameters missing, returns error",
			maxDifferentPixels:     missing,
			pixelDeltaThreshold:    missing,
			ignoredBorderThickness: missing,
			error:                  "required image matching parameter not found",
		},
	}
	tests = append(tests, commonMaxDifferentPixelsTestCases()...)
	tests = append(tests, commonPixelDeltaThresholdTestCases()...)
	tests = append(tests, commonIgnoredBorderThicknessTestCases()...)

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			optionalKeys := map[string]string{
				AlgorithmNameOptKey: string(FuzzyMatching),
			}
			if tc.maxDifferentPixels != missing {
				optionalKeys[string(MaxDifferentPixels)] = tc.maxDifferentPixels
			}
			if tc.pixelDeltaThreshold != missing {
				optionalKeys[string(PixelDeltaThreshold)] = tc.pixelDeltaThreshold
			}
			if tc.pixelPerChannelDeltaThreshold != missing {
				optionalKeys[string(PixelPerChannelDeltaThreshold)] = tc.pixelPerChannelDeltaThreshold
			}
			if tc.ignoredBorderThickness != missing {
				optionalKeys[string(IgnoredBorderThickness)] = tc.ignoredBorderThickness
			}

			algorithmName, matcher, err := MakeMatcher(optionalKeys)

			if tc.error != "" {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tc.error)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, FuzzyMatching, algorithmName)
				assert.Equal(t, &tc.want, matcher)
			}
		})
	}
}

func TestMakeMatcher_PositiveIfOnlyImageMatching(t *testing.T) {
	algorithmName, matcher, err := MakeMatcher(map[string]string{
		AlgorithmNameOptKey: string(PositiveIfOnlyImageMatching),
	})

	assert.NoError(t, err)
	assert.Equal(t, PositiveIfOnlyImageMatching, algorithmName)
	assert.Equal(t, matcher, &positive_if_only_image.Matcher{})
}

func TestMakeMatcher_SobelFuzzyMatching(t *testing.T) {
	type sobelFuzzyMatchingTestCase struct {
		name                          string
		edgeThreshold                 string
		maxDifferentPixels            string
		pixelDeltaThreshold           string
		pixelPerChannelDeltaThreshold string
		ignoredBorderThickness        string
		want                          sobel.Matcher
		error                         string
	}

	tests := []sobelFuzzyMatchingTestCase{
		{
			name:                          "all parameters missing, returns error",
			edgeThreshold:                 missing,
			maxDifferentPixels:            missing,
			pixelDeltaThreshold:           missing,
			pixelPerChannelDeltaThreshold: missing,
			ignoredBorderThickness:        missing,

			error: "required image matching parameter not found",
		},
		{
			name:                          "edge threshold: missing, returns error",
			edgeThreshold:                 missing,
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         `required image matching parameter not found: "sobel_edge_threshold"`,
		},
		{
			name:                          "edge threshold: empty, returns error",
			edgeThreshold:                 "",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         `image matching parameter "sobel_edge_threshold" cannot be empty`,
		},
		{
			name:                          "edge threshold: non-integer value, returns error",
			edgeThreshold:                 "not an integer",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         "invalid syntax",
		},
		{
			name:                          "edge threshold: non-32-bit integer (math.MinInt32 - 1), returns error",
			edgeThreshold:                 fmt.Sprintf("%d", math.MinInt32-1),
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         "out of range",
		},
		{
			name:                          "edge threshold: non-32-bit integer (math.MaxInt32 + 1), returns error",
			edgeThreshold:                 fmt.Sprintf("%d", math.MaxInt32+1),
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         "out of range",
		},
		{
			name:                          "edge threshold: value < 0, returns error",
			edgeThreshold:                 "-1",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         `image matching parameter "sobel_edge_threshold" must be between 0 and 255, was: -1`,
		},
		{
			name:                          "edge threshold: value = 0, success",
			edgeThreshold:                 "0",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			want: sobel.Matcher{
				Matcher: fuzzy.Matcher{
					MaxDifferentPixels:            0,
					PixelDeltaThreshold:           0,
					PixelPerChannelDeltaThreshold: 0,
					IgnoredBorderThickness:        0,
				},
				EdgeThreshold: 0,
			},
		},
		{
			name:                          "edge threshold: 0 < value < 255, success",
			edgeThreshold:                 "254",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			want: sobel.Matcher{
				Matcher: fuzzy.Matcher{
					MaxDifferentPixels:            0,
					PixelDeltaThreshold:           0,
					PixelPerChannelDeltaThreshold: 0,
					IgnoredBorderThickness:        0,
				},
				EdgeThreshold: 254,
			},
		},
		{
			name:                          "edge threshold: value = 255, success",
			edgeThreshold:                 "255",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			want: sobel.Matcher{
				Matcher: fuzzy.Matcher{
					MaxDifferentPixels:            0,
					PixelDeltaThreshold:           0,
					PixelPerChannelDeltaThreshold: 0,
					IgnoredBorderThickness:        0,
				},
				EdgeThreshold: 255,
			},
		},
		{
			name:                          "edge threshold: value > 255, returns error",
			edgeThreshold:                 "256",
			maxDifferentPixels:            "0",
			pixelDeltaThreshold:           "0",
			pixelPerChannelDeltaThreshold: "0",
			ignoredBorderThickness:        "0",
			error:                         `image matching parameter "sobel_edge_threshold" must be between 0 and 255, was: 256`,
		},
	}

	// Append test cases for FuzzyMatching.
	appendCommonTestCase := func(tc fuzzyMatchingTestCase) {
		tests = append(tests, sobelFuzzyMatchingTestCase{
			name:                          tc.name,
			edgeThreshold:                 "0",
			maxDifferentPixels:            tc.maxDifferentPixels,
			pixelDeltaThreshold:           tc.pixelDeltaThreshold,
			pixelPerChannelDeltaThreshold: tc.pixelPerChannelDeltaThreshold,
			ignoredBorderThickness:        tc.ignoredBorderThickness,
			want: sobel.Matcher{
				Matcher:       tc.want,
				EdgeThreshold: 0,
			},
			error: tc.error,
		})
	}
	for _, tc := range commonMaxDifferentPixelsTestCases() {
		appendCommonTestCase(tc)
	}
	for _, tc := range commonPixelDeltaThresholdTestCases() {
		appendCommonTestCase(tc)
	}
	for _, tc := range commonIgnoredBorderThicknessTestCases() {
		appendCommonTestCase(tc)
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			optionalKeys := map[string]string{
				AlgorithmNameOptKey: string(SobelFuzzyMatching),
			}
			if tc.edgeThreshold != missing {
				optionalKeys[string(EdgeThreshold)] = tc.edgeThreshold
			}
			if tc.maxDifferentPixels != missing {
				optionalKeys[string(MaxDifferentPixels)] = tc.maxDifferentPixels
			}
			if tc.pixelDeltaThreshold != missing {
				optionalKeys[string(PixelDeltaThreshold)] = tc.pixelDeltaThreshold
			}
			if tc.pixelPerChannelDeltaThreshold != missing {
				optionalKeys[string(PixelPerChannelDeltaThreshold)] = tc.pixelPerChannelDeltaThreshold
			}
			if tc.ignoredBorderThickness != missing {
				optionalKeys[string(IgnoredBorderThickness)] = tc.ignoredBorderThickness
			}

			algorithmName, matcher, err := MakeMatcher(optionalKeys)

			if tc.error != "" {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tc.error)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, SobelFuzzyMatching, algorithmName)
				assert.Equal(t, &tc.want, matcher)
			}
		})
	}
}

func TestMakeMatcher_SampleAreaMatching_Error(t *testing.T) {
	type sampleAreaErrorTestCase struct {
		name                            string
		sampleAreaWidth                 string
		maxDifferentPixelsPerArea       string
		sampleAreaChannelDeltaThreshold string
		error                           string
	}

	maxIntSqrt := int(math.Sqrt(math.MaxInt32))

	tests := []sampleAreaErrorTestCase{
		// Missing cases.
		{
			name:                            "sample area width: missing, returns error",
			sampleAreaWidth:                 missing,
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `required image matching parameter not found: "sample_area_width"`,
		},
		{
			name:                            "max different pixels per area: missing, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       missing,
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `required image matching parameter not found: "sample_area_max_different_pixels_per_area"`,
		},
		{
			name:                            "all parameters missing, returns error",
			sampleAreaWidth:                 missing,
			maxDifferentPixelsPerArea:       missing,
			sampleAreaChannelDeltaThreshold: missing,
			error:                           "required image matching parameter not found",
		},
		// Empty cases.
		{
			name:                            "sample area width: empty, returns error",
			sampleAreaWidth:                 "",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `image matching parameter "sample_area_width" cannot be empty`,
		},
		{
			name:                            "max different pixels per area: empty, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `image matching parameter "sample_area_max_different_pixels_per_area" cannot be empty`,
		},
		{
			name:                            "sample area channel delta threshold: empty, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "",
			error:                           `image matching parameter "sample_area_channel_delta_threshold" cannot be empty`,
		},
		// Non-integer cases.
		{
			name:                            "sample area width: non-integer value, returns error",
			sampleAreaWidth:                 "not an integer",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "invalid syntax",
		},
		{
			name:                            "max different pixels per area: non-integer value, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "not an integer",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "invalid syntax",
		},
		{
			name:                            "sample area channel delta threshold: non-integer value, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "not an integer",
			error:                           "invalid syntax",
		},
		// Non-32-bit integer cases.
		{
			name:                            "sample area width: non-32-bit integer (math.MinInt32 - 1), returns error",
			sampleAreaWidth:                 fmt.Sprintf("%d", math.MinInt32-1),
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "out of range",
		},
		{
			name:                            "sample area width: non-32-bit integer (math.MaxInt32 + 1), returns error",
			sampleAreaWidth:                 fmt.Sprintf("%d", math.MaxInt32+1),
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "out of range",
		},
		{
			name:                            "max different pixels per area: non-32-bit integer (math.MinInt32 - 1), returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       fmt.Sprintf("%d", math.MinInt32-1),
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "out of range",
		},
		{
			name:                            "max different pixels per area: non-32-bit integer (math.MaxInt32 + 1), returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       fmt.Sprintf("%d", math.MaxInt32+1),
			sampleAreaChannelDeltaThreshold: "0",
			error:                           "out of range",
		},
		{
			name:                            "sample area channel delta threshold: non-32-bit integer (math.MinInt32 - 1), returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: fmt.Sprintf("%d", math.MinInt32-1),
			error:                           "out of range",
		},
		{
			name:                            "sample area channel delta threshold: non-32-bit integer (math.MaxInt32 + 1), returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: fmt.Sprintf("%d", math.MaxInt32+1),
			error:                           "out of range",
		},
		// Under lower limit cases.
		{
			name:                            "sample area width: value < 1, returns error",
			sampleAreaWidth:                 "0",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           fmt.Sprintf(`image matching parameter "sample_area_width" must be between 1 and %d, was: 0`, maxIntSqrt),
		},
		{
			name:                            "max different pixels per area: value < 0, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "-1",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `image matching parameter "sample_area_max_different_pixels_per_area" must be between 0 and 4, was: -1`,
		},
		{
			name:                            "sample area channel delta threshold: value < 0, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "-1",
			error:                           `image matching parameter "sample_area_channel_delta_threshold" must be between 0 and 255, was: -1`,
		},
		// Over upper limit cases.
		{
			name:                            "sample area width: value > max int 32 square root, returns error",
			sampleAreaWidth:                 fmt.Sprintf("%d", maxIntSqrt+1),
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           fmt.Sprintf(`image matching parameter "sample_area_width" must be between 1 and %d, was: %d`, maxIntSqrt, maxIntSqrt+1),
		},
		{
			name:                            "max different pixels per area: value > number of sampled pixels, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "5",
			sampleAreaChannelDeltaThreshold: "0",
			error:                           `image matching parameter "sample_area_max_different_pixels_per_area" must be between 0 and 4, was: 5`,
		},
		{
			name:                            "sample area channel delta threshold: value > 255, returns error",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "256",
			error:                           `image matching parameter "sample_area_channel_delta_threshold" must be between 0 and 255, was: 256`,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			optionalKeys := map[string]string{
				AlgorithmNameOptKey: string(SampleAreaMatching),
			}
			if tc.sampleAreaWidth != missing {
				optionalKeys[string(SampleAreaWidth)] = tc.sampleAreaWidth
			}
			if tc.maxDifferentPixelsPerArea != missing {
				optionalKeys[string(MaxDifferentPixelsPerArea)] = tc.maxDifferentPixelsPerArea
			}
			if tc.sampleAreaChannelDeltaThreshold != missing {
				optionalKeys[string(SampleAreaChannelDeltaThreshold)] = tc.sampleAreaChannelDeltaThreshold
			}

			_, _, err := MakeMatcher(optionalKeys)

			assert.Error(t, err)
			assert.Contains(t, err.Error(), tc.error)
		})
	}
}

func TestMakeMatcher_SampleAreaMatching_Success(t *testing.T) {
	type sampleAreaSuccessTestCase struct {
		name                            string
		sampleAreaWidth                 string
		maxDifferentPixelsPerArea       string
		sampleAreaChannelDeltaThreshold string
		want                            sample_area.Matcher
	}

	maxIntSqrt := int(math.Sqrt(math.MaxInt32))

	tests := []sampleAreaSuccessTestCase{
		// Missing cases.
		{
			name:                            "sample area channel delta threshold: missing, uses default",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: missing,
			want: sample_area.Matcher{
				SampleAreaWidth:                 2,
				MaxDifferentPixelsPerArea:       0,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		// At lower limit cases.
		{
			name:                            "sample area width: value = lower limit, success",
			sampleAreaWidth:                 "1",
			maxDifferentPixelsPerArea:       "1",
			sampleAreaChannelDeltaThreshold: "0",
			want: sample_area.Matcher{
				SampleAreaWidth:                 1,
				MaxDifferentPixelsPerArea:       1,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		{
			name:                            "max different pixels per area: value = lower limit, success",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			want: sample_area.Matcher{
				SampleAreaWidth:                 2,
				MaxDifferentPixelsPerArea:       0,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		{
			name:                            "sample area channel delta threshold: value = lower limit, success",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "1",
			sampleAreaChannelDeltaThreshold: "0",
			want: sample_area.Matcher{
				SampleAreaWidth:                 2,
				MaxDifferentPixelsPerArea:       1,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		// At upper limit cases.
		{
			name:                            "sample area width: value = upper limit, success",
			sampleAreaWidth:                 fmt.Sprintf("%d", maxIntSqrt),
			maxDifferentPixelsPerArea:       "0",
			sampleAreaChannelDeltaThreshold: "0",
			want: sample_area.Matcher{
				SampleAreaWidth:                 maxIntSqrt,
				MaxDifferentPixelsPerArea:       0,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		{
			name:                            "max different pixels per area: value = upper limit, success",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "4",
			sampleAreaChannelDeltaThreshold: "0",
			want: sample_area.Matcher{
				SampleAreaWidth:                 2,
				MaxDifferentPixelsPerArea:       4,
				SampleAreaChannelDeltaThreshold: 0,
			},
		},
		{
			name:                            "sample area channel delta threshold: value = upper limit, success",
			sampleAreaWidth:                 "2",
			maxDifferentPixelsPerArea:       "1",
			sampleAreaChannelDeltaThreshold: "255",
			want: sample_area.Matcher{
				SampleAreaWidth:                 2,
				MaxDifferentPixelsPerArea:       1,
				SampleAreaChannelDeltaThreshold: 255,
			},
		},
		// Between limits cases already handled by the lower limit cases for the
		// other arguments.
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			optionalKeys := map[string]string{
				AlgorithmNameOptKey: string(SampleAreaMatching),
			}
			optionalKeys[string(SampleAreaWidth)] = tc.sampleAreaWidth
			optionalKeys[string(MaxDifferentPixelsPerArea)] = tc.maxDifferentPixelsPerArea
			if tc.sampleAreaChannelDeltaThreshold != missing {
				optionalKeys[string(SampleAreaChannelDeltaThreshold)] = tc.sampleAreaChannelDeltaThreshold
			}

			algorithmName, matcher, err := MakeMatcher(optionalKeys)

			assert.NoError(t, err)
			assert.Equal(t, SampleAreaMatching, algorithmName)
			assert.Equal(t, &tc.want, matcher)
		})
	}
}