package main

import (
	"context"
	"errors"
	"strings"
	"sync/atomic"
	"testing"
	"time"

	"voicesnap/internal/config"
	"voicesnap/internal/engine"
	"voicesnap/internal/history"
	"voicesnap/internal/overlay"
	"voicesnap/internal/textoutput"
	"voicesnap/internal/userdict"
)

func TestLiveCaptionDisplayTextFitsOverlayBuffer(t *testing.T) {
	input := strings.Repeat("这是一句实时字幕", 12)
	got := liveCaptionDisplayText(input)
	if got == "" {
		t.Fatal("caption should not be empty")
	}
	if len([]byte(got)) > liveCaptionMaxBytes {
		t.Fatalf("caption bytes = %d, want <= %d", len([]byte(got)), liveCaptionMaxBytes)
	}
	if !strings.HasPrefix(got, "...") {
		t.Fatalf("caption = %q, want leading truncation marker", got)
	}
}

func TestReleaseTailCaptureDelayUsesEngineCapability(t *testing.T) {
	a := &App{}
	a.replaceEngine(tailCaptureTestEngine{delay: 300 * time.Millisecond})

	if got := a.releaseTailCaptureDelay(); got != 300*time.Millisecond {
		t.Fatalf("releaseTailCaptureDelay() = %v, want 300ms", got)
	}
}

func TestReleaseTailCaptureDelayCanBeDisabledByEngineCapability(t *testing.T) {
	a := &App{}
	a.replaceEngine(tailCaptureTestEngine{delay: 0})

	if got := a.releaseTailCaptureDelay(); got != 0 {
		t.Fatalf("releaseTailCaptureDelay() = %v, want 0", got)
	}
}

func TestReleaseTailCaptureDelayDefaultsToNoProtectionWindow(t *testing.T) {
	a := &App{}
	a.replaceEngine(plainTestEngine{})

	if got := a.releaseTailCaptureDelay(); got != 0 {
		t.Fatalf("releaseTailCaptureDelay() = %v, want 0", got)
	}
}

func TestReleaseTailCaptureDelayDisabledWithoutEngine(t *testing.T) {
	a := &App{}
	a.replaceEngine(nil)

	if got := a.releaseTailCaptureDelay(); got != 0 {
		t.Fatalf("releaseTailCaptureDelay() = %v, want 0 without engine", got)
	}
}

func TestSlowRecognitionReason(t *testing.T) {
	tests := []struct {
		name        string
		recognizeMS int64
		totalMS     int64
		want        string
	}{
		{name: "fast", recognizeMS: 2000, totalMS: 2500, want: ""},
		{name: "recognize", recognizeMS: 2001, totalMS: 2400, want: "recognize"},
		{name: "total", recognizeMS: 1000, totalMS: 2501, want: "total"},
		{name: "both", recognizeMS: 2001, totalMS: 2501, want: "recognize,total"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := slowRecognitionReason(tt.recognizeMS, tt.totalMS); got != tt.want {
				t.Fatalf("slowRecognitionReason(%d, %d) = %q, want %q", tt.recognizeMS, tt.totalMS, got, tt.want)
			}
		})
	}
}

func TestHoldPreCaptureUsesEngineCapability(t *testing.T) {
	a := &App{}
	a.replaceEngine(holdPreCaptureTestEngine{enabled: true})

	if !a.holdPreCaptureEnabled.Load() {
		t.Fatal("hold pre-capture should be enabled by engine capability")
	}
}

func TestHoldPreCaptureCanBeDisabledByEngineCapability(t *testing.T) {
	a := &App{}
	a.replaceEngine(holdPreCaptureTestEngine{enabled: false})

	if a.holdPreCaptureEnabled.Load() {
		t.Fatal("hold pre-capture should respect engine capability false")
	}
}

func TestHoldPreCaptureDefaultsToTrueForReadyEngine(t *testing.T) {
	a := &App{}
	a.replaceEngine(plainTestEngine{})

	if !a.holdPreCaptureEnabled.Load() {
		t.Fatal("hold pre-capture should default to true for ready engines")
	}
}

