package audio

import (
	"errors"
	"fmt"
	"math"
	"sync"
	"time"
	"voicesnap/internal/logger"

	"github.com/gen2brain/malgo"
)

const (
	sampleRate            = 16000
	channels              = 1
	bitsPerSample         = 16
	silenceThreshold      = 0.05
	maxRecordingSeconds   = 15 * 60
	maxPCMBufferBytes     = sampleRate * channels * (bitsPerSample / 8) * maxRecordingSeconds
	MaxRecordingDuration  = time.Duration(maxRecordingSeconds) * time.Second
	maxPendingDeviceStops = 2
	deviceStartWatchDelay = 2 * time.Second
)

var pendingDeviceStops = make(chan struct{}, maxPendingDeviceStops)

var ErrMicrophonePermission = errors.New("microphone permission not granted")

// InputDevice represents an audio input device.
type InputDevice struct {
	Name      string `json:"name"`
	IsDefault bool   `json:"isDefault"`
}

type recorderAudioContext interface {
	devices(malgo.DeviceType) ([]malgo.DeviceInfo, error)
	initDevice(malgo.DeviceConfig, malgo.DeviceCallbacks) (recorderDevice, error)
	free()
}

type malgoRecorderContext struct {
	allocated *malgo.AllocatedContext
}

func (c *malgoRecorderContext) devices(deviceType malgo.DeviceType) ([]malgo.DeviceInfo, error) {
	return c.allocated.Context.Devices(deviceType)
}

func (c *malgoRecorderContext) initDevice(config malgo.DeviceConfig, callbacks malgo.DeviceCallbacks) (recorderDevice, error) {
	return malgo.InitDevice(c.allocated.Context, config, callbacks)
}

func (c *malgoRecorderContext) free() {
	c.allocated.Free()
}

type recorderDevice interface {
	Start() error
	Stop() error
	Uninit()
}

// Recorder captures audio from the default input device using malgo (miniaudio).
type Recorder struct {
	mu          sync.Mutex
	lifecycleMu sync.Mutex

	ctx    recorderAudioContext
	device recorderDevice

	// PCM buffer (16-bit signed, little-endian)
	pcmBuf []byte

	// Preferred device name (empty = system default)
	preferredDevice string

	// State
	isRecording    bool
	startRequested bool
	isStarting     bool
	stopAfterStart bool
	bufferLimitHit bool
	closing        bool
	maxVolume      float64
	currentVolume  float64
	volumeCallback func(float64)
	deviceChangeCb func(string)
}

// NewRecorder creates a new audio recorder backed by malgo.
func NewRecorder() *Recorder {
	ctxConfig := malgo.ContextConfig{}
	ctx, err := malgo.InitContext(nil, ctxConfig, nil)
	if err != nil {
		logger.Error("Failed to init malgo context: %v", err)
		return &Recorder{}
	}
	return &Recorder{ctx: &malgoRecorderContext{allocated: ctx}}
}

// OnVolume registers a callback for real-time volume updates.
func (r *Recorder) OnVolume(fn func(float64)) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.volumeCallback = fn
}

// OnDeviceChange registers a callback for audio device changes.
func (r *Recorder) OnDeviceChange(fn func(string)) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.deviceChangeCb = fn
}

// ListInputDevices returns all available audio capture devices.
func (r *Recorder) ListInputDevices() []InputDevice {
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	ctx := r.ctx
	if ctx == nil {
		return nil
	}
	infos, err := ctx.devices(malgo.Capture)
	if err != nil {
		logger.Error("Failed to list devices: %v", err)
		return nil
	}
	var result []InputDevice
	for i, info := range infos {
		result = append(result, InputDevice{
			Name:      info.Name(),
			IsDefault: i == 0,
		})
	}
	return result
}

// SetPreferredDevice sets the preferred device by name. Empty string = system default.
func (r *Recorder) SetPreferredDevice(name string) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.preferredDevice = name
	logger.Info("Preferred device set to: %q", name)
}

