//! monolith — the Glitching Monolith mandelbulb on a deep void.
//!
//! Premise → implementation:
//!   · 40–80 Hz sub-bass / kicks  → macro structure & gravity (sp_scale spring
//!     breathes the bulb; lowf shader scalar darkens the outer void → "the
//!     808 pulls the picture in").
//!   · IDM mids / pads             → fluid + colour (swirl phase rotates the
//!     feedback trail, midf shader scalar drifts radial ink-in-water; accent
//!     hue eases toward the dominant chroma class).
//!   · Breakcore high-mids / snares → glitch + stutter + camera (glitch_env
//!     drives the shader's coarse-cell UV-shove grid; a `stutter` FSM holds
//!     the camera/scale/glow for ~120 ms on a snare-flux burst while the
//!     shader's feedback decay floor pins near 1.0 → the previous frame
//!     "freezes" — looks like the render dropped to ~10 fps for a beat).
//!
//! Fingerprint mapping (committed once at startup or M-cycle):
//!   chroma_dom % 3       → neon accent class (cyan / magenta / acid green)
//!   centroid_mean        → base hue along a deep-blue↔purple arc
//!   tonality             → palette saturation + edge softness
//!   dyn_range            → motion scale (low DR = slow, wide DR = punchy)
//!   tempo_class          → camera orbit rate baseline
//!
//! Per-run novelty (wall-clock seed in live; deterministic in `--render`):
//!   camera start angles + initial swirl phase.
//!
//! Determinism: `Rng` and the stutter/glitch FSMs advance only in `update`
//! (one call per frame, live and render). The shader is a pure function of
//! the UBO + hash(fragCoord, frame). Same input + same seed = same frame.
//!
//! WGSL coupling (non-negotiable): the header is **9** std140 rows so the
//! UBO is exactly **36** f32 (`UBO_LEN`). No nodes array — the form is the
//! DE itself.

use crate::audio::Bands;
use crate::viz::curve::Rng;
use crate::viz::fingerprint::Fingerprint;
use crate::viz::math::{Spring, angle_to};
use crate::viz::palette::{Palette, oklch};
use crate::viz::post::read_texture_rgba;
use crate::viz::shader::ShaderPipeline;
use crate::viz::structure::{Arch, Structure};
use nannou::wgpu;

/// UBO length in f32: **10** std140 rows (40). Header layout is duplicated
/// in the WGSL `struct U`; changing one without the other silently mis-reads
/// every uniform. Row 9 (`col2`) carries a secondary neon accent so the
/// shader can paint two contrasting hues across one frame (cyan body /
/// magenta rim, etc).
const UBO_LEN: usize = 40;

const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
const TAU: f32 = std::f32::consts::TAU;

/// Neon-accent class — picks the violent-flash hue. Derived from the
/// committed fingerprint's dominant chroma class % 3.
#[derive(Clone, Copy, PartialEq, Debug)]
enum Accent {
    Cyan,
    Magenta,
    AcidGreen,
}

impl Accent {
    fn from_chroma(c: usize) -> Self {
        match c % 3 {
            0 => Accent::Cyan,
            1 => Accent::Magenta,
            _ => Accent::AcidGreen,
        }
    }
    /// Centre hue (radians) for this neon class — OKLCH wheel convention
    /// shared with `palette::from_audio`.
    fn hue(self) -> f32 {
        match self {
            // Eyeballed in OKLCH so the chroma lands near max-vibrance for
            // each named neon (cyan ≈ 195°, magenta ≈ 325°, acid ≈ 130°).
            Accent::Cyan => 3.40,
            Accent::Magenta => 5.67,
            Accent::AcidGreen => 2.27,
        }
    }
    /// Partner-class hue — the secondary neon paired with this one for
    /// per-frame contrast (cyan↔magenta, magenta↔acid, acid↔cyan). Keeps two
    /// hues in frame at once so the picture has actual colour, not a wash.
    fn partner(self) -> Accent {
        match self {
            Accent::Cyan => Accent::Magenta,
            Accent::Magenta => Accent::AcidGreen,
            Accent::AcidGreen => Accent::Cyan,
        }
    }
}

pub struct Monolith {
    pub seed: u64,
    rng: Rng,

    fp: Fingerprint,
    fp_committed: bool,
    accent_class: Accent,

    structure: Structure,

    // springs
    sp_scale: Spring, // sub-bass breath (bulb world scale)
    sp_glow: Spring,
    sp_power: Spring, // bulb power n (mid drift + fingerprint bias)
    sp_dist: Spring,  // camera distance (kick pulls back into void)

