package audio

import (
	"errors"
	"os"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/gen2brain/malgo"
)

func TestMain(m *testing.M) {
	oldEnsure := ensureMicrophoneAuthorization
	ensureMicrophoneAuthorization = func() microphoneAuthorization {
		return microphoneAuthorization{granted: true, state: "granted"}
	}
	code := m.Run()
	ensureMicrophoneAuthorization = oldEnsure
	os.Exit(code)
}

func TestReadSamplesSinceReturnsOnlyNewSamples(t *testing.T) {
	r := &Recorder{
		pcmBuf: pcm16LE(0, 16384, -32768),
	}

	samples, nextOffset := r.ReadSamplesSince(1)
	if nextOffset != 3 {
		t.Fatalf("next offset = %d, want 3", nextOffset)
	}
	if len(samples) != 2 {
		t.Fatalf("sample count = %d, want 2", len(samples))
	}
	if samples[0] != 0.5 {
		t.Fatalf("samples[0] = %f, want 0.5", samples[0])
	}
	if samples[1] != -1 {
		t.Fatalf("samples[1] = %f, want -1", samples[1])
	}
}

func TestReadSamplesSinceClampsOffset(t *testing.T) {
	r := &Recorder{
		pcmBuf: pcm16LE(0, 16384),
	}

	samples, nextOffset := r.ReadSamplesSince(99)
	if nextOffset != 2 {
		t.Fatalf("next offset = %d, want 2", nextOffset)
	}
	if len(samples) != 0 {
		t.Fatalf("sample count = %d, want 0", len(samples))
	}
}

func TestOnDataCapsRecordingBuffer(t *testing.T) {
	r := &Recorder{
		isRecording: true,
		pcmBuf:      make([]byte, maxPCMBufferBytes-2),
	}

	r.onData(pcm16LE(1, 2))

	if got := len(r.pcmBuf); got != maxPCMBufferBytes {
		t.Fatalf("pcm buffer length = %d, want capped %d", got, maxPCMBufferBytes)
	}
	if !r.bufferLimitHit {
		t.Fatal("bufferLimitHit should be set after truncating at cap")
	}

	r.onData(pcm16LE(3))
	if got := len(r.pcmBuf); got != maxPCMBufferBytes {
		t.Fatalf("pcm buffer length after cap = %d, want %d", got, maxPCMBufferBytes)
	}
}

