package ui

import (
	"math"
	"strings"
	"time"

	"charm.land/lipgloss/v2"
)

const (
	DefaultSpectrumBands = 10
	defaultFFTSize       = 2048
	DefaultVisRows       = 5
	minSpectrumHz        = 20.0
	maxSpectrumHz        = 20000.0
	// Cap on dt fed into smoothing easing — long gaps (sleep, paused, stalled
	// frame) step like ~1 frame instead of integrating over a huge interval.
	maxSmoothDtFrames = 10
)

var legacySpectrumEdges = [DefaultSpectrumBands + 1]float64{
	minSpectrumHz,
	100,
	200,
	400,
	800,
	1600,
	3200,
	6400,
	12800,
	16000,
	maxSpectrumHz,
}

// VisMode selects the visualizer rendering style.
type VisMode int

const (
	VisBars        VisMode = iota // smooth fractional blocks
	VisBarsDot                    // bars with braille dot stipple
	VisRain                       // falling rain droplets within bar shapes
	VisBarsOutline                // top-edge outline of bars
	VisBricks                     // solid bricks with gaps
	VisColumns                    // many thin columns
	VisClassicPeak                // classic falling peak caps over thin columns
	VisWave                       // braille waveform oscilloscope
	VisScatter                    // braille particle sparkle
	VisFlame                      // braille rising flame tendrils
	VisRetro                      // 80s synthwave perspective grid with wave
	VisPulse                      // braille pulsating circle
	VisMatrix                     // falling matrix rain characters
	VisBinary                     // streaming binary 0s and 1s
	VisSakura                     // falling cherry blossom petals
	VisFirework                   // exploding firework bursts
	VisBubbles                    // rising hollow ring bubbles
	VisLogo                       // CLIAMP pixel text
	VisTerrain                    // scrolling side-view mountain range
	VisScope                      // Lissajous XY oscilloscope
	VisHeartbeat                  // ECG pulse monitor trace
	VisButterfly                  // mirrored Rorschach spectrum
	VisAscii                      // dense shade-block columns (website style)
	VisFirefly                    // firefly meadow at dusk
	VisMosaic                     // static heatmap of flickering tiles
	VisSand                       // falling-sand cellular automaton
	VisGeyser                     // bass-driven particle fountain
	VisClassicLED                 // Winamp 2.9 LED matrix with falling peak caps
	VisNone                       // hidden — no visualizer
	VisCount                      // sentinel for cycling
)

// Unicode block elements for bar height (9 levels including space)
var barBlocks = []string{" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"}

// brailleBit maps (row, col) in a 4×2 Braille dot grid to its bit value.
var brailleBit = [4][2]rune{
	{0x01, 0x08}, // row 0
	{0x02, 0x10}, // row 1
	{0x04, 0x20}, // row 2
	{0x40, 0x80}, // row 3
}

// visBandWidth returns the character width for band b so that all bands plus
// 1-char gaps exactly fill PanelWidth. The remainder is distributed across the
// first few bands.
func visBandWidth(totalBands, b int) int {
	const gap = 1
	if totalBands <= 0 {
		return 0
	}
	base := (PanelWidth - (totalBands-1)*gap) / totalBands
	extra := (PanelWidth - (totalBands-1)*gap) % totalBands
	if b < extra {
		return base + 1
	}
	return base
}

// interpolateBandColumns builds per-column levels by interpolating between neighboring bands.
func interpolateBandColumns(bands []float64, bandCols []int) []float64 {
	totalCols := 0
	for _, width := range bandCols {
		totalCols += width
	}

	cols := make([]float64, totalCols)
	offset := 0
	for b, level := range bands {
		width := bandCols[b]
		if width <= 0 {
			continue
		}
		nextLevel := level
		if b+1 < len(bands) {
			nextLevel = bands[b+1]
		}
		for c := range width {
			t := float64(c) / float64(width)
			cols[offset+c] = level*(1-t) + nextLevel*t
		}
		offset += width
	}
	return cols
}

func sampleBandLinear(bands []float64, pos float64) float64 {
	switch len(bands) {
	case 0:
		return 0
	case 1:
		return bands[0]
	}
	if pos <= 0 {
		return bands[0]
	}
	last := float64(len(bands) - 1)
	if pos >= last {
		return bands[len(bands)-1]
	}
	idx := int(pos)
	frac := pos - float64(idx)
	return bands[idx]*(1-frac) + bands[idx+1]*frac
}

