package main

import (
	"bytes"
	"encoding/json"
	"os"
	"strings"
	"testing"

	"mxl-pattern-generator/internal/audio"
	"mxl-pattern-generator/internal/flowdef"
	"mxl-pattern-generator/internal/video"

	"github.com/spf13/pflag"
)

func TestAlphaFlag(t *testing.T) {
	var args appArgs
	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
	addFlags(flags, &args)
	if err := flags.Parse([]string{"--alpha"}); err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if !args.videoAlpha {
		t.Fatal("videoAlpha = false, want true")
	}
}

func TestParseArgsHelpStopsBeforeValidation(t *testing.T) {
	var stdout, stderr bytes.Buffer

	result, err := parseArgs([]string{"--help"}, &stdout, &stderr)
	if err != nil {
		t.Fatalf("parseArgs: %v", err)
	}
	if result.shouldRun {
		t.Fatal("shouldRun = true, want false")
	}
	if !result.args.showHelp {
		t.Fatal("showHelp = false, want true")
	}
	if !strings.Contains(stdout.String(), "Usage: mxl-gen") {
		t.Fatalf("help output does not contain usage: %q", stdout.String())
	}
	if stderr.Len() != 0 {
		t.Fatalf("stderr = %q, want empty", stderr.String())
	}
}

func TestParseArgsListPatternsStopsBeforeValidation(t *testing.T) {
	var stdout, stderr bytes.Buffer

	result, err := parseArgs([]string{"--list-patterns"}, &stdout, &stderr)
	if err != nil {
		t.Fatalf("parseArgs: %v", err)
	}
	if result.shouldRun {
		t.Fatal("shouldRun = true, want false")
	}
	if !result.args.listPatterns {
		t.Fatal("listPatterns = false, want true")
	}
	if !strings.Contains(stdout.String(), "ebu75") {
		t.Fatalf("pattern output does not contain ebu75: %q", stdout.String())
	}
	if stderr.Len() != 0 {
		t.Fatalf("stderr = %q, want empty", stderr.String())
	}
}

func TestParseArgsRejectsUnexpectedPositionalArguments(t *testing.T) {
	var stdout, stderr bytes.Buffer

	result, err := parseArgs([]string{"unexpected"}, &stdout, &stderr)
	if err == nil {
		t.Fatal("parseArgs returned nil error")
	}
	if result.shouldRun {
		t.Fatal("shouldRun = true, want false")
	}
	if !strings.Contains(err.Error(), "unexpected positional arguments") {
		t.Fatalf("error = %q", err)
	}
}

func TestParseArgsRejectsUnknownFlag(t *testing.T) {
	var stdout, stderr bytes.Buffer

	result, err := parseArgs([]string{"--not-a-flag"}, &stdout, &stderr)
	if err == nil {
		t.Fatal("parseArgs returned nil error")
	}
	if result.shouldRun {
		t.Fatal("shouldRun = true, want false")
	}
}

func TestValidateAudioArgsSkipsDisabledAudio(t *testing.T) {
	args := appArgs{
		audioChannels:     0,
		audioSamplingFreq: "unsupported",
		audioUUID:         "not-a-uuid",
	}

	if err := validateAudioArgs(&args); err != nil {
		t.Fatalf("validateAudioArgs: %v", err)
	}
	if args.audioUUID != "not-a-uuid" {
		t.Fatalf("audio UUID changed while audio is disabled: %q", args.audioUUID)
	}
}

func TestValidateVideoArgsSkipsDisabledVideo(t *testing.T) {
	args := appArgs{
		noVideo:    true,
		pattern:    "not-a-pattern",
		videoWidth: 1,
		videoFPS:   "unsupported",
		videoUUID:  "not-a-uuid",
	}

	if err := validateVideoArgs(&args); err != nil {
		t.Fatalf("validateVideoArgs: %v", err)
	}
	if args.videoUUID != "not-a-uuid" {
		t.Fatalf("video UUID changed while video is disabled: %q", args.videoUUID)
	}
}

func TestParseVideoBackend(t *testing.T) {
	tests := []struct {
		name    string
		value   string
		want    video.Backend
		wantErr bool
	}{
		{name: "zero value defaults to auto", want: video.BackendAuto},
		{name: "auto", value: "auto", want: video.BackendAuto},
		{name: "gpu", value: "gpu", want: video.BackendGPU},
		{name: "cpu", value: "cpu", want: video.BackendCPU},
		{name: "unknown", value: "other", wantErr: true},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			got, err := parseVideoBackend(tc.value)
			if tc.wantErr {
				if err == nil || !strings.Contains(err.Error(), "unsupported video backend") {
					t.Fatalf("error = %v, want unsupported backend error", err)
				}
				return
			}
			if err != nil {
				t.Fatalf("parseVideoBackend: %v", err)
			}
			if got != tc.want {
				t.Fatalf("backend = %q, want %q", got, tc.want)
			}
		})
	}
}