func TestHoldPreCaptureDisabledWithoutEngine(t *testing.T) {
	a := &App{}
	a.replaceEngine(nil)

	if a.holdPreCaptureEnabled.Load() {
		t.Fatal("hold pre-capture should be disabled without an engine")
	}
}

func TestHasEngineReflectsCurrentEngine(t *testing.T) {
	a := &App{}
	if a.hasEngine() {
		t.Fatal("new app should not report an engine")
	}

	a.replaceEngine(plainTestEngine{})
	if !a.hasEngine() {
		t.Fatal("app should report an engine after replaceEngine")
	}

	a.replaceEngine(nil)
	if a.hasEngine() {
		t.Fatal("app should not report an engine after clearing")
	}
}

func TestInitEngineSerializesAndDiscardsStaleEngine(t *testing.T) {
	first := &closeTrackingTestEngine{name: "first"}
	second := &closeTrackingTestEngine{name: "second"}
	firstStarted := make(chan struct{})
	allowFirst := make(chan struct{})
	calls := atomic.Int32{}

	a := &App{
		engineFactory: func(initID uint64) (engine.Engine, engineMetadata, bool, error) {
			call := calls.Add(1)
			switch call {
			case 1:
				close(firstStarted)
				<-allowFirst
				return first, engineMetadata{InitID: initID, ResolvedModelID: "first", HardwareInfo: "first"}, true, nil
			case 2:
				return second, engineMetadata{InitID: initID, ResolvedModelID: "second", HardwareInfo: "second"}, true, nil
			default:
				t.Fatalf("unexpected engine factory call %d", call)
				return nil, engineMetadata{}, false, nil
			}
		},
	}

	doneFirst := make(chan struct{})
	go func() {
		a.initEngine()
		close(doneFirst)
	}()

	select {
	case <-firstStarted:
	case <-time.After(time.Second):
		t.Fatal("first engine init did not start")
	}

	doneSecond := make(chan struct{})
	go func() {
		a.initEngine()
		close(doneSecond)
	}()

	waitForCondition(t, time.Second, func() bool {
		return a.engineInitSeq.Load() == 2
	})
	close(allowFirst)

	select {
	case <-doneFirst:
	case <-time.After(time.Second):
		t.Fatal("first engine init did not finish")
	}
	select {
	case <-doneSecond:
	case <-time.After(time.Second):
		t.Fatal("second engine init did not finish")
	}

	a.engineMu.Lock()
	gotEngine := a.eng
	gotMeta := a.engineMeta
	a.engineMu.Unlock()

	if gotEngine != second {
		t.Fatalf("final engine = %#v, want second", gotEngine)
	}
	if !first.closed.Load() {
		t.Fatal("stale first engine should be closed")
	}
	if second.closed.Load() {
		t.Fatal("current second engine should remain open")
	}
	if gotMeta.ResolvedModelID != "second" || gotMeta.InitID != 2 {
		t.Fatalf("engine metadata = %+v, want second init metadata", gotMeta)
	}
}

func waitForCondition(t *testing.T, timeout time.Duration, fn func() bool) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		if fn() {
			return
		}
		time.Sleep(10 * time.Millisecond)
	}
	t.Fatal("condition was not met before timeout")
}

func TestShouldStartHoldPreCaptureLocked(t *testing.T) {
	a := &App{}
	a.holdPreCaptureEnabled.Store(true)

	if !a.shouldStartHoldPreCaptureLocked() {
		t.Fatal("expected hold pre-capture to start when enabled and idle")
	}

	a.isRecording = true
	if a.shouldStartHoldPreCaptureLocked() {
		t.Fatal("should not pre-capture while already recording")
	}
	a.isRecording = false

	a.isStoppingRecording = true
	if a.shouldStartHoldPreCaptureLocked() {
		t.Fatal("should not pre-capture while stopping")
	}
	a.isStoppingRecording = false

	a.isFreetalking = true
	if a.shouldStartHoldPreCaptureLocked() {
		t.Fatal("should not pre-capture while tap recording is active")
	}
	a.isFreetalking = false

	a.lastStopTime = time.Now()
	if a.shouldStartHoldPreCaptureLocked() {
		t.Fatal("should not pre-capture during post-stop debounce")
	}
}