func resampleBandsLinear(bands []float64, totalCols int) []float64 {
	if totalCols <= 0 || len(bands) == 0 {
		return nil
	}
	if len(bands) == totalCols {
		out := make([]float64, len(bands))
		copy(out, bands)
		return out
	}
	out := make([]float64, totalCols)
	if totalCols == 1 {
		out[0] = sampleBandLinear(bands, float64(len(bands)-1)/2)
		return out
	}
	last := float64(len(bands) - 1)
	for col := range totalCols {
		pos := float64(col) / float64(totalCols-1) * last
		out[col] = sampleBandLinear(bands, pos)
	}
	return out
}

func averageSpectrumRangeLinear(magnitudes []float64, loPos, hiPos float64) float64 {
	if len(magnitudes) == 0 {
		return 0
	}
	minPos := 1.0
	maxPos := float64(len(magnitudes) - 1)
	loPos = max(minPos, min(maxPos, loPos))
	hiPos = max(loPos, min(maxPos, hiPos))
	span := hiPos - loPos
	if span <= 0 {
		return sampleBandLinear(magnitudes, loPos)
	}
	sampleCount := max(4, min(32, int(math.Ceil(span*2))))
	var sum float64
	for i := range sampleCount {
		t := (float64(i) + 0.5) / float64(sampleCount)
		sum += sampleBandLinear(magnitudes, loPos+t*span)
	}
	return sum / float64(sampleCount)
}

// Pre-built styles for spectrum bar colors to avoid per-frame allocation.
var (
	specLowStyle  = lipgloss.NewStyle().Foreground(SpectrumLow)
	specMidStyle  = lipgloss.NewStyle().Foreground(SpectrumMid)
	specHighStyle = lipgloss.NewStyle().Foreground(SpectrumHigh)
)

// Raw ANSI wrappers for the spectrum styles. Caching these once lets every
// style-run flush skip lipgloss.Render (which allocates a fresh wrapped string
// per call) and instead stream prefix + body + suffix into an existing builder.
// Rebuilt via refreshSpecANSI on theme changes.
var (
	specLowPrefix, specLowSuffix   string
	specMidPrefix, specMidSuffix   string
	specHighPrefix, specHighSuffix string
)

func init() {
	refreshSpecANSI()
}

func refreshSpecANSI() {
	specLowPrefix, specLowSuffix = splitStyleAroundProbe(specLowStyle)
	specMidPrefix, specMidSuffix = splitStyleAroundProbe(specMidStyle)
	specHighPrefix, specHighSuffix = splitStyleAroundProbe(specHighStyle)
}

// splitStyleAroundProbe renders a rare marker through the style and splits the
// output around it, yielding the ANSI prefix and suffix the style applies.
// Works for plain Foreground-only styles; adding borders or padding would
// invalidate the split.
func splitStyleAroundProbe(s lipgloss.Style) (prefix, suffix string) {
	const probe = "\uFFFC"
	rendered := s.Render(probe)
	idx := strings.Index(rendered, probe)
	if idx < 0 {
		return "", ""
	}
	return rendered[:idx], rendered[idx+len(probe):]
}

type VisTickContext struct {
	Now           time.Time
	Playing       bool
	Paused        bool
	OverlayActive bool
	Analyze       func(VisAnalysisSpec) []float64
}

type VisAnalysisSpec struct {
	BandCount int
	FFTSize   int
}

func spectrumAnalysisSpec(bandCount int) VisAnalysisSpec {
	return VisAnalysisSpec{
		BandCount: bandCount,
		FFTSize:   defaultFFTSize,
	}
}

func NormalizeAnalysisSpec(spec VisAnalysisSpec) VisAnalysisSpec {
	if spec.BandCount < 0 {
		spec.BandCount = 0
	}
	if spec.FFTSize <= 0 {
		spec.FFTSize = defaultFFTSize
	}
	return spec
}

type visModeDriver interface {
	AnalysisSpec(*Visualizer) VisAnalysisSpec
	Render(*Visualizer) string
	Tick(*Visualizer, VisTickContext)
	TickInterval(*Visualizer, VisTickContext) time.Duration
	OnEnter(*Visualizer)
	OnLeave(*Visualizer)
}

// visEntry pairs a display name with a factory for that mode's visModeDriver.
type visEntry struct {
	name      string
	newDriver func() visModeDriver
}

type renderOnlyDriver struct {
	spec         VisAnalysisSpec
	render       func(*Visualizer, []float64) string
	tickDuration time.Duration // 0 = use defaultDriverTickInterval
}

func (d *renderOnlyDriver) AnalysisSpec(*Visualizer) VisAnalysisSpec {
	return d.spec
}