    // stutter FSM — snare-flux burst freezes camera/scale/glow for ~120 ms,
    // shader pins feedback decay near 1.0 so the prev frame survives.
    stutter_w: f32,
    stutter_gate: f32,
    held_yaw: f32,
    held_pitch: f32,
    held_roll: f32,
    held_dist: f32,
    held_scale: f32,
    held_glow: f32,

    // smoothed glitch envelope feeding the shader's coarse-cell UV-shove
    glitch_env: f32,

    // mid-band ink-in-water feedback swirl accumulator
    swirl_phase: f32,

    // camera + smoothed colour
    yaw: f32,
    pitch: f32,
    roll: f32,
    hue_b: f32,  // base hue (deep blue↔purple arc)
    hue_a: f32,  // primary accent hue
    hue_a2: f32, // secondary accent hue (partner neon)

    t: f32,
    frame: u32,
    b: Bands,

    rw: u32,
    rh: u32,
    gpu: ShaderPipeline<[f32; UBO_LEN]>,
}

impl Monolith {
    /// `w`×`h` is the raymarch target size (output × supersample); any aspect.
    pub fn new(seed: u64, device: &wgpu::Device, w: u32, h: u32) -> Self {
        let mut rng = Rng::new(seed ^ 0xC0FF_EEFA_CADE_B00C_u64);
        // Per-run novelty: nudge camera start so each run isn't identical.
        let yaw0 = rng.range(0.0, TAU);
        let pitch0 = rng.range(-0.25, 0.25);
        let swirl0 = rng.range(0.0, TAU);
        Monolith {
            seed,
            rng,
            fp: Fingerprint::default(),
            fp_committed: false,
            accent_class: Accent::Cyan,
            structure: Structure::new(),
            sp_scale: Spring { x: 1.0, v: 0.0 },
            sp_glow: Spring { x: 0.55, v: 0.0 },
            sp_power: Spring { x: 8.0, v: 0.0 },
            sp_dist: Spring { x: 2.8, v: 0.0 },
            stutter_w: 0.0,
            stutter_gate: 0.0,
            held_yaw: yaw0,
            held_pitch: pitch0,
            held_roll: 0.0,
            held_dist: 2.8,
            held_scale: 1.0,
            held_glow: 0.55,
            glitch_env: 0.0,
            swirl_phase: swirl0,
            yaw: yaw0,
            pitch: pitch0,
            roll: 0.0,
            hue_b: 4.6,
            hue_a: 3.4,
            hue_a2: 5.67,
            t: 0.0,
            frame: 0,
            b: Bands::default(),
            rw: w,
            rh: h,
            gpu: ShaderPipeline::new(device, include_str!("monolith.wgsl"), w, h, FMT),
        }
    }

    pub fn reseed(&mut self, seed: u64) {
        self.seed = seed;
        self.rng = Rng::new(seed ^ 0xC0FF_EEFA_CADE_B00C_u64);
        self.yaw = self.rng.range(0.0, TAU);
        self.pitch = self.rng.range(-0.25, 0.25);
        self.roll = 0.0;
        self.swirl_phase = self.rng.range(0.0, TAU);
        self.stutter_w = 0.0;
        self.stutter_gate = 0.0;
        self.glitch_env = 0.0;
    }

    /// "Element count" for the HUD — there is no element list (the form is
    /// the DE), so report the bulb iteration count instead.
    pub fn element_count(&self) -> usize {
        8
    }

    /// Install a fingerprint and re-derive accent class / palette bias.
    /// Cheap; idempotent — safe to call repeatedly.
    pub fn install_fingerprint(&mut self, fp: Fingerprint) {
        self.fp = fp;
        self.fp_committed = true;
        self.accent_class = Accent::from_chroma(fp.chroma_dom);
    }

    pub fn fingerprint_committed(&self) -> bool {
        self.fp_committed
    }

