package video

import (
	"errors"
	"strings"
	"testing"

	"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)
				}
			}
		})
	}
}