func (d *renderOnlyDriver) Render(v *Visualizer) string {
	return d.render(v, v.SmoothedBands())
}

func (d *renderOnlyDriver) Tick(v *Visualizer, ctx VisTickContext) {
	defaultDriverTick(v, ctx, d.spec)
}

func (d *renderOnlyDriver) TickInterval(_ *Visualizer, ctx VisTickContext) time.Duration {
	if d.tickDuration > 0 && ctx.Playing && !ctx.OverlayActive {
		return d.tickDuration
	}
	return defaultDriverTickInterval(ctx)
}

func (*renderOnlyDriver) OnEnter(*Visualizer) {}

func (*renderOnlyDriver) OnLeave(*Visualizer) {}

type noOpDriver struct{}

func (*noOpDriver) AnalysisSpec(*Visualizer) VisAnalysisSpec { return VisAnalysisSpec{} }

func (*noOpDriver) Render(*Visualizer) string { return "" }

func (*noOpDriver) Tick(*Visualizer, VisTickContext) {}

func (*noOpDriver) TickInterval(*Visualizer, VisTickContext) time.Duration { return TickSlow }

func (*noOpDriver) OnEnter(*Visualizer) {}

func (*noOpDriver) OnLeave(*Visualizer) {}

func newRenderOnlyDriver(spec VisAnalysisSpec, render func(*Visualizer, []float64) string) func() visModeDriver {
	return func() visModeDriver {
		return &renderOnlyDriver{spec: NormalizeAnalysisSpec(spec), render: render}
	}
}

func newFastRenderOnlyDriver(spec VisAnalysisSpec, tick time.Duration, render func(*Visualizer, []float64) string) func() visModeDriver {
	return func() visModeDriver {
		return &renderOnlyDriver{spec: NormalizeAnalysisSpec(spec), render: render, tickDuration: tick}
	}
}

func newNoOpDriver() visModeDriver {
	return &noOpDriver{}
}

func defaultDriverTick(v *Visualizer, ctx VisTickContext, spec VisAnalysisSpec) {
	if ctx.OverlayActive {
		// Reset both clocks so the first tick after dismissal analyzes
		// immediately and smoothing dt resets to a single-frame step.
		v.lastAnalyzeAt = time.Time{}
		v.lastSmoothTick = time.Time{}
		return
	}
	spec = NormalizeAnalysisSpec(spec)
	if ctx.Analyze != nil {
		// Decouple FFT cadence from animation cadence: skip Analyze if we ran
		// it recently. Animation still advances every tick via advanceSmoothing.
		due := v.lastAnalyzeAt.IsZero() || ctx.Now.IsZero() ||
			ctx.Now.Sub(v.lastAnalyzeAt) >= TickAnalyze
		if due {
			bands := ctx.Analyze(spec)
			if spec.BandCount > 0 {
				v.bands = bands
			}
			if !ctx.Now.IsZero() {
				v.lastAnalyzeAt = ctx.Now
			}
		}
	}
	// Always ease toward the most recent target — even when Analyze is nil
	// or skipped — so animation stays smooth across analysis gaps.
	if spec.BandCount > 0 {
		v.advanceSmoothing(ctx.Now)
	}
}

// defaultDriverTickInterval uses fast ticks only when audio is actively playing
// with a live visualizer. Paused/stopped playback has no new audio samples, so
// slow ticks are sufficient and save CPU/GPU repaints. Overlays use slow ticks
// as well. Bar-style spectrum drivers opt into TickAnim via newFastRenderOnlyDriver.
func defaultDriverTickInterval(ctx VisTickContext) time.Duration {
	if ctx.OverlayActive {
		return TickSlow
	}
	if ctx.Playing {
		return TickFast
	}
	return TickSlow
}

// Visualizer performs FFT analysis and renders spectrum bars.
type Visualizer struct {
	prevBySpec      map[VisAnalysisSpec][]float64
	edgeCache       map[int][]float64
	fftBufCache     map[int][]float64
	fftCplxCache    map[int][]complex128 // reusable in-place FFT work buffers
	fftTwiddleCache map[int][]complex128 // precomputed roots of unity per FFT size
	windowCache     map[int][]float64
	resultBufCache  map[VisAnalysisSpec][]float64 // reusable output buffers for Analyze(), keyed by spec
	bands           []float64
	smoothedBands   []float64 // bands with sub-tick exponential easing toward v.bands
	lastSmoothTick  time.Time // wall clock of the last advanceSmoothing call
	lastAnalyzeAt   time.Time // wall clock of the last FFT analysis
	sr              float64
	Mode            VisMode
	Rows            int       // display height in terminal rows (default 5)
	waveBuf         []float64 // raw samples for wave mode
	waveYBuf        []int     // reusable y-position buffer for wave rendering
	frame           uint64    // tick-driven animation clock
	sampleBuf       []float64 // reusable buffer for reading audio tap samples
	drivers         [VisCount]visModeDriver
	activeMode      VisMode
	activeModeSet   bool
	refreshPending  bool
	luaVisNames     []string
	luaRender       LuaVisRenderer
	luaDriverCache  map[int]visModeDriver
	pulseCoordCache *pulseCoords
}

