package sound

import (
	"encoding/binary"
	"math"
	"sync"
	"syscall"
	"unsafe"
)

var (
	winmm        = syscall.NewLazyDLL("winmm.dll")
	playSoundW   = winmm.NewProc("PlaySoundW")
	sndMemory    uintptr = 0x0004
	sndAsync     uintptr = 0x0001
	sndNoDefault uintptr = 0x0002

	startWAV  []byte
	doneWAV   []byte
	cancelWAV []byte
	once      sync.Once
)

const (
	sRate    = 48000
	bitDepth = 16
	nCh      = 1
)

func init() {
	once.Do(func() {
		// Ascending "deng-deng ↑"
		startWAV = genMalletPair(330.0, 440.0, 0.13, 0.28, 0.015)
		// Descending "deng-deng ↓"
		doneWAV = genMalletPair(330.0, 247.0, 0.13, 0.28, 0.015)
		// Cancel: single low soft tap
		cancelWAV = genMalletSingle(247.0, 0.20)
	})
}

func PlayStart()  { go playWAV(startWAV) }
func PlayDone()   { go playWAV(doneWAV) }
func PlayCancel() { go playWAV(cancelWAV) }

func playWAV(data []byte) {
	if len(data) == 0 {
		return
	}
	playSoundW.Call(
		uintptr(unsafe.Pointer(&data[0])),
		0,
		sndMemory|sndAsync|sndNoDefault,
	)
}

// genMalletPair generates two mallet-like tones (like a marimba) with a gap.
// Mimics the Typeless "deng-deng" pattern:
//   - 20ms leading silence
//   - Tone 1: fast attack (3ms) + exponential decay over dur1
//   - gap of silence
//   - Tone 2: fast attack (3ms) + exponential decay over dur2 (longer tail)
//   - 20ms trailing silence
func genMalletPair(freq1, freq2, dur1, dur2, gap float64) []byte {
	leadSilence := int(0.02 * sRate)
	n1 := int(dur1 * sRate)
	nGap := int(gap * sRate)
	n2 := int(dur2 * sRate)
	trailSilence := int(0.02 * sRate)
	total := leadSilence + n1 + nGap + n2 + trailSilence

	samples := make([]int16, total)

	// Tone 1
	off := leadSilence
	for i := 0; i < n1; i++ {
		t := float64(i) / sRate
		env := malletEnvelope(i, n1, 6.0) // faster decay
		val := malletOsc(freq1, t, env)
		samples[off+i] = int16(clamp(val*32767, -32767, 32767))
	}

	// Tone 2
	off = leadSilence + n1 + nGap
	for i := 0; i < n2; i++ {
		t := float64(i) / sRate
		env := malletEnvelope(i, n2, 4.5) // slower decay, longer tail
		val := malletOsc(freq2, t, env)
		samples[off+i] = int16(clamp(val*32767, -32767, 32767))
	}

	return buildWAV(samples)
}

// genMalletSingle generates a single mallet tap.
func genMalletSingle(freq, dur float64) []byte {
	lead := int(0.02 * sRate)
	n := int(dur * sRate)
	trail := int(0.02 * sRate)
	total := lead + n + trail

	samples := make([]int16, total)
	for i := 0; i < n; i++ {
		t := float64(i) / sRate
		env := malletEnvelope(i, n, 5.0)
		val := malletOsc(freq, t, env) * 0.8
		samples[lead+i] = int16(clamp(val*32767, -32767, 32767))
	}
	return buildWAV(samples)
}

// malletOsc produces a marimba-like oscillator: fundamental + 2nd harmonic + 3rd harmonic.
// Volume is low (~12% of full scale).
func malletOsc(freq, t, env float64) float64 {
	fundamental := math.Sin(2 * math.Pi * freq * t)
	harmonic2 := math.Sin(2*math.Pi*freq*2*t) * 0.15
	harmonic3 := math.Sin(2*math.Pi*freq*3*t) * 0.05
	return (fundamental + harmonic2 + harmonic3) * env * 0.10
}

// malletEnvelope: 3ms attack, then exponential decay.
// decayRate controls how fast it fades (higher = faster).
func malletEnvelope(i, total int, decayRate float64) float64 {
	attackSamples := sRate * 3 / 1000 // 3ms
	t := float64(i) / sRate

	var env float64
	if i < attackSamples {
		// Fast smooth attack (sine curve for no click)
		env = math.Sin(math.Pi / 2 * float64(i) / float64(attackSamples))
	} else {
		// Exponential decay from peak
		decayT := t - float64(attackSamples)/sRate
		env = math.Exp(-decayRate * decayT)
	}

	// Gentle fade-out at the very end to avoid any click
	fadeOut := sRate * 5 / 1000 // 5ms
	if i > total-fadeOut {
		remaining := float64(total - i)
		env *= remaining / float64(fadeOut)
	}

	return env
}

func clamp(v, lo, hi float64) float64 {
	if v < lo {
		return lo
	}
	if v > hi {
		return hi
	}
	return v
}

func buildWAV(samples []int16) []byte {
	dataSize := len(samples) * 2
	fileSize := 44 + dataSize

	buf := make([]byte, fileSize)
	copy(buf[0:4], "RIFF")
	binary.LittleEndian.PutUint32(buf[4:8], uint32(fileSize-8))
	copy(buf[8:12], "WAVE")

	copy(buf[12:16], "fmt ")
	binary.LittleEndian.PutUint32(buf[16:20], 16)
	binary.LittleEndian.PutUint16(buf[20:22], 1)
	binary.LittleEndian.PutUint16(buf[22:24], nCh)
	binary.LittleEndian.PutUint32(buf[24:28], sRate)
	binary.LittleEndian.PutUint32(buf[28:32], sRate*nCh*bitDepth/8)
	binary.LittleEndian.PutUint16(buf[32:34], nCh*bitDepth/8)
	binary.LittleEndian.PutUint16(buf[34:36], bitDepth)

	copy(buf[36:40], "data")
	binary.LittleEndian.PutUint32(buf[40:44], uint32(dataSize))

	for i, s := range samples {
		binary.LittleEndian.PutUint16(buf[44+i*2:44+i*2+2], uint16(s))
	}

	return buf
}