func TestStartWithoutMicrophonePermissionDoesNotInitializeDevice(t *testing.T) {
	oldEnsure := ensureMicrophoneAuthorization
	ensureMicrophoneAuthorization = func() microphoneAuthorization {
		return microphoneAuthorization{granted: false, state: "denied"}
	}
	defer func() {
		ensureMicrophoneAuthorization = oldEnsure
	}()

	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	err := r.Start()
	if err == nil {
		t.Fatal("Start returned nil without microphone permission")
	}
	if ctx.initEntered.Load() {
		t.Fatal("initDevice should not run without microphone permission")
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not run without microphone permission")
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if r.startRequested || r.isStarting || r.isRecording || r.stopAfterStart || r.device != nil {
		t.Fatalf("recorder state leaked after microphone denial: startRequested=%t isStarting=%t isRecording=%t stopAfterStart=%t deviceNil=%t",
			r.startRequested, r.isStarting, r.isRecording, r.stopAfterStart, r.device == nil)
	}
}

func TestStopWhileMicrophoneAuthorizationPendingPreventsNativeStart(t *testing.T) {
	oldEnsure := ensureMicrophoneAuthorization
	entered := make(chan struct{})
	allow := make(chan struct{})
	var enteredOnce sync.Once
	ensureMicrophoneAuthorization = func() microphoneAuthorization {
		enteredOnce.Do(func() { close(entered) })
		<-allow
		return microphoneAuthorization{granted: true, state: "granted"}
	}
	defer func() {
		ensureMicrophoneAuthorization = oldEnsure
	}()

	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	select {
	case <-entered:
	case <-time.After(time.Second):
		t.Fatal("microphone authorization was not entered")
	}

	r.Stop()
	close(allow)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	if ctx.initEntered.Load() {
		t.Fatal("initDevice should not run after Stop during microphone authorization")
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not run after Stop during microphone authorization")
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if r.startRequested || r.isStarting || r.isRecording || r.stopAfterStart || r.device != nil {
		t.Fatalf("recorder state leaked after pending authorization stop: startRequested=%t isStarting=%t isRecording=%t stopAfterStart=%t deviceNil=%t",
			r.startRequested, r.isStarting, r.isRecording, r.stopAfterStart, r.device == nil)
	}
}

func TestStopAndGetSamplesWhileMicrophoneAuthorizationPendingPreventsNativeStart(t *testing.T) {
	oldEnsure := ensureMicrophoneAuthorization
	entered := make(chan struct{})
	allow := make(chan struct{})
	var enteredOnce sync.Once
	ensureMicrophoneAuthorization = func() microphoneAuthorization {
		enteredOnce.Do(func() { close(entered) })
		<-allow
		return microphoneAuthorization{granted: true, state: "granted"}
	}
	defer func() {
		ensureMicrophoneAuthorization = oldEnsure
	}()

	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	select {
	case <-entered:
	case <-time.After(time.Second):
		t.Fatal("microphone authorization was not entered")
	}

	samples := r.StopAndGetSamples()
	if len(samples) != 0 {
		t.Fatalf("samples while microphone authorization pending = %d, want 0", len(samples))
	}
	close(allow)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	if ctx.initEntered.Load() {
		t.Fatal("initDevice should not run after StopAndGetSamples during microphone authorization")
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not run after StopAndGetSamples during microphone authorization")
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if r.startRequested || r.isStarting || r.isRecording || r.stopAfterStart || r.device != nil {
		t.Fatalf("recorder state leaked after pending authorization samples stop: startRequested=%t isStarting=%t isRecording=%t stopAfterStart=%t deviceNil=%t",
			r.startRequested, r.isStarting, r.isRecording, r.stopAfterStart, r.device == nil)
	}
}

func TestCloseWaitsForBlockedStartBeforeFreeingContext(t *testing.T) {
	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return device.startEntered.Load() })

	closeDone := make(chan struct{})
	go func() {
		r.Close()
		close(closeDone)
	}()

	select {
	case <-closeDone:
		t.Fatal("Close returned while recorder Start was still blocked")
	case <-time.After(50 * time.Millisecond):
	}
	if got := ctx.freeCount.Load(); got != 0 {
		t.Fatalf("context freed before Start returned = %d, want 0", got)
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninitialized before Start returned = %d, want 0", got)
	}

	close(device.allowStart)
	if err := <-startDone; err == nil {
		t.Fatal("Start returned nil after Close was requested during startup")
	}
	waitForRecorderTest(t, func() bool {
		select {
		case <-closeDone:
			return true
		default:
			return false
		}
	})
	if got := ctx.freeCount.Load(); got != 1 {
		t.Fatalf("context free count = %d, want 1", got)
	}
	if got := device.stopCount.Load(); got != 1 {
		t.Fatalf("device stop count = %d, want 1", got)
	}
	if got := device.uninitCount.Load(); got != 1 {
		t.Fatalf("device uninit count = %d, want 1", got)
	}
}

func TestStopWhileStartBlockedDefersDeviceCleanup(t *testing.T) {
	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return device.startEntered.Load() })

	stopDone := make(chan struct{})
	go func() {
		r.Stop()
		close(stopDone)
	}()

	select {
	case <-stopDone:
	case <-time.After(time.Second):
		t.Fatal("Stop should return while recorder Start is still blocked")
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stopped before Start returned = %d, want 0", got)
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninitialized before Start returned = %d, want 0", got)
	}

	close(device.allowStart)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	waitForRecorderTest(t, func() bool { return device.uninitCount.Load() == 1 })
	if got := device.stopCount.Load(); got != 1 {
		t.Fatalf("device stop count = %d, want 1", got)
	}
}

func TestStopAndGetSamplesWhileStartBlockedReturnsBufferedPCM(t *testing.T) {
	device := newFakeRecorderDevice()
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return device.startEntered.Load() })

	r.onData(pcm16LE(16384, -32768))
	samples := r.StopAndGetSamples()
	if len(samples) != 2 {
		t.Fatalf("samples len = %d, want 2", len(samples))
	}
	if samples[0] != 0.5 || samples[1] != -1 {
		t.Fatalf("samples = %#v, want [0.5 -1]", samples)
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stopped before Start returned = %d, want 0", got)
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninitialized before Start returned = %d, want 0", got)
	}

	close(device.allowStart)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	if got := device.stopCount.Load(); got != 1 {
		t.Fatalf("device stop count after Start returned = %d, want 1", got)
	}
	if got := device.uninitCount.Load(); got != 1 {
		t.Fatalf("device uninit count after Start returned = %d, want 1", got)
	}
}