// LuaVisRenderer is the callback type for rendering a Lua visualizer frame.
type LuaVisRenderer func(name string, bands [DefaultSpectrumBands]float64, rows, cols int, frame uint64) string

// NewVisualizer creates a Visualizer for the given sample rate.
func NewVisualizer(sampleRate float64) *Visualizer {
	return &Visualizer{
		sr:              sampleRate,
		sampleBuf:       make([]float64, defaultFFTSize),
		Rows:            DefaultVisRows,
		bands:           make([]float64, DefaultSpectrumBands),
		prevBySpec:      make(map[VisAnalysisSpec][]float64),
		edgeCache:       make(map[int][]float64),
		fftBufCache:     make(map[int][]float64),
		fftCplxCache:    make(map[int][]complex128),
		fftTwiddleCache: make(map[int][]complex128),
		windowCache:     make(map[int][]float64),
		resultBufCache:  make(map[VisAnalysisSpec][]float64),
		luaDriverCache:  make(map[int]visModeDriver),
		refreshPending:  true,
	}
}

// CycleMode advances to the next visualizer mode, including Lua visualizers.
func (v *Visualizer) CycleMode() {
	total := VisCount + VisMode(len(v.luaVisNames))
	v.Mode = (v.Mode + 1) % total
}

// visModes is the single source of truth for all visualizer modes.
// To add a new mode: add a const, add one line here, create a vis_*.go file.
var visModes = [VisCount]visEntry{
	VisBars:        {"Bars", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderBars)},
	VisBarsDot:     {"BarsDot", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderBarsDot)},
	VisRain:        {"Rain", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderRain)},
	VisBarsOutline: {"BarsOutline", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderBarsOutline)},
	VisBricks:      {"Bricks", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderBricks)},
	VisColumns:     {"Columns", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderColumns)},
	VisClassicPeak: {"ClassicPeak", newClassicPeakDriver},
	VisWave:        {"Wave", newFastRenderOnlyDriver(spectrumAnalysisSpec(0), TickWave, func(v *Visualizer, _ []float64) string { return v.renderWave() })},
	VisScatter:     {"Scatter", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderScatter)},
	VisFlame:       {"Flame", newFlameDriver},
	VisRetro:       {"Retro", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderRetro)},
	VisPulse:       {"Pulse", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderPulse)},
	VisMatrix:      {"Matrix", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderMatrix)},
	VisBinary:      {"Binary", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderBinary)},
	VisSakura:      {"Sakura", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderSakura)},
	VisFirework:    {"Firework", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderFirework)},
	VisBubbles:     {"Bubbles", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderBubbles)},
	VisLogo:        {"Logo", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderLogo)},
	VisTerrain:     {"Terrain", newTerrainDriver},
	VisScope:       {"Scope", newFastRenderOnlyDriver(spectrumAnalysisSpec(0), TickWave, func(v *Visualizer, _ []float64) string { return v.renderScope() })},
	VisHeartbeat:   {"Heartbeat", newFastRenderOnlyDriver(spectrumAnalysisSpec(0), TickWave, func(v *Visualizer, _ []float64) string { return v.renderHeartbeat() })},
	VisButterfly:   {"Butterfly", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderButterfly)},
	VisAscii:       {"Ascii", newFastRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), TickAnim, (*Visualizer).renderAscii)},
	VisFirefly:     {"Firefly", newRenderOnlyDriver(spectrumAnalysisSpec(DefaultSpectrumBands), (*Visualizer).renderFirefly)},
	VisMosaic:      {"Mosaic", newMosaicDriver},
	VisSand:        {"Sand", newSandDriver},
	VisGeyser:      {"Geyser", newGeyserDriver},
	VisClassicLED:  {"ClassicLED", newClassicLEDDriver},
	VisNone:        {"None", newNoOpDriver},
}

var visNameMap map[string]VisMode