func TestHoldPreCaptureAutoConfirmsWithoutAdditionalKeyDown(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.hotkeyActive
	})

	if got := a.recorder.(*fakeAppRecorder).starts.Load(); got != 1 {
		t.Fatalf("recorder starts = %d, want 1", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusRecording) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusRecording)
	}
}

func TestHoldPreCaptureTimerConfirmsWhileRecorderStartBlocked(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return recorder.starts.Load() == 1
	})
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.hotkeyActive
	})

	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusRecording) {
		t.Fatalf("indicator status = %q, want %q while recorder start is blocked", got, overlay.StatusRecording)
	}
	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isHoldRecorderStarting
	})
}

func TestHoldPreCaptureReleaseAfterConfirmRunsRecognitionWhileRecorderStartBlocked(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart
	recorder.samples = []float32{0.2, 0.1, -0.1, -0.2}
	recorder.hasVoice.Store(true)
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return paster.pasted.Load() == "PrivateVoice AX POC"
	})

	if got := recorder.stopAndGetSamples.Load(); got != 1 {
		t.Fatalf("StopAndGetSamples while recorder start is blocked = %d, want 1", got)
	}
	if got := eng.recognizes.Load(); got != 1 {
		t.Fatalf("recognizes = %d, want 1", got)
	}
	a.mu.Lock()
	if a.isHoldStopPending {
		t.Fatal("normal release while recorder is starting should not mark cancel-style pending stop")
	}
	a.mu.Unlock()

	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
	if got := recorder.stops.Load(); got != 0 {
		t.Fatalf("app-level fake recorder stops = %d, want 0; native cleanup is covered by audio recorder tests", got)
	}
}

func TestHoldPreCaptureReleaseAfterConfirmRunsRecognitionBeforeRecorderStartEntered(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	preStartBlock := make(chan struct{})
	recorder.preStartBlock = preStartBlock
	recorder.samples = []float32{0.2, 0.1, -0.1, -0.2}
	recorder.hasVoice.Store(true)
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})
	if got := recorder.starts.Load(); got != 0 {
		t.Fatalf("recorder Start entered before release = %d, want 0", got)
	}

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return paster.pasted.Load() == "PrivateVoice AX POC"
	})
	if got := recorder.stopAndGetSamples.Load(); got != 1 {
		t.Fatalf("StopAndGetSamples before recorder Start entered = %d, want 1", got)
	}
	if got := eng.recognizes.Load(); got != 1 {
		t.Fatalf("recognizes = %d, want 1", got)
	}

	close(preStartBlock)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
	if got := recorder.stops.Load(); got != 0 {
		t.Fatalf("app-level fake recorder stops = %d, want 0 for normal release pipeline", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusDone) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusDone)
	}
}

func TestHoldPreCaptureReleaseWaitsForStartupSamplesBeforeRecognition(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	readSamplesReady := make(chan struct{})
	recorder.startBlock = blockStart
	recorder.readSamplesBlock = readSamplesReady
	recorder.samples = []float32{0.2, 0.1, -0.1, -0.2}
	recorder.hasVoice.Store(true)
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	time.Sleep(holdStartupSamplePollInterval * 2)
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples before startup samples = %d, want 0", got)
	}
	if got := eng.recognizes.Load(); got != 0 {
		t.Fatalf("recognizes before startup samples = %d, want 0", got)
	}

	close(readSamplesReady)
	waitForCondition(t, time.Second, func() bool {
		return paster.pasted.Load() == "PrivateVoice AX POC"
	})
	if got := recorder.stopAndGetSamples.Load(); got != 1 {
		t.Fatalf("StopAndGetSamples after startup samples = %d, want 1", got)
	}
	if got := eng.recognizes.Load(); got != 1 {
		t.Fatalf("recognizes = %d, want 1", got)
	}

	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
}