func TestValidateVideoArgsRejectsUnknownBackend(t *testing.T) {
	args := appArgs{videoBackend: "other"}
	if err := validateVideoArgs(&args); err == nil || !strings.Contains(err.Error(), "unsupported video backend") {
		t.Fatalf("error = %v, want unsupported backend error", err)
	}
}

func TestValidateMediaSelection(t *testing.T) {
	tests := []struct {
		name       string
		args       appArgs
		wantErrSub string
	}{
		{
			name:       "no video with video definition",
			args:       appArgs{noVideo: true, videoFlowDefFile: "video.json", audioChannels: 2},
			wantErrSub: "cannot be used with --video",
		},
		{
			name:       "no flows",
			args:       appArgs{noVideo: true},
			wantErrSub: "requires audio enabled",
		},
		{
			name: "generated audio only",
			args: appArgs{noVideo: true, audioChannels: 2},
		},
		{
			name: "external audio only",
			args: appArgs{noVideo: true, audioFlowDefFile: "audio.json"},
		},
		{
			name: "video enabled by default",
			args: appArgs{},
		},
		{
			name:       "alpha without video",
			args:       appArgs{noVideo: true, videoAlpha: true, audioChannels: 2},
			wantErrSub: "cannot be used with --no-video",
		},
		{
			name:       "alpha with custom video definition",
			args:       appArgs{videoAlpha: true, videoFlowDefFile: "video.json"},
			wantErrSub: "cannot be used with --video",
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			err := validateMediaSelection(tc.args)
			if tc.wantErrSub == "" {
				if err != nil {
					t.Fatalf("validateMediaSelection: %v", err)
				}
				return
			}
			if err == nil || !strings.Contains(err.Error(), tc.wantErrSub) {
				t.Fatalf("error = %v, want substring %q", err, tc.wantErrSub)
			}
		})
	}
}

func TestListPatternsIsSorted(t *testing.T) {
	var output bytes.Buffer
	listPatterns(&output)

	text := output.String()
	if strings.Index(text, "ebu100") > strings.Index(text, "ebu75") {
		t.Fatalf("patterns are not sorted: %q", text)
	}
}

func TestBuildVideoConfigFromArgs(t *testing.T) {
	args := appArgs{
		videoUUID:   "5fbec3b1-1b0f-417d-9059-8b94a47197ed",
		videoWidth:  1920,
		videoHeight: 1080,
		videoFPS:    "29.97",
		pattern:     "ebu75",
	}

	cfg, err := buildVideoConfig(args)
	if err != nil {
		t.Fatalf("buildVideoConfig: %v", err)
	}
	if cfg.Width() != 1920 || cfg.Height() != 1080 {
		t.Fatalf("dimensions = %dx%d, want 1920x1080", cfg.Width(), cfg.Height())
	}
	if cfg.Rate().Num != 30000 || cfg.Rate().Den != 1001 {
		t.Fatalf("rate = %d/%d, want 30000/1001", cfg.Rate().Num, cfg.Rate().Den)
	}
	if cfg.Backend != video.BackendAuto {
		t.Fatalf("backend = %q, want %q", cfg.Backend, video.BackendAuto)
	}
}

func TestBuildVideoConfigWithAlpha(t *testing.T) {
	cfg, err := buildVideoConfig(appArgs{
		videoUUID:   "5fbec3b1-1b0f-417d-9059-8b94a47197ed",
		videoWidth:  1280,
		videoHeight: 720,
		videoFPS:    "50",
		pattern:     "gray-ramp",
		videoAlpha:  true,
	})
	if err != nil {
		t.Fatalf("buildVideoConfig: %v", err)
	}
	if cfg.Definition.MediaType != flowdef.MediaTypeV210A {
		t.Fatalf("media type = %q, want %q", cfg.Definition.MediaType, flowdef.MediaTypeV210A)
	}
	if !cfg.HasAlpha() {
		t.Fatal("HasAlpha() = false, want true")
	}
}

func TestBuildVideoConfigBackends(t *testing.T) {
	for _, backend := range []video.Backend{video.BackendGPU, video.BackendCPU} {
		t.Run(string(backend), func(t *testing.T) {
			cfg, err := buildVideoConfig(appArgs{
				videoUUID:    "5fbec3b1-1b0f-417d-9059-8b94a47197ed",
				videoWidth:   1920,
				videoHeight:  1080,
				videoFPS:     "25",
				pattern:      "ebu75",
				videoBackend: string(backend),
			})
			if err != nil {
				t.Fatalf("buildVideoConfig: %v", err)
			}
			if cfg.Backend != backend {
				t.Fatalf("backend = %q, want %q", cfg.Backend, backend)
			}
		})
	}
}

func TestBuildVideoConfigDisabled(t *testing.T) {
	cfg, err := buildVideoConfig(appArgs{noVideo: true})
	if err != nil {
		t.Fatalf("buildVideoConfig: %v", err)
	}
	if cfg != nil {
		t.Fatalf("config = %+v, want nil for disabled video", cfg)
	}
}