    pub fn update(&mut self, b: &Bands, dt: f32) {
        let dt = dt.clamp(0.0, 0.05);
        self.t += dt;
        self.frame = self.frame.wrapping_add(1);
        self.b = *b;

        self.structure.update(b, dt);
        let arch = self.structure.arch();
        let release = self.structure.release();

        // Dynamic-range scaled motion (premise: quiet songs move slowly).
        let dyn_m = (0.40 + 0.85 * self.fp.dyn_range).clamp(0.40, 1.20);

        // Quadratic shape of the audio levels so light hats / room tone
        // contribute near zero, and only real hits move the picture. This is
        // the single biggest "proportionality" lever — a linear `b.high` of
        // 0.2 becomes 0.04 here, a `b.high` of 0.8 stays 0.64.
        let low_q = b.low * b.low;
        let mid_q = b.mid * b.mid;
        let high_q = b.high * b.high;
        let flux_q = b.flux * b.flux;

        // --- sub-bass breath: sp_scale grows on low²; the kick still reads,
        // a mid-range hum doesn't.
        let scale_t = 1.0 + 0.40 * low_q + 0.22 * b.low_on;
        self.sp_scale.step(scale_t, 5.0 * dyn_m, dt);

        // --- distance: kick pulls back into void; release kick-back shove.
        let dist_t = 2.8 + 0.35 * low_q + 0.15 * b.low_on;
        self.sp_dist.step(dist_t, 4.0 * dyn_m, dt);
        self.sp_dist.x += 1.2 * release * release; // Immediate shove on drop

        // --- bulb power: small drift around 8 — mid² nudges it gently and
        // the fingerprint's tonality biases the resting point.
        let power_t = 7.8 + 0.5 * self.fp.tonality + 0.2 * (mid_q - 0.25);
        self.sp_power.step(power_t.clamp(6.5, 9.5), 2.0, dt);

        // --- glow: rides loudness² + flux². Quiet floor sits low so the
        // bulb is a dark silhouette by default, only loud moments lift it.
        self.sp_glow.step(
            0.28 + 0.35 * b.loud * b.loud + 0.20 * flux_q,
            5.5 * dyn_m,
            dt,
        );

        // --- glitch envelope: smoothed hi-band onset / flux with a deadband.
        let raw = 0.7 * b.high_on * b.high_on + 0.35 * flux_q;
        let glitch_target = (raw - 0.10).clamp(0.0, 1.2);
        let g_tau = if glitch_target > self.glitch_env {
            0.08
        } else {
            0.40
        };
        let a_g = 1.0 - (-dt / g_tau).exp();
        self.glitch_env += (glitch_target - self.glitch_env) * a_g;

        // --- stutter FSM (the "drops to 12 fps" simulation). Triggered only
        // by real snare-flux bursts.
        self.stutter_gate = (self.stutter_gate - dt).max(0.0);
        self.stutter_w = (self.stutter_w - dt / 0.08).max(0.0);
        let snare_burst = (b.high_on > 0.75 && b.flux > 0.70) || b.flux > 0.94 || b.high_on > 0.88;

        // Gate stutter more aggressively during drops/builds so it doesn't "stuck" the energy.
        let stutter_cooldown = match arch {
            Arch::Drop | Arch::Build => 0.65,
            _ => 0.45,
        };

        if snare_burst && self.stutter_gate <= 0.0 {
            self.stutter_w = 1.0;
            self.stutter_gate = stutter_cooldown;
            self.held_yaw = self.yaw;
            self.held_pitch = self.pitch;
            self.held_roll = self.roll;
            self.held_dist = self.sp_dist.x;
            self.held_scale = self.sp_scale.x;
            self.held_glow = self.sp_glow.x;
        }

        // --- camera: Section-aware rotation rate.
        let energy_mult = match arch {
            Arch::Drop => 2.4,
            Arch::Build => 1.4 + self.structure.tension(),
            Arch::Ambient | Arch::Breakdown => 0.45,
            _ => 1.0,
        };

        let base_rate = 0.05 + 0.10 * self.fp.tempo_class;
        let rate = base_rate * dyn_m * energy_mult;
        self.yaw += rate * dt + 0.15 * b.beat * b.beat * dt;
        self.pitch += (0.12 * low_q - 0.04) * rate * dt;
        self.roll += 0.04 * high_q * dt;

        // --- swirl: mid² accumulates the feedback rotation.
        self.swirl_phase += (0.15 + 0.6 * mid_q) * 0.30 * dt;

        // --- colour inertia.
        let base_t = (5.0 - b.centroid * 1.4).rem_euclid(TAU);
        let acc_t = self.accent_class.hue()
            + (self.fp.chroma_dom as f32) / 12.0 * 0.3
            + 0.15 * (mid_q - 0.25);
        let acc2_t = self.accent_class.partner().hue() + 0.15 * (high_q - 0.25);
        let ha = 1.0 - (-dt / 0.5).exp();
        self.hue_b = angle_to(self.hue_b, base_t, ha);
        self.hue_a = angle_to(self.hue_a, acc_t, ha);
        self.hue_a2 = angle_to(self.hue_a2, acc2_t, ha);
    }