func init() {
	visNameMap = make(map[string]VisMode, VisCount)
	for i := range VisCount {
		visNameMap[strings.ToLower(visModes[i].name)] = VisMode(i)
	}
}

// ModeName returns the display name of the current mode.
func (v *Visualizer) ModeName() string {
	if v.Mode < VisCount {
		return visModes[v.Mode].name
	}
	luaIdx := int(v.Mode - VisCount)
	if luaIdx < len(v.luaVisNames) {
		return v.luaVisNames[luaIdx]
	}
	return "Unknown"
}

// StringToVisModeExact converts a name to VisMode, returning false if not found.
func StringToVisModeExact(name string) (VisMode, bool) {
	mode, ok := visNameMap[strings.ToLower(name)]
	return mode, ok
}

// VisModeNames returns the display names of all built-in visualizer modes.
func VisModeNames() []string {
	names := make([]string, VisCount)
	for i := range VisCount {
		names[i] = visModes[i].name
	}
	return names
}

// AllModeNames returns the display names of every selectable visualizer mode in
// cycle order: built-in modes followed by any registered Lua visualizers. The
// index of each name equals its VisMode value, so a picker can map a list row
// directly to a mode.
func (v *Visualizer) AllModeNames() []string {
	return append(VisModeNames(), v.luaVisNames...)
}

// SetMode switches to mode if it is within range (built-in or Lua) and requests
// a refresh. Out-of-range values are ignored, matching the SetVisualizer guard.
func (v *Visualizer) SetMode(mode VisMode) {
	if mode < 0 || mode >= VisCount+VisMode(len(v.luaVisNames)) {
		return
	}
	v.Mode = mode
	v.RequestRefresh()
}

func buildSpectrumEdges(count int) []float64 {
	if count <= 0 {
		return nil
	}
	edges := make([]float64, count+1)
	lastAnchor := len(legacySpectrumEdges) - 1
	for i := range count + 1 {
		numerator := i * lastAnchor
		idx := numerator / count
		if idx >= lastAnchor {
			edges[i] = legacySpectrumEdges[lastAnchor]
			continue
		}
		if numerator%count == 0 {
			edges[i] = legacySpectrumEdges[idx]
			continue
		}
		frac := float64(numerator%count) / float64(count)
		lo := legacySpectrumEdges[idx]
		hi := legacySpectrumEdges[idx+1]
		edges[i] = math.Pow(10, math.Log10(lo)*(1-frac)+math.Log10(hi)*frac)
	}
	return edges
}

func buildHannWindow(size int) []float64 {
	window := make([]float64, size)
	for i := range size {
		window[i] = 0.5 * (1 - math.Cos(2*math.Pi*float64(i)/float64(size-1)))
	}
	return window
}

func (v *Visualizer) prevBands(spec VisAnalysisSpec) []float64 {
	if prev, ok := v.prevBySpec[spec]; ok {
		return prev
	}
	prev := make([]float64, spec.BandCount)
	v.prevBySpec[spec] = prev
	return prev
}

func (v *Visualizer) spectrumEdges(count int) []float64 {
	if edges, ok := v.edgeCache[count]; ok {
		return edges
	}
	edges := buildSpectrumEdges(count)
	v.edgeCache[count] = edges
	return edges
}

func (v *Visualizer) fftBuffer(size int) []float64 {
	if buf, ok := v.fftBufCache[size]; ok {
		return buf
	}
	buf := make([]float64, size)
	v.fftBufCache[size] = buf
	return buf
}

func (v *Visualizer) fftComplexBuffer(size int) []complex128 {
	if buf, ok := v.fftCplxCache[size]; ok {
		return buf
	}
	buf := make([]complex128, size)
	v.fftCplxCache[size] = buf
	return buf
}

func (v *Visualizer) fftTwiddles(size int) []complex128 {
	if w, ok := v.fftTwiddleCache[size]; ok {
		return w
	}
	w := buildTwiddles(size)
	v.fftTwiddleCache[size] = w
	return w
}

// resultBufFor returns a reusable []float64 for Analyze output, keyed by the
// full analysis spec so different specs with the same band count don't alias.
// Avoids allocating a new slice on every tick (20x/sec).
func (v *Visualizer) resultBufFor(spec VisAnalysisSpec) []float64 {
	if buf, ok := v.resultBufCache[spec]; ok {
		clear(buf)
		return buf
	}
	buf := make([]float64, spec.BandCount)
	v.resultBufCache[spec] = buf
	return buf
}

func (v *Visualizer) hannWindow(size int) []float64 {
	if window, ok := v.windowCache[size]; ok {
		return window
	}
	window := buildHannWindow(size)
	v.windowCache[size] = window
	return window
}

