package audio

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

	"github.com/gen2brain/malgo"
)

const (
	sampleRate       = 16000
	channels         = 1
	bitsPerSample    = 16
	silenceThreshold = 0.05
)

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

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

	ctx    *malgo.AllocatedContext
	device *malgo.Device

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

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

	// State
	isRecording    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: 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 {
	if r.ctx == nil {
		return nil
	}
	infos, err := r.ctx.Context.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.mu.Lock()
	defer r.mu.Unlock()

	if r.isRecording {
		return nil
	}

	r.pcmBuf = nil
	r.maxVolume = 0
	r.currentVolume = 0

	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 r.preferredDevice != "" {
		infos, err := r.ctx.Context.Devices(malgo.Capture)
		if err == nil {
			for _, info := range infos {
				if info.Name() == r.preferredDevice {
					deviceConfig.Capture.DeviceID = info.ID.Pointer()
					break
				}
			}
		}
	}

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

	device, err := malgo.InitDevice(r.ctx.Context, deviceConfig, callbacks)
	if err != nil {
		return err
	}

	if err := device.Start(); err != nil {
		device.Uninit()
		return err
	}

	r.device = device
	r.isRecording = true
	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
	}

	// Convert 16-bit PCM to float32
	numSamples := len(pcm) / 2
	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
	}

	logger.Info("Recording stopped, %d samples captured", numSamples)
	return samples
}

// 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 {
	if r.ctx == nil {
		return "Default"
	}
	devices, err := r.ctx.Context.Devices(malgo.Capture)
	if err != nil || len(devices) == 0 {
		return "Default"
	}
	return devices[0].Name()
}

// Close releases all audio resources.
func (r *Recorder) Close() {
	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() *malgo.Device {
	r.mu.Lock()
	defer r.mu.Unlock()

	device := r.device
	r.device = nil
	r.isRecording = false
	return device
}

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

	device := r.device
	r.device = nil
	r.isRecording = false
	pcm := append([]byte(nil), r.pcmBuf...)
	r.pcmBuf = nil
	return device, pcm
}

func stopAndUninitDeviceAsync(device *malgo.Device) {
	if device == nil {
		return
	}
	done := make(chan struct{})
	go func() {
		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 *malgo.Device) {
	if device == nil {
		return
	}
	logger.Info("Stopping audio device")
	device.Stop()
	logger.Info("Audio device stopped")
	device.Uninit()
	logger.Info("Audio device uninitialized")
}

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

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

	// Append raw PCM data
	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)
	}
}