func TestBuildVideoConfigFromFile(t *testing.T) {
	definition, err := flowdef.NewV210Video(
		"5fbec3b1-1b0f-417d-9059-8b94a47197ed",
		3840,
		2160,
		flowdef.Rational{Numerator: 60000, Denominator: 1001},
	)
	if err != nil {
		t.Fatalf("NewV210Video: %v", err)
	}
	data, err := json.Marshal(definition)
	if err != nil {
		t.Fatalf("json.Marshal: %v", err)
	}
	path := t.TempDir() + "/video.json"
	if err := os.WriteFile(path, data, 0o600); err != nil {
		t.Fatalf("os.WriteFile: %v", err)
	}

	cfg, err := buildVideoConfig(appArgs{
		videoFlowDefFile: path,
		pattern:          "smpte",
		// These values must be ignored when a definition file is supplied.
		videoWidth:  1920,
		videoHeight: 1080,
		videoFPS:    "25",
	})
	if err != nil {
		t.Fatalf("buildVideoConfig: %v", err)
	}
	if cfg.Width() != 3840 || cfg.Height() != 2160 {
		t.Fatalf("dimensions = %dx%d, want file values 3840x2160", cfg.Width(), cfg.Height())
	}
	if cfg.Rate().Num != 60000 || cfg.Rate().Den != 1001 {
		t.Fatalf("rate = %d/%d, want file value 60000/1001", cfg.Rate().Num, cfg.Rate().Den)
	}
}

func TestBuildAudioConfigDisabled(t *testing.T) {
	cfg, err := buildAudioConfig(appArgs{})
	if err != nil {
		t.Fatalf("buildAudioConfig: %v", err)
	}
	if cfg != nil {
		t.Fatalf("config = %+v, want nil for disabled audio", cfg)
	}
}

func TestBuildAudioConfigFromArgs(t *testing.T) {
	cfg, err := buildAudioConfig(appArgs{
		audioUUID:         "b3bb5be7-9fe9-4324-a5bb-4c70e1084449",
		audioChannels:     2,
		audioSamplingFreq: "48",
		audioLevel:        "ebu",
	})
	if err != nil {
		t.Fatalf("buildAudioConfig: %v", err)
	}
	if cfg == nil {
		t.Fatal("config is nil")
	}
	if cfg.Channels() != 2 {
		t.Fatalf("channels = %d, want 2", cfg.Channels())
	}
	if cfg.Rate().Num != 48000 || cfg.Rate().Den != 1 {
		t.Fatalf("rate = %d/%d, want 48000/1", cfg.Rate().Num, cfg.Rate().Den)
	}
	if cfg.LevelDBFS != audio.LevelEBUDBFS {
		t.Fatalf("level = %.2f dBFS, want %.2f dBFS", cfg.LevelDBFS, audio.LevelEBUDBFS)
	}
}

func TestBuildAudioConfigFromFile(t *testing.T) {
	definition, err := flowdef.NewFloat32Audio(
		"b3bb5be7-9fe9-4324-a5bb-4c70e1084449",
		8,
		flowdef.Rational{Numerator: 96000, Denominator: 1},
	)
	if err != nil {
		t.Fatalf("NewFloat32Audio: %v", err)
	}
	data, err := json.Marshal(definition)
	if err != nil {
		t.Fatalf("json.Marshal: %v", err)
	}
	path := t.TempDir() + "/audio.json"
	if err := os.WriteFile(path, data, 0o600); err != nil {
		t.Fatalf("os.WriteFile: %v", err)
	}

	cfg, err := buildAudioConfig(appArgs{
		audioFlowDefFile:  path,
		audioChannels:     2,
		audioSamplingFreq: "48",
		audioLevel:        "smpte",
	})
	if err != nil {
		t.Fatalf("buildAudioConfig: %v", err)
	}
	if cfg == nil {
		t.Fatal("config is nil")
	}
	if cfg.Channels() != 8 {
		t.Fatalf("channels = %d, want file value 8", cfg.Channels())
	}
	if cfg.Rate().Num != 96000 || cfg.Rate().Den != 1 {
		t.Fatalf("rate = %d/%d, want file value 96000/1", cfg.Rate().Num, cfg.Rate().Den)
	}
	if cfg.LevelDBFS != audio.LevelSMPTEDBFS {
		t.Fatalf("level = %.2f dBFS, want %.2f dBFS", cfg.LevelDBFS, audio.LevelSMPTEDBFS)
	}
}

func TestValidateAudioArgsRejectsUnknownLevelForFlowDefinition(t *testing.T) {
	args := appArgs{
		audioFlowDefFile: "audio.json",
		audioLevel:       "unknown",
	}

	err := validateAudioArgs(&args)
	if err == nil || !strings.Contains(err.Error(), "unsupported audio level") {
		t.Fatalf("error = %v, want unsupported audio level error", err)
	}
}