func (v *Visualizer) resetSpectrumHistory() {
	if v == nil {
		return
	}
	clear(v.prevBySpec)
}

func (v *Visualizer) EnsureSampleBuf(size int) []float64 {
	size = NormalizeAnalysisSpec(VisAnalysisSpec{FFTSize: size}).FFTSize
	if cap(v.sampleBuf) < size {
		v.sampleBuf = make([]float64, size)
	} else {
		v.sampleBuf = v.sampleBuf[:size]
	}
	return v.sampleBuf
}

// RegisterLuaVisualizers adds Lua visualizer names so they can be cycled
// through with the v key. renderer is called when a Lua visualizer is active.
func (v *Visualizer) RegisterLuaVisualizers(names []string, renderer LuaVisRenderer) {
	v.luaVisNames = names
	v.luaRender = renderer
	clear(v.luaDriverCache)
	// Add to name map for StringToVisModeExact lookups.
	for i, name := range names {
		visNameMap[strings.ToLower(name)] = VisCount + VisMode(i)
	}
}

// Analyze runs FFT on raw audio samples and returns normalized band levels (0-1).
func (v *Visualizer) Analyze(samples []float64, spec VisAnalysisSpec) []float64 {
	spec = NormalizeAnalysisSpec(spec)

	// Store raw samples for wave mode.
	if n := len(samples); n > 0 {
		if cap(v.waveBuf) >= n {
			v.waveBuf = v.waveBuf[:n]
		} else {
			v.waveBuf = make([]float64, n)
		}
		copy(v.waveBuf, samples)
	} else {
		v.waveBuf = v.waveBuf[:0]
	}

	if spec.BandCount <= 0 {
		return nil
	}

	prev := v.prevBands(spec)
	bands := v.resultBufFor(spec)

	// Silence gate: skip the FFT pipeline when input is empty or effectively
	// silent. A quick max-abs scan is two orders of magnitude cheaper than the
	// FFT and fires whenever playback is paused, between tracks, or quiet.
	silent := len(samples) == 0
	if !silent {
		maxAbs := 0.0
		for _, s := range samples {
			a := math.Abs(s)
			if a > maxAbs {
				maxAbs = a
			}
		}
		silent = maxAbs < 1e-5
	}
	if silent {
		for b := range spec.BandCount {
			bands[b] = prev[b] * 0.8
			prev[b] = bands[b]
		}
		return bands
	}

	// Window samples into the reusable complex FFT buffer. Any tail beyond the
	// provided samples stays zero from the previous run-through — we always
	// overwrite the first `have` entries and explicitly zero the rest below.
	cbuf := v.fftComplexBuffer(spec.FFTSize)
	window := v.hannWindow(spec.FFTSize)
	have := min(len(samples), spec.FFTSize)
	for i := range have {
		cbuf[i] = complex(samples[i]*window[i], 0)
	}
	for i := have; i < spec.FFTSize; i++ {
		cbuf[i] = 0
	}

	fftInPlace(cbuf, v.fftTwiddles(spec.FFTSize))

	// Power spectrum |X|^2 into the reusable float buffer. Skipping the sqrt
	// per bin halves the work compared to magnitudes; the log10 below absorbs
	// the factor of two so band values stay in the same [0,1] range.
	halfLen := spec.FFTSize / 2
	powers := v.fftBuffer(spec.FFTSize)[:halfLen]
	powers[0] = 0
	for i := 1; i < halfLen; i++ {
		re := real(cbuf[i])
		im := imag(cbuf[i])
		powers[i] = re*re + im*im
	}

	binHz := v.sr / float64(spec.FFTSize)
	edges := v.spectrumEdges(spec.BandCount)

	for b := range spec.BandCount {
		sum := averageSpectrumRangeLinear(powers, edges[b]/binHz, edges[b+1]/binHz)

		// Convert to dB-like scale. 10*log10(power) == 20*log10(magnitude).
		if sum > 0 {
			bands[b] = (10*math.Log10(sum) + 10) / 50
		}
		bands[b] = max(0, min(1, bands[b]))

		// Temporal smoothing: fast attack, slow decay.
		if bands[b] > prev[b] {
			bands[b] = bands[b]*0.6 + prev[b]*0.4
		} else {
			bands[b] = bands[b]*0.25 + prev[b]*0.75
		}
		prev[b] = bands[b]
	}

	return bands
}

// Render dispatches to the active visualizer mode.
func (v *Visualizer) Render() string {
	driver := v.syncDriverMode()
	if driver == nil {
		return ""
	}
	return driver.Render(v)
}