func TestHoldPreCaptureReleaseWithoutStartupSamplesReportsAudioNotReady(t *testing.T) {
	oldTimeout := holdStartupSampleWaitTimeout
	oldPoll := holdStartupSamplePollInterval
	holdStartupSampleWaitTimeout = 40 * time.Millisecond
	holdStartupSamplePollInterval = 5 * time.Millisecond
	defer func() {
		holdStartupSampleWaitTimeout = oldTimeout
		holdStartupSamplePollInterval = oldPoll
	}()

	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return recorder.stops.Load() == 1 &&
			a.indicator.(*fakeOverlay).lastStatus.Load() == string(overlay.StatusError)
	})
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples after audio-not-ready timeout = %d, want 0", got)
	}
	if got := eng.recognizes.Load(); got != 0 {
		t.Fatalf("recognizes after audio-not-ready timeout = %d, want 0", got)
	}
	if got := paster.pasted.Load(); got != nil {
		t.Fatalf("pasted text after audio-not-ready timeout = %v, want nil", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusError) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusError)
	}

	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
}

func TestHoldPreCaptureReleaseWhileRecorderPermissionPendingDoesNotRecognize(t *testing.T) {
	oldTimeout := holdStartupSampleWaitTimeout
	oldPoll := holdStartupSamplePollInterval
	holdStartupSampleWaitTimeout = 40 * time.Millisecond
	holdStartupSamplePollInterval = 5 * time.Millisecond
	defer func() {
		holdStartupSampleWaitTimeout = oldTimeout
		holdStartupSamplePollInterval = oldPoll
	}()

	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	preStartBlock := make(chan struct{})
	recorder.preStartBlock = preStartBlock
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})
	if got := recorder.starts.Load(); got != 0 {
		t.Fatalf("recorder Start entered before permission pending release = %d, want 0", got)
	}

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return recorder.stops.Load() == 1 &&
			a.indicator.(*fakeOverlay).lastStatus.Load() == string(overlay.StatusError)
	})
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples after permission-pending audio-not-ready = %d, want 0", got)
	}
	if got := eng.recognizes.Load(); got != 0 {
		t.Fatalf("recognizes after permission-pending audio-not-ready = %d, want 0", got)
	}
	if got := paster.pasted.Load(); got != nil {
		t.Fatalf("pasted text after permission-pending audio-not-ready = %v, want nil", got)
	}

	close(preStartBlock)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
	if got := recorder.starts.Load(); got != 1 {
		t.Fatalf("recorder Start after permission resumes = %d, want 1", got)
	}
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder stops after late permission success = %d, want 1", got)
	}
}

func TestHoldPreCaptureEscapeAfterConfirmDefersStopUntilRecorderStart(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart
	captionCancelled := false

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})

	a.mu.Lock()
	a.liveCaptionCancel = func() { captionCancelled = true }
	a.mu.Unlock()
	listener.escapeDown.Store(true)

	done := make(chan struct{})
	go func() {
		a.pollHotkey()
		close(done)
	}()
	select {
	case <-done:
	case <-time.After(100 * time.Millisecond):
		t.Fatal("Escape cancel should not wait for blocked recorder start")
	}

	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder stops before start returned = %d, want 1", got)
	}
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples before recorder start returned = %d, want 0", got)
	}
	a.mu.Lock()
	if !a.isHoldStopPending {
		t.Fatal("Escape while recorder is starting should mark pending stop")
	}
	if a.liveCaptionCancel != nil {
		t.Fatal("Escape while recorder is starting should clear live caption")
	}
	a.mu.Unlock()
	if !captionCancelled {
		t.Fatal("Escape while recorder is starting should cancel live caption")
	}

	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})

	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples after deferred Escape stop = %d, want 0", got)
	}
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder stops = %d, want 1", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusCancelled) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusCancelled)
	}
}

func TestPollHotkeyIgnoresUnsetHotkey(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	a.cfg.HotkeyVK = config.UnsetHotkeyVK

	a.pollHotkey()

	if got := listener.keyChecks.Load(); got != 0 {
		t.Fatalf("IsKeyDown calls for unset hotkey = %d, want 0", got)
	}
	if a.hotkeyActive {
		t.Fatal("unset hotkey must not become active")
	}
	if a.isRecording || a.isFreetalking {
		t.Fatal("unset hotkey must not start recording")
	}
}