// Start begins recording from the preferred (or default) capture device.
func (r *Recorder) Start() error {
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	r.mu.Lock()
	if r.closing {
		r.mu.Unlock()
		return fmt.Errorf("audio recorder is closed")
	}
	if r.isRecording || r.startRequested || r.isStarting {
		r.mu.Unlock()
		return nil
	}

	r.pcmBuf = nil
	r.bufferLimitHit = false
	r.maxVolume = 0
	r.currentVolume = 0
	r.startRequested = true
	r.stopAfterStart = false
	ctx := r.ctx
	preferredDevice := r.preferredDevice
	r.mu.Unlock()
	logger.Info("Audio recorder start requested sample_rate=%d channels=%d preferred_device=%q", sampleRate, channels, preferredDevice)

	auth := ensureMicrophoneAuthorization()
	if !auth.granted {
		r.mu.Lock()
		r.startRequested = false
		r.stopAfterStart = false
		r.isRecording = false
		r.mu.Unlock()
		logger.Error("Microphone permission not granted; audio recorder start blocked state=%s", auth.state)
		return fmt.Errorf("%w: %s", ErrMicrophonePermission, auth.state)
	}
	logger.Info("Microphone permission ready state=%s", auth.state)

	r.mu.Lock()
	stopBeforeAuthComplete := r.stopAfterStart || r.closing
	startWasClosed := r.closing
	if stopBeforeAuthComplete {
		r.startRequested = false
		r.stopAfterStart = false
		r.isRecording = false
		r.mu.Unlock()
		if startWasClosed {
			return fmt.Errorf("audio recorder closed during start")
		}
		return nil
	}
	r.mu.Unlock()

	if ctx == nil {
		r.mu.Lock()
		r.startRequested = false
		r.stopAfterStart = false
		r.mu.Unlock()
		return fmt.Errorf("audio context is not initialized")
	}

	deviceConfig := malgo.DefaultDeviceConfig(malgo.Capture)
	deviceConfig.Capture.Format = malgo.FormatS16
	deviceConfig.Capture.Channels = channels
	deviceConfig.SampleRate = sampleRate
	deviceConfig.PeriodSizeInMilliseconds = 50

	// Use preferred device if set
	if preferredDevice != "" {
		infos, err := ctx.devices(malgo.Capture)
		if err == nil {
			for _, info := range infos {
				if info.Name() == preferredDevice {
					deviceConfig.Capture.DeviceID = info.ID.Pointer()
					break
				}
			}
		}
	}

	callbacks := malgo.DeviceCallbacks{
		Data: func(outputSamples, inputSamples []byte, framecount uint32) {
			r.onData(inputSamples)
		},
	}

	device, err := ctx.initDevice(deviceConfig, callbacks)
	if err != nil {
		r.mu.Lock()
		r.startRequested = false
		r.stopAfterStart = false
		r.mu.Unlock()
		return err
	}
	logger.Info("Audio device initialized; starting native device")

	r.mu.Lock()
	stopBeforeStart := r.stopAfterStart || r.closing
	startWasClosed = r.closing
	if r.isRecording || stopBeforeStart {
		r.startRequested = false
		r.stopAfterStart = false
		r.isRecording = false
		r.mu.Unlock()
		device.Uninit()
		if startWasClosed {
			return fmt.Errorf("audio recorder closed during start")
		}
		return nil
	}
	r.device = device
	r.isRecording = true
	r.startRequested = false
	r.isStarting = true
	r.stopAfterStart = false
	r.mu.Unlock()

	deviceStartBegin := time.Now()
	watchDone := make(chan struct{})
	go func() {
		select {
		case <-watchDone:
		case <-time.After(deviceStartWatchDelay):
			logger.Error("Native audio device start still pending after %dms", deviceStartWatchDelay.Milliseconds())
		}
	}()
	if err := device.Start(); err != nil {
		close(watchDone)
		r.mu.Lock()
		stillCurrent := r.device == device
		if stillCurrent {
			r.device = nil
			r.isRecording = false
			r.startRequested = false
			r.isStarting = false
			r.stopAfterStart = false
		}
		r.mu.Unlock()
		if stillCurrent {
			device.Uninit()
		}
		return err
	}
	close(watchDone)
	logger.Info("Native audio device start returned result=success start_ms=%d", time.Since(deviceStartBegin).Milliseconds())

	r.mu.Lock()
	stillCurrent := r.device == device
	shouldStop := stillCurrent && (r.stopAfterStart || r.closing || !r.isRecording)
	startWasClosed = stillCurrent && r.closing
	if !stillCurrent && r.device == device {
		r.device = nil
		r.isRecording = false
		r.isStarting = false
		r.stopAfterStart = false
	}
	if stillCurrent {
		r.startRequested = false
		r.isStarting = false
	}
	if shouldStop {
		r.device = nil
		r.isRecording = false
		r.stopAfterStart = false
	}
	r.mu.Unlock()
	if !stillCurrent {
		stopAndUninitDevice(device)
		return fmt.Errorf("audio recorder closed during start")
	}
	if shouldStop {
		stopAndUninitDevice(device)
		if startWasClosed {
			return fmt.Errorf("audio recorder closed during start")
		}
		return nil
	}

	logger.Info("Recording started (16kHz/16-bit/mono)")
	return nil
}