func (v *Visualizer) RequestRefresh() {
	if v != nil {
		v.refreshPending = true
	}
}

func (v *Visualizer) ConsumeRefresh() bool {
	if v == nil || !v.refreshPending {
		return false
	}
	v.refreshPending = false
	return true
}

// SampleBuf returns the internal sample buffer (for slicing after SamplesInto).
func (v *Visualizer) SampleBuf() []float64 { return v.sampleBuf }

// Bands returns the current spectrum band values.
func (v *Visualizer) Bands() []float64 { return v.bands }

// SmoothedBands returns the eased per-frame band values used by spectrum
// renderers. Falls back to the raw bands until smoothing has run at least
// once.
func (v *Visualizer) SmoothedBands() []float64 {
	if v == nil {
		return nil
	}
	if len(v.smoothedBands) == len(v.bands) && len(v.smoothedBands) > 0 {
		return v.smoothedBands
	}
	return v.bands
}

// advanceSmoothing eases v.smoothedBands toward v.bands using the same
// fast-attack / slow-decay shape as classicPeak's per-bar smoothing
// (classicPeakStep), so every spectrum visualizer glides between FFT samples
// instead of snapping at the analysis rate.
func (v *Visualizer) advanceSmoothing(now time.Time) {
	if v == nil || len(v.bands) == 0 {
		return
	}
	if len(v.smoothedBands) != len(v.bands) {
		// First frame after a spec change snaps to the current analysis output
		// so existing levels appear immediately instead of fading in from zero.
		v.smoothedBands = append(v.smoothedBands[:0], v.bands...)
		v.lastSmoothTick = now
		return
	}
	dt := TickAnim.Seconds()
	if !now.IsZero() && !v.lastSmoothTick.IsZero() {
		dt = now.Sub(v.lastSmoothTick).Seconds()
	}
	if dt <= 0 || dt > maxSmoothDtFrames*TickAnim.Seconds() {
		dt = TickAnim.Seconds()
	}
	v.lastSmoothTick = now
	for i, target := range v.bands {
		v.smoothedBands[i] = classicPeakStep(v.smoothedBands[i], target, dt)
	}
}

// Frame returns the current animation frame counter.
func (v *Visualizer) Frame() uint64 { return v.frame }

// RefreshPending reports whether a refresh has been requested.
func (v *Visualizer) RefreshPending() bool { return v != nil && v.refreshPending }

func (v *Visualizer) TickInterval(ctx VisTickContext) time.Duration {
	driver := v.syncDriverMode()
	if driver == nil {
		return TickSlow
	}
	if ctx.Paused {
		return TickSlow
	}
	return driver.TickInterval(v, ctx)
}

func (v *Visualizer) Tick(ctx VisTickContext) {
	driver := v.syncDriverMode()
	if driver == nil {
		return
	}
	v.refreshPending = false
	if ctx.Paused {
		return
	}
	if v.Mode != VisNone && !ctx.OverlayActive {
		v.frame++
	}
	driver.Tick(v, ctx)
}

func (v *Visualizer) driverFor(mode VisMode) visModeDriver {
	if v == nil || mode < 0 {
		return nil
	}
	if mode >= VisCount {
		idx := int(mode - VisCount)
		if idx < 0 || idx >= len(v.luaVisNames) {
			return nil
		}
		if driver, ok := v.luaDriverCache[idx]; ok {
			return driver
		}
		driver := &luaModeDriver{index: idx}
		v.luaDriverCache[idx] = driver
		return driver
	}
	if v.drivers[mode] == nil {
		newDriver := visModes[mode].newDriver
		if newDriver == nil {
			return nil
		}
		v.drivers[mode] = newDriver()
	}
	return v.drivers[mode]
}

type luaModeDriver struct {
	index int
}

func (*luaModeDriver) AnalysisSpec(*Visualizer) VisAnalysisSpec {
	return spectrumAnalysisSpec(DefaultSpectrumBands)
}

func (d *luaModeDriver) Render(v *Visualizer) string {
	if v == nil || d.index < 0 || d.index >= len(v.luaVisNames) || v.luaRender == nil {
		return ""
	}
	return v.luaRender(v.luaVisNames[d.index], luaBands(v.bands), v.Rows, PanelWidth, v.frame)
}

func (d *luaModeDriver) Tick(v *Visualizer, ctx VisTickContext) {
	defaultDriverTick(v, ctx, d.AnalysisSpec(v))
}