func TestHoldPreCaptureEscapeWhileRecorderPermissionPendingStopsLateStart(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	preStartBlock := make(chan struct{})
	recorder.preStartBlock = preStartBlock
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})
	if got := recorder.starts.Load(); got != 0 {
		t.Fatalf("recorder Start entered before Escape during permission pending = %d, want 0", got)
	}

	listener.escapeDown.Store(true)
	done := make(chan struct{})
	go func() {
		a.pollHotkey()
		close(done)
	}()
	select {
	case <-done:
	case <-time.After(100 * time.Millisecond):
		t.Fatal("Escape during permission pending should not wait for recorder Start")
	}
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder Stop during permission-pending Escape = %d, want 1", got)
	}
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples during permission-pending Escape = %d, want 0", got)
	}
	if got := eng.recognizes.Load(); got != 0 {
		t.Fatalf("recognizes during permission-pending Escape = %d, want 0", got)
	}

	close(preStartBlock)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder stops after late permission success = %d, want 1", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusCancelled) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusCancelled)
	}
}

func TestHoldPreCaptureCombinationWhileRecorderPermissionPendingStopsLateStart(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	preStartBlock := make(chan struct{})
	recorder.preStartBlock = preStartBlock
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()
	listener.otherSince.Store(true)

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isCombination && !a.isRecording && !a.isHoldRecordingPending && a.isHoldStopPending
	})
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder Stop during permission-pending combination cancel = %d, want 1", got)
	}
	if got := recorder.stopAndGetSamples.Load(); got != 0 {
		t.Fatalf("StopAndGetSamples during permission-pending combination cancel = %d, want 0", got)
	}
	if got := eng.recognizes.Load(); got != 0 {
		t.Fatalf("recognizes during permission-pending combination cancel = %d, want 0", got)
	}

	close(preStartBlock)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && !a.isHoldStopPending
	})
	if got := recorder.stops.Load(); got != 1 {
		t.Fatalf("recorder stops after late combination permission success = %d, want 1", got)
	}
}

func TestHoldPreCaptureReleaseAfterRecorderStartRunsRecognitionAndOutput(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	recorder.samples = []float32{0.2, 0.1, -0.1, -0.2}
	recorder.hasVoice.Store(true)
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && !a.isHoldRecorderStarting
	})

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return paster.pasted.Load() == "PrivateVoice AX POC"
	})

	if got := recorder.stopAndGetSamples.Load(); got != 1 {
		t.Fatalf("StopAndGetSamples = %d, want 1", got)
	}
	if got := eng.recognizes.Load(); got != 1 {
		t.Fatalf("recognizes = %d, want 1", got)
	}
	if got := recorder.stops.Load(); got != 0 {
		t.Fatalf("recorder Stop = %d, want 0 for normal recognition path", got)
	}
}

func TestHoldPreCaptureReleasePipelineSuppressesLateRecorderStartError(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	listener := a.hk.(*fakeHotkeyListener)
	listener.down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart
	recorder.startErr = errors.New("start failed")
	recorder.samples = []float32{0.2, 0.1, -0.1, -0.2}
	recorder.hasVoice.Store(true)
	eng := &recognizingHoldEngine{text: "PrivateVoice AX POC"}
	a.replaceEngine(eng)
	paster := &fakeAppPaster{}
	a.outputRouter = textoutput.NewRouter(paster)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting
	})

	listener.down.Store(false)
	a.mu.Lock()
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		return paster.pasted.Load() == "PrivateVoice AX POC"
	})
	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isHoldRecorderStarting
	})

	if got := eng.recognizes.Load(); got != 1 {
		t.Fatalf("recognizes = %d, want 1", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusDone) {
		t.Fatalf("late recorder start error overwrote indicator status = %q, want %q", got, overlay.StatusDone)
	}
}

func TestHoldPreCaptureRecorderStartLateErrorCleansConfirmedState(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)
	recorder := a.recorder.(*fakeAppRecorder)
	blockStart := make(chan struct{})
	recorder.startBlock = blockStart
	recorder.startErr = errors.New("start failed")
	captionCancelled := false
	a.liveCaptionCancel = func() { captionCancelled = true }

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isRecording && !a.isHoldRecordingPending && a.isHoldRecorderStarting && a.liveCaptionCancel != nil
	})

	close(blockStart)
	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecorderStarting && a.liveCaptionCancel == nil
	})

	if !captionCancelled {
		t.Fatal("late recorder start error should cancel live caption")
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got != string(overlay.StatusError) {
		t.Fatalf("indicator status = %q, want %q", got, overlay.StatusError)
	}
}