// Stop stops recording and discards audio data.
func (r *Recorder) Stop() {
	device, _ := r.detachDeviceAndPCM()
	stopAndUninitDeviceAsync(device)
}

// StopAndGetSamples stops recording and returns the captured audio as float32 samples.
func (r *Recorder) StopAndGetSamples() []float32 {
	device, pcm := r.detachDeviceAndPCM()
	stopAndUninitDeviceAsync(device)

	if len(pcm) < 2 {
		return nil
	}

	samples := pcm16LEToFloat32(pcm)
	logger.Info("Recording stopped, %d samples captured", len(samples))
	return samples
}

// ReadSamplesSince returns newly captured samples after sampleOffset and the
// next offset to pass on the following call. It is safe to call while recording.
func (r *Recorder) ReadSamplesSince(sampleOffset int) ([]float32, int) {
	r.mu.Lock()
	totalSamples := len(r.pcmBuf) / 2
	if sampleOffset < 0 {
		sampleOffset = 0
	}
	if sampleOffset > totalSamples {
		sampleOffset = totalSamples
	}
	startByte := sampleOffset * 2
	pcm := append([]byte(nil), r.pcmBuf[startByte:]...)
	r.mu.Unlock()

	if len(pcm) < 2 {
		return nil, totalSamples
	}
	return pcm16LEToFloat32(pcm), totalSamples
}

// HasVoiceActivity returns true if the max volume exceeded the silence threshold.
func (r *Recorder) HasVoiceActivity() bool {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.maxVolume > silenceThreshold
}

// GetDeviceName returns the name of the current capture device.
func (r *Recorder) GetDeviceName() string {
	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	ctx := r.ctx
	if ctx == nil {
		return "Default"
	}
	devices, err := ctx.devices(malgo.Capture)
	if err != nil || len(devices) == 0 {
		return "Default"
	}
	return devices[0].Name()
}

// Close releases all audio resources.
func (r *Recorder) Close() {
	r.mu.Lock()
	r.closing = true
	r.mu.Unlock()

	r.lifecycleMu.Lock()
	defer r.lifecycleMu.Unlock()

	device := r.detachDevice()
	stopAndUninitDevice(device)

	r.mu.Lock()
	defer r.mu.Unlock()
	if r.ctx != nil {
		r.ctx.free()
		r.ctx = nil
	}
}

func (r *Recorder) detachDevice() recorderDevice {
	r.mu.Lock()
	defer r.mu.Unlock()

	device := r.device
	if r.startRequested && !r.isStarting {
		logger.Info("Recording stop requested before audio device was published; deferring startup cleanup")
		r.isRecording = false
		r.stopAfterStart = true
		return nil
	}
	if r.isStarting {
		logger.Info("Recording stop requested while audio device start is still pending; deferring native device cleanup")
		r.isRecording = false
		r.stopAfterStart = true
		return nil
	}
	r.device = nil
	r.isRecording = false
	return device
}