func TestStopAndGetSamplesBeforeDevicePublishDefersIntentAndCleansInitializedDevice(t *testing.T) {
	device := newFakeRecorderDevice()
	initBlock := make(chan struct{})
	ctx := &fakeRecorderContext{device: device, initBlock: initBlock}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return ctx.initEntered.Load() })

	samples := r.StopAndGetSamples()
	if len(samples) != 0 {
		t.Fatalf("samples len before device publish = %d, want 0", len(samples))
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not be entered while initDevice is blocked")
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stopped before it was published = %d, want 0", got)
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninit before initDevice returned = %d, want 0", got)
	}

	close(initBlock)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not run after stop intent arrived before publish")
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stop count = %d, want 0 for never-started device", got)
	}
	if got := device.uninitCount.Load(); got != 1 {
		t.Fatalf("device uninit count = %d, want 1", got)
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if r.startRequested || r.isStarting || r.isRecording || r.stopAfterStart || r.device != nil {
		t.Fatalf("recorder state leaked after pre-publish stop: startRequested=%t isStarting=%t isRecording=%t stopAfterStart=%t deviceNil=%t",
			r.startRequested, r.isStarting, r.isRecording, r.stopAfterStart, r.device == nil)
	}
}

func TestStopBeforeDevicePublishDefersIntentAndCleansInitializedDevice(t *testing.T) {
	device := newFakeRecorderDevice()
	initBlock := make(chan struct{})
	ctx := &fakeRecorderContext{device: device, initBlock: initBlock}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return ctx.initEntered.Load() })

	r.Stop()
	if device.startEntered.Load() {
		t.Fatal("device Start should not be entered while initDevice is blocked")
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stopped before it was published = %d, want 0", got)
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninit before initDevice returned = %d, want 0", got)
	}

	close(initBlock)
	if err := <-startDone; err != nil {
		t.Fatalf("Start returned error = %v", err)
	}
	if device.startEntered.Load() {
		t.Fatal("device Start should not run after stop intent arrived before publish")
	}
	if got := device.stopCount.Load(); got != 0 {
		t.Fatalf("device stop count = %d, want 0 for never-started device", got)
	}
	if got := device.uninitCount.Load(); got != 1 {
		t.Fatalf("device uninit count = %d, want 1", got)
	}
}

func TestStopWhileStartBlockedLetsStartErrorCleanup(t *testing.T) {
	startErr := errors.New("start failed")
	device := newFakeRecorderDevice()
	device.startErr = startErr
	ctx := &fakeRecorderContext{device: device}
	r := &Recorder{ctx: ctx}

	startDone := make(chan error, 1)
	go func() {
		startDone <- r.Start()
	}()
	waitForRecorderTest(t, func() bool { return device.startEntered.Load() })

	stopDone := make(chan struct{})
	go func() {
		r.Stop()
		close(stopDone)
	}()

	select {
	case <-stopDone:
	case <-time.After(time.Second):
		t.Fatal("Stop should return while recorder Start is still blocked")
	}
	if got := device.uninitCount.Load(); got != 0 {
		t.Fatalf("device uninit before Start error returned = %d, want 0", got)
	}
	close(device.allowStart)
	if err := <-startDone; !errors.Is(err, startErr) {
		t.Fatalf("Start error = %v, want %v", err, startErr)
	}
	if got := device.uninitCount.Load(); got != 1 {
		t.Fatalf("device uninit count = %d, want 1", got)
	}
}

func pcm16LE(values ...int16) []byte {
	buf := make([]byte, len(values)*2)
	for i, value := range values {
		buf[i*2] = byte(value)
		buf[i*2+1] = byte(value >> 8)
	}
	return buf
}

type fakeRecorderContext struct {
	device      *fakeRecorderDevice
	initErr     error
	initBlock   <-chan struct{}
	initEntered atomic.Bool
	freeCount   atomic.Int32
}

func (c *fakeRecorderContext) devices(malgo.DeviceType) ([]malgo.DeviceInfo, error) {
	return nil, nil
}

func (c *fakeRecorderContext) initDevice(malgo.DeviceConfig, malgo.DeviceCallbacks) (recorderDevice, error) {
	c.initEntered.Store(true)
	if c.initBlock != nil {
		<-c.initBlock
	}
	if c.initErr != nil {
		return nil, c.initErr
	}
	return c.device, nil
}

func (c *fakeRecorderContext) free() {
	c.freeCount.Add(1)
}

type fakeRecorderDevice struct {
	startEntered atomic.Bool
	startOnce    sync.Once
	allowStart   chan struct{}
	startErr     error
	stopCount    atomic.Int32
	uninitCount  atomic.Int32
}

func newFakeRecorderDevice() *fakeRecorderDevice {
	return &fakeRecorderDevice{allowStart: make(chan struct{})}
}

func (d *fakeRecorderDevice) Start() error {
	d.startOnce.Do(func() {
		d.startEntered.Store(true)
	})
	<-d.allowStart
	return d.startErr
}

func (d *fakeRecorderDevice) Stop() error {
	d.stopCount.Add(1)
	return nil
}

func (d *fakeRecorderDevice) Uninit() {
	d.uninitCount.Add(1)
}

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