func TestHoldPreCaptureReleaseBeforeActivationCancelsTimer(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.hk.(*fakeHotkeyListener).down.Store(false)
	a.pollHoldHotkeyLocked(false, true)
	a.mu.Unlock()

	time.Sleep(holdActivationDelay + 50*time.Millisecond)

	a.mu.Lock()
	defer a.mu.Unlock()
	if a.isRecording || a.isHoldRecordingPending {
		t.Fatalf("recording=%t pending=%t, want both false after early release", a.isRecording, a.isHoldRecordingPending)
	}
	if got := a.recorder.(*fakeAppRecorder).stops.Load(); got != 1 {
		t.Fatalf("recorder stops = %d, want 1", got)
	}
}

func TestHoldPreCaptureTimerCancelsWhenKeyReleasedBeforePoll(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	a.hk.(*fakeHotkeyListener).down.Store(false)

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return !a.isRecording && !a.isHoldRecordingPending
	})

	a.mu.Lock()
	defer a.mu.Unlock()
	if a.hotkeyActive != true {
		t.Fatal("hotkeyActive should remain true until release poll handles the key-up")
	}
	if got := a.recorder.(*fakeAppRecorder).stops.Load(); got != 1 {
		t.Fatalf("recorder stops = %d, want 1", got)
	}
	if got := a.indicator.(*fakeOverlay).lastStatus.Load(); got == string(overlay.StatusRecording) {
		t.Fatalf("indicator status = %q, should not confirm recording after physical release", got)
	}
}

func TestHoldPreCaptureCombinationBeforeActivationCancels(t *testing.T) {
	a, cleanup := newHoldPreCaptureTestApp()
	defer cleanup()
	a.hk.(*fakeHotkeyListener).down.Store(true)

	a.mu.Lock()
	a.pollHoldHotkeyLocked(true, true)
	a.mu.Unlock()

	a.hk.(*fakeHotkeyListener).otherSince.Store(true)

	waitForCondition(t, time.Second, func() bool {
		a.mu.Lock()
		defer a.mu.Unlock()
		return a.isCombination && !a.isRecording && !a.isHoldRecordingPending
	})

	if got := a.recorder.(*fakeAppRecorder).stops.Load(); got != 1 {
		t.Fatalf("recorder stops = %d, want 1", got)
	}
}

func TestStartRecordingIgnoredWhileStoppingRecording(t *testing.T) {
	a := &App{isStoppingRecording: true}

	a.startRecordingLocked()

	if a.isRecording {
		t.Fatal("startRecordingLocked should not start while stop tail capture is pending")
	}
}

func TestStartTapRecordingIgnoredWhileStoppingRecording(t *testing.T) {
	a := &App{isStoppingRecording: true}

	a.startTapRecordingLocked()

	if a.isRecording || a.isFreetalking {
		t.Fatal("startTapRecordingLocked should not start while stop tail capture is pending")
	}
}

type plainTestEngine struct{}

func (plainTestEngine) Recognize([]float32) (string, error) { return "", nil }
func (plainTestEngine) HardwareInfo() string                { return "test" }
func (plainTestEngine) Close()                              {}

type closeTrackingTestEngine struct {
	plainTestEngine
	name   string
	closed atomic.Bool
}

func (e *closeTrackingTestEngine) HardwareInfo() string { return e.name }
func (e *closeTrackingTestEngine) Close()               { e.closed.Store(true) }

type tailCaptureTestEngine struct {
	plainTestEngine
	delay time.Duration
}

func (e tailCaptureTestEngine) ReleaseTailCaptureDelay() time.Duration {
	return e.delay
}

type holdPreCaptureTestEngine struct {
	plainTestEngine
	enabled bool
}

func (e holdPreCaptureTestEngine) HoldPreCaptureEnabled() bool {
	return e.enabled
}