    /// Render this frame into the target and return it.
    #[allow(clippy::too_many_arguments)]
    pub fn render(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        pal: &Palette,
        scale: f32,
        _warp: f32,
        feedback: bool,
        fade: f32,
        ca_px: f32,
        drive: f32,
        march_cap: u32,
    ) -> &wgpu::Texture {
        let dr = drive.clamp(0.0, 3.0);
        let dyn_m = (0.40 + 0.85 * self.fp.dyn_range).clamp(0.40, 1.20);
        let arch = self.structure.arch();

        // Held-vs-live blending
        let s = self.stutter_w.clamp(0.0, 1.0);
        let yaw = self.yaw * (1.0 - s) + self.held_yaw * s;
        let pitch = self.pitch * (1.0 - s) + self.held_pitch * s;
        let roll = self.roll * (1.0 - s) + self.held_roll * s;
        let dist = self.sp_dist.x * (1.0 - s) + self.held_dist * s;
        let scl = self.sp_scale.x * (1.0 - s) + self.held_scale * s;
        let glow = self.sp_glow.x * (1.0 - s) + self.held_glow * s;

        // Palette
        let lo = self.b.loud;
        let base = oklch(
            (0.14 + 0.14 * lo * lo).min(0.42),
            (0.035 + 0.015 * self.fp.tonality).min(0.06),
            self.hue_b,
        );
        let acc_sat = (0.18 + 0.05 * lo) * (0.65 + 0.40 * self.fp.tonality);
        let acc = oklch((0.68 + 0.20 * lo).min(0.92), acc_sat, self.hue_a);
        let acc2 = oklch(
            (0.66 + 0.20 * lo).min(0.90),
            (acc_sat * 0.85).min(0.30),
            self.hue_a2,
        );

        let mut u = [0.0f32; UBO_LEN];

        // row0 cam
        u[0] = yaw;
        u[1] = pitch;
        u[2] = roll;
        u[3] = dist.clamp(1.8, 4.5);

        // row1 p0 = scale, glow_gain, ca_px, edge_softness
        u[4] = (scale * scl).clamp(0.4, 2.2);
        u[5] = glow.clamp(0.18, 0.85);
        u[6] = ca_px * (0.6 + 0.4 * dr) * (1.0 + 0.6 * s);
        u[7] = (0.50 + 0.45 * (1.0 - self.fp.tonality) + 0.15 * self.b.flatness).clamp(0.30, 1.10);

        // row2 col0 = base.rgb, fade
        u[8] = base[0];
        u[9] = base[1];
        u[10] = base[2];
        u[11] = (fade * (1.0 - 0.25 * (1.0 - dyn_m))).clamp(0.02, 1.0);

        // row3 col1 = accent.rgb, flash
        u[12] = acc[0];
        u[13] = acc[1];
        u[14] = acc[2];
        u[15] = pal.flash;

        // row4 p1 = res_w, res_h, frame, time
        u[16] = self.rw as f32;
        u[17] = self.rh as f32;
        u[18] = (self.frame & 0xffff) as f32;
        u[19] = self.t;

        // row5 p2 = march_steps, power_n, feedback_on, world_r
        u[20] = (20.0 + 7.0 * dr).clamp(16.0, march_cap.min(96) as f32);
        u[21] = self.sp_power.x.clamp(6.5, 9.5);
        u[22] = if feedback && self.gpu.primed() {
            1.0
        } else {
            0.0
        };
        u[23] = (1.30 * scl + 0.20).clamp(1.0, 3.5);

        // row6 p3 = grain, glitch_a, fog, beat
        // Gated grain: ambient/breakdown reduces grain base to near zero.
        let g_base = match arch {
            Arch::Ambient | Arch::Breakdown => 0.001,
            _ => 0.005,
        };
        u[24] = (g_base + 0.012 * self.b.flux * dr).clamp(0.0, 0.022);
        u[25] = (self.glitch_env * dr).clamp(0.0, 1.2);
        u[26] = (0.30 + 0.35 * self.b.loud).clamp(0.20, 0.75);
        u[27] = self.b.beat;

        // row7 p4 = loud, low, mid, high
        u[28] = self.b.loud;
        u[29] = self.b.low;
        u[30] = self.b.mid;
        u[31] = self.b.high;

        // row8 p5 = stutter_w, swirl, aspect, tonality
        u[32] = s;
        u[33] = self.swirl_phase % TAU;
        u[34] = self.rw as f32 / self.rh.max(1) as f32;
        u[35] = self.fp.tonality.clamp(0.0, 1.0);

        // row9 col2 = secondary accent.rgb, release
        u[36] = acc2[0];
        u[37] = acc2[1];
        u[38] = acc2[2];
        u[39] = self.structure.release();

        self.gpu.render(device, queue, &u)
    }

    pub fn current(&self) -> &wgpu::Texture {
        self.gpu.current()
    }

    pub fn capture_raw(
        &self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
    ) -> anyhow::Result<Vec<u8>> {
        read_texture_rgba(device, queue, self.gpu.current(), self.rw, self.rh)
    }
}