func (r *Recorder) detachDeviceAndPCM() (recorderDevice, []byte) {
	r.mu.Lock()
	defer r.mu.Unlock()

	device := r.device
	if r.startRequested && !r.isStarting {
		logger.Info("Recording samples requested before audio device was published; snapshotting buffered PCM and deferring startup cleanup")
		r.isRecording = false
		r.stopAfterStart = true
		pcm := append([]byte(nil), r.pcmBuf...)
		r.pcmBuf = nil
		return nil, pcm
	}
	if r.isStarting {
		logger.Info("Recording samples requested while audio device start is still pending; snapshotting buffered PCM and deferring native device cleanup")
		r.isRecording = false
		r.stopAfterStart = true
		pcm := append([]byte(nil), r.pcmBuf...)
		r.pcmBuf = nil
		return nil, pcm
	}
	r.device = nil
	r.isRecording = false
	pcm := append([]byte(nil), r.pcmBuf...)
	r.pcmBuf = nil
	return device, pcm
}

func stopAndUninitDeviceAsync(device recorderDevice) {
	if device == nil {
		return
	}
	select {
	case pendingDeviceStops <- struct{}{}:
	case <-time.After(100 * time.Millisecond):
		logger.Error("Audio device stop queue saturated; stopping synchronously")
		stopAndUninitDevice(device)
		return
	}
	done := make(chan struct{})
	go func() {
		defer func() {
			<-pendingDeviceStops
		}()
		stopAndUninitDevice(device)
		close(done)
	}()
	go func() {
		select {
		case <-done:
		case <-time.After(2 * time.Second):
			logger.Error("Audio device stop is still pending; continuing without blocking UI")
		}
	}()
}

func stopAndUninitDevice(device recorderDevice) {
	if device == nil {
		return
	}
	logger.Info("Stopping audio device")
	device.Stop()
	logger.Info("Audio device stopped")
	device.Uninit()
	logger.Info("Audio device uninitialized")
}

func pcm16LEToFloat32(pcm []byte) []float32 {
	numSamples := len(pcm) / 2
	if numSamples == 0 {
		return nil
	}
	samples := make([]float32, numSamples)
	for i := 0; i < numSamples; i++ {
		sample := int16(pcm[i*2]) | int16(pcm[i*2+1])<<8
		samples[i] = float32(sample) / 32768.0
	}
	return samples
}

func (r *Recorder) onData(input []byte) {
	r.mu.Lock()

	if !r.isRecording {
		r.mu.Unlock()
		return
	}

	// Append raw PCM data
	if len(r.pcmBuf) >= maxPCMBufferBytes {
		if !r.bufferLimitHit {
			logger.Error("Recording buffer limit reached; dropping additional audio max_seconds=%d", maxRecordingSeconds)
			r.bufferLimitHit = true
		}
		r.mu.Unlock()
		return
	}
	if len(r.pcmBuf)+len(input) > maxPCMBufferBytes {
		input = input[:maxPCMBufferBytes-len(r.pcmBuf)]
		if !r.bufferLimitHit {
			logger.Error("Recording buffer limit reached; truncating audio max_seconds=%d", maxRecordingSeconds)
			r.bufferLimitHit = true
		}
	}
	r.pcmBuf = append(r.pcmBuf, input...)

	// Calculate RMS volume
	numSamples := len(input) / 2
	if numSamples == 0 {
		r.mu.Unlock()
		return
	}

	var sum float64
	for i := 0; i < len(input)-1; i += 2 {
		sample := int16(input[i]) | int16(input[i+1])<<8
		normalized := float64(sample) / 32768.0
		sum += normalized * normalized
	}
	rms := math.Sqrt(sum / float64(numSamples))
	volume := math.Min(1.0, rms*8)

	r.currentVolume = volume
	if volume > r.maxVolume {
		r.maxVolume = volume
	}

	cb := r.volumeCallback
	r.mu.Unlock()

	// Invoke callback outside lock to prevent deadlock with app mutex
	if cb != nil {
		cb(volume)
	}
}