func newHoldPreCaptureTestApp() (*App, context.CancelFunc) {
	ctx, cancel := context.WithCancel(context.Background())
	a := &App{
		ctx:       ctx,
		cancel:    cancel,
		cfg:       &config.Config{HotkeyVK: 0x5C, HotkeyMode: config.HotkeyModeHold},
		recorder:  &fakeAppRecorder{},
		hk:        &fakeHotkeyListener{},
		indicator: &fakeOverlay{},
		history:   history.New(),
		userdict:  userdict.New(),
	}
	a.replaceEngine(holdPreCaptureTestEngine{enabled: true})
	a.holdPreCaptureEnabled.Store(true)
	return a, cancel
}

type fakeAppRecorder struct {
	starts            atomic.Int32
	stops             atomic.Int32
	stopAndGetSamples atomic.Int32
	hasVoice          atomic.Bool
	samples           []float32
	preStartBlock     <-chan struct{}
	startBlock        <-chan struct{}
	readSamplesBlock  <-chan struct{}
	startErr          error
}

func (r *fakeAppRecorder) OnVolume(func(float64))      {}
func (r *fakeAppRecorder) OnDeviceChange(func(string)) {}
func (r *fakeAppRecorder) Start() error {
	if r.preStartBlock != nil {
		<-r.preStartBlock
	}
	r.starts.Add(1)
	if r.startBlock != nil {
		<-r.startBlock
	}
	return r.startErr
}
func (r *fakeAppRecorder) Stop() { r.stops.Add(1) }
func (r *fakeAppRecorder) StopAndGetSamples() []float32 {
	r.stopAndGetSamples.Add(1)
	return append([]float32(nil), r.samples...)
}
func (r *fakeAppRecorder) HasVoiceActivity() bool { return r.hasVoice.Load() }
func (r *fakeAppRecorder) ReadSamplesSince(offset int) ([]float32, int) {
	if r.readSamplesBlock != nil {
		select {
		case <-r.readSamplesBlock:
		default:
			return nil, 0
		}
	}
	total := len(r.samples)
	if offset < 0 {
		offset = 0
	}
	if offset > total {
		offset = total
	}
	return append([]float32(nil), r.samples[offset:]...), total
}
func (r *fakeAppRecorder) Close() {}

type recognizingHoldEngine struct {
	text       string
	recognizes atomic.Int32
}

func (e *recognizingHoldEngine) Recognize([]float32) (string, error) {
	e.recognizes.Add(1)
	return e.text, nil
}
func (e *recognizingHoldEngine) HardwareInfo() string        { return "test" }
func (e *recognizingHoldEngine) Close()                      {}
func (e *recognizingHoldEngine) HoldPreCaptureEnabled() bool { return true }

type fakeAppPaster struct {
	pasted atomic.Value
	typed  atomic.Value
}

func (p *fakeAppPaster) Paste(text string, keepClipboard bool) error {
	p.pasted.Store(text)
	return nil
}

func (p *fakeAppPaster) TypeText(text string) error {
	p.typed.Store(text)
	return nil
}

type fakeHotkeyListener struct {
	down       atomic.Bool
	escapeDown atomic.Bool
	otherSince atomic.Bool
	keyChecks  atomic.Int32
}

func (h *fakeHotkeyListener) IsKeyDown(key int) bool {
	h.keyChecks.Add(1)
	if key == 0x1B {
		return h.escapeDown.Load()
	}
	return h.down.Load()
}
func (h *fakeHotkeyListener) IsAnyOtherKeyPressed(int) bool { return false }
func (h *fakeHotkeyListener) IsAnyOtherKeyPressedSince(int, time.Time) bool {
	return h.otherSince.Load()
}
func (h *fakeHotkeyListener) Close() {}

type fakeOverlay struct {
	lastStatus atomic.Value
}

func (o *fakeOverlay) Show() {}
func (o *fakeOverlay) Hide() {}
func (o *fakeOverlay) SetStatus(status overlay.Status, text string) {
	o.lastStatus.Store(string(status))
}
func (o *fakeOverlay) SetVolume(float64)        {}
func (o *fakeOverlay) SetPosition(int, int)     {}
func (o *fakeOverlay) GetPosition() (int, int)  { return 0, 0 }
func (o *fakeOverlay) Size() (int, int)         { return 170, 48 }
func (o *fakeOverlay) OnDragged(func(int, int)) {}
func (o *fakeOverlay) Close()                   {}
func (o *fakeOverlay) AutoPosition()            {}