package video

import (
	"errors"
	"strings"
	"testing"

	"mxl-pattern-generator/internal/flowdef"
	"mxl-pattern-generator/internal/generator"
)

type stubFrameGenerator struct{}

func (*stubFrameGenerator) GenerateFrame([]byte, int) error { return nil }
func (*stubFrameGenerator) Close() error                    { return nil }

func TestSelectFrameGenerator(t *testing.T) {
	gpuErr := errors.New("no GPU")
	cpuErr := errors.New("no CPU pattern")
	tests := []struct {
		name          string
		backend       Backend
		gpuErr        error
		cpuErr        error
		wantBackend   Backend
		wantGPUCalls  int
		wantCPUCalls  int
		wantErrSubstr []string
	}{
		{name: "explicit GPU", backend: BackendGPU, wantBackend: BackendGPU, wantGPUCalls: 1},
		{name: "explicit CPU", backend: BackendCPU, wantBackend: BackendCPU, wantCPUCalls: 1},
		{name: "auto prefers GPU", backend: BackendAuto, wantBackend: BackendGPU, wantGPUCalls: 1},
		{name: "zero value is auto", wantBackend: BackendGPU, wantGPUCalls: 1},
		{
			name:         "auto falls back to CPU",
			backend:      BackendAuto,
			gpuErr:       gpuErr,
			wantBackend:  BackendCPU,
			wantGPUCalls: 1,
			wantCPUCalls: 1,
		},
		{
			name:          "auto reports both failures",
			backend:       BackendAuto,
			gpuErr:        gpuErr,
			cpuErr:        cpuErr,
			wantGPUCalls:  1,
			wantCPUCalls:  1,
			wantErrSubstr: []string{"GPU video generator", "CPU video generator"},
		},
		{
			name:          "explicit GPU does not fall back",
			backend:       BackendGPU,
			gpuErr:        gpuErr,
			wantGPUCalls:  1,
			wantErrSubstr: []string{"GPU video generator"},
		},
		{
			name:          "explicit CPU does not try GPU",
			backend:       BackendCPU,
			cpuErr:        cpuErr,
			wantCPUCalls:  1,
			wantErrSubstr: []string{"CPU video generator"},
		},
		{
			name:          "invalid backend",
			backend:       Backend("invalid"),
			wantErrSubstr: []string{"unsupported video backend"},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			gpuCalls, cpuCalls := 0, 0
			factory := func(calls *int, err error) generatorFactory {
				return func() (generator.FrameGenerator, error) {
					*calls++
					if err != nil {
						return nil, err
					}
					return &stubFrameGenerator{}, nil
				}
			}

			gen, backend, err := selectFrameGenerator(
				tc.backend,
				factory(&gpuCalls, tc.gpuErr),
				factory(&cpuCalls, tc.cpuErr),
			)
			if gpuCalls != tc.wantGPUCalls || cpuCalls != tc.wantCPUCalls {
				t.Fatalf("factory calls GPU/CPU = %d/%d, want %d/%d",
					gpuCalls, cpuCalls, tc.wantGPUCalls, tc.wantCPUCalls)
			}
			if len(tc.wantErrSubstr) == 0 {
				if err != nil {
					t.Fatalf("selectFrameGenerator: %v", err)
				}
				if gen == nil || backend != tc.wantBackend {
					t.Fatalf("generator/backend = %v/%q, want non-nil/%q", gen, backend, tc.wantBackend)
				}
				return
			}
			if err == nil {
				t.Fatal("selectFrameGenerator returned nil error")
			}
			for _, substring := range tc.wantErrSubstr {
				if !strings.Contains(err.Error(), substring) {
					t.Errorf("error = %q, want substring %q", err, substring)
				}
			}
		})
	}
}

func TestWrapAlphaGenerator(t *testing.T) {
	const id = "5fbec3b1-1b0f-417d-9059-8b94a47197ed"
	rate := flowdef.Rational{Numerator: 25, Denominator: 1}
	tests := []struct {
		name      string
		alpha     bool
		wantAlpha bool
	}{
		{name: "v210"},
		{name: "v210a", alpha: true, wantAlpha: true},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			var (
				definition flowdef.Video
				err        error
			)
			if tc.alpha {
				definition, err = flowdef.NewV210AVideo(id, 100, 200, rate)
			} else {
				definition, err = flowdef.NewV210Video(id, 100, 200, rate)
			}
			if err != nil {
				t.Fatalf("create flow definition: %v", err)
			}
			cfg := Config{
				Definition: definition,
				Pattern:    "gray-ramp",
				Backend:    BackendCPU,
			}
			fill := &stubFrameGenerator{}

			gen, err := wrapAlphaGenerator(cfg, fill, false)
			if err != nil {
				t.Fatalf("wrapAlphaGenerator: %v", err)
			}
			defer gen.Close()
			_, gotAlpha := gen.(*generator.V210AGenerator)
			if gotAlpha != tc.wantAlpha {
				t.Errorf("v210a wrapper present = %v, want %v", gotAlpha, tc.wantAlpha)
			}
			if !tc.wantAlpha && gen != fill {
				t.Error("v210 generator was unexpectedly replaced")
			}
		})
	}
}

func TestConfigHasAlpha(t *testing.T) {
	for _, tc := range []struct {
		mediaType string
		want      bool
	}{
		{mediaType: flowdef.MediaTypeV210},
		{mediaType: flowdef.MediaTypeV210A, want: true},
		{mediaType: "video/unknown"},
	} {
		cfg := Config{Definition: flowdef.Video{Common: flowdef.Common{MediaType: tc.mediaType}}}
		if got := cfg.HasAlpha(); got != tc.want {
			t.Errorf("HasAlpha() for %q = %v, want %v", tc.mediaType, got, tc.want)
		}
	}
}