func (*luaModeDriver) TickInterval(_ *Visualizer, ctx VisTickContext) time.Duration {
	return defaultDriverTickInterval(ctx)
}

func (*luaModeDriver) OnEnter(*Visualizer) {}

func (*luaModeDriver) OnLeave(*Visualizer) {}

func luaBands(src []float64) [DefaultSpectrumBands]float64 {
	var bands [DefaultSpectrumBands]float64
	copy(bands[:], src)
	return bands
}

func (v *Visualizer) syncDriverMode() visModeDriver {
	if v == nil {
		return nil
	}
	driver := v.driverFor(v.Mode)
	if !v.activeModeSet {
		if driver != nil {
			driver.OnEnter(v)
		}
		v.activeMode = v.Mode
		v.activeModeSet = true
		return driver
	}
	if v.activeMode != v.Mode {
		prev := v.driverFor(v.activeMode)
		prevSpec := VisAnalysisSpec{}
		if prev != nil {
			prevSpec = NormalizeAnalysisSpec(prev.AnalysisSpec(v))
		}
		nextSpec := VisAnalysisSpec{}
		if driver != nil {
			nextSpec = NormalizeAnalysisSpec(driver.AnalysisSpec(v))
		}
		if (prevSpec.BandCount == 0) != (nextSpec.BandCount == 0) {
			v.resetSpectrumHistory()
		}
		if prev != nil {
			prev.OnLeave(v)
		}
		if driver != nil {
			driver.OnEnter(v)
		}
		v.activeMode = v.Mode
	}
	return driver
}

// fracBlock returns the fractional Unicode block character for a band level
// within the row span [rowBottom, rowTop]. Used by bars and columns visualizers.
func fracBlock(level, rowBottom, rowTop float64) string {
	if level >= rowTop {
		return "█"
	}
	if level > rowBottom {
		frac := (level - rowBottom) / (rowTop - rowBottom)
		idx := int(frac * float64(len(barBlocks)-1))
		idx = max(0, min(idx, len(barBlocks)-1))
		return barBlocks[idx]
	}
	return " "
}

// scatterHash returns a pseudo-random value in [0, 1) for a given dot position
// and frame. Dots persist for a few frames to create a twinkling effect.
func scatterHash(band, row, col int, frame uint64) float64 {
	// Stagger per-dot so they don't all change simultaneously.
	f := (frame + uint64(row*3+col)) / 3
	h := uint64(band)*7919 + uint64(row)*6271 + uint64(col)*3037 + f*104729
	h ^= h >> 16
	h *= 0x45d9f3b37197344b
	h ^= h >> 16
	return float64(h%10000) / 10000.0
}

// specTag returns 0, 1, or 2 identifying the spectrum color tier for style-run
// batching, using the same thresholds as specWrap.
func specTag(norm float64) int {
	if norm >= 0.6 {
		return 2
	}
	if norm >= 0.3 {
		return 1
	}
	return 0
}

// specWrap wraps body in the cached ANSI sequences for the spectrum color at
// the given row-bottom (0-1). One string concatenation instead of the several
// allocations a per-call lipgloss.Style.Render would perform.
func specWrap(rowBottom float64, body string) string {
	var prefix, suffix string
	switch specTag(rowBottom) {
	case 2:
		prefix, suffix = specHighPrefix, specHighSuffix
	case 1:
		prefix, suffix = specMidPrefix, specMidSuffix
	case 0:
		prefix, suffix = specLowPrefix, specLowSuffix
	}
	if prefix == "" {
		return body
	}
	return prefix + body + suffix
}

// flushStyleRun appends the accumulated run bytes to sb wrapped in the cached
// ANSI sequences for the given tag, then resets run. Tag -1 writes unstyled.
// Streaming via the pre-extracted prefix/suffix strings avoids allocating a
// fresh lipgloss.Render result on every flush (the hot path for Matrix/Pulse).
func flushStyleRun(sb *strings.Builder, run *strings.Builder, tag int) {
	if run.Len() == 0 {
		return
	}
	var prefix, suffix string
	switch tag {
	case 2:
		prefix, suffix = specHighPrefix, specHighSuffix
	case 1:
		prefix, suffix = specMidPrefix, specMidSuffix
	case 0:
		prefix, suffix = specLowPrefix, specLowSuffix
	}
	if prefix != "" {
		sb.WriteString(prefix)
	}
	// run.String() aliases the builder's backing array (no allocation) and we
	// copy those bytes into sb before run.Reset() releases the slice.
	sb.WriteString(run.String())
	if suffix != "" {
		sb.WriteString(suffix)
	}
	run.Reset()
}