//! Oscilloscope *art* — vector-display structures in the spirit of
//! oscilloscope-music visuals (Jerobeam Fenderson / sakr / OsciStudio).
//!
//! A phosphor beam traces a deterministic 3D wireframe **figure** — a torus
//! knot, a Gielis supershape, a 3D Lissajous, a harmonograph, a rose-helix —
//! whose parameters are seeded so every track/seed yields a distinct object.
//! The figure is not chaotic frame-to-frame: it holds, and *morphs* into a
//! freshly-seeded figure on a strong broadband transient (cooldown-gated, like
//! the sigil's restructure), the two point-sets lerped so the change reads as
//! the music turning a corner rather than a glitch.
//!
//! Audio drives it continuously: rotation from mid/low, a breathing scale from
//! low/loud, slow figure-parameter drift from spectral brightness, and a gentle
//! beam-noise wobble from the live waveform + flux — so it captures what is
//! playing *now* while staying a coherent shape.
//!
//! Rendering is vector-display: a faint continuous beam, brightened where the
//! beam moves slowly (the real-scope intensity trick), dithered into dots, over
//! a faint CRT grain, near-monochrome (the palette desaturated so the hue still
//! drifts with timbre). The post stack's feedback gives the phosphor decay.
//!
//! Determinism: `Rng` is only advanced in `update` (figure selection); the
//! dither/grain are pure hashes of (index, frame). `update` runs once per
//! frame, so live and `--render` stay bit-identical per seed + timeline.

use crate::audio::{Bands, WAVE_N};
use crate::viz::curve::{Rng, flow};
use crate::viz::geometry::Figure;
use crate::viz::math::smoothstep;
use crate::viz::palette::Palette;
use nannou::prelude::*;

const FIELD: f32 = 960.0; // design-space extent (matches sigil/post)
const N: usize = 1600; // beam samples per figure
const MORPH_SECS: f32 = 0.85; // figure cross-fade time

/// Stateless hash -> 0..1 (ordered dither + grain; deterministic per frame).
fn h01(a: u32, b: u32) -> f32 {
    let mut x = a.wrapping_mul(0x9E37_79B1) ^ b.wrapping_mul(0x85EB_CA77) ^ 0xC2B2_AE3D;
    x ^= x >> 15;
    x = x.wrapping_mul(0x2545_F491);
    x ^= x >> 13;
    (x >> 9) as f32 / (1u32 << 23) as f32
}

// `Figure` (torus knot / Gielis supershape / 3D Lissajous / harmonograph /
// rose-helix) is shared geometry — see `crate::viz::geometry` (imported
// above). The scope only seeds (`Figure::random`) and samples (`.at`) it.

pub struct Scope {
    pub seed: u64,
    rng: Rng,
    cur: Figure,
    tgt: Figure,
    morph: f32, // 0..1 cur->tgt (1 = settled)
    yaw: f32,
    pitch: f32,
    roll: f32,
    breathe: f32,
    restruct_cd: f32,
    prev_flux: f32,
    idle: f32, // seconds since last change (quiet-track fallback)
    wave: [f32; WAVE_N],
    loud: f32,
    flux: f32,
    centroid: f32,
    t: f32,
}

impl Scope {
    pub fn new(seed: u64) -> Self {
        let mut rng = Rng::new(seed ^ 0x05C0_BE11);
        let cur = Figure::random(&mut rng);
        Scope {
            seed,
            rng,
            cur,
            tgt: cur,
            morph: 1.0,
            yaw: 0.0,
            pitch: 0.0,
            roll: 0.0,
            breathe: 0.0,
            restruct_cd: 0.0,
            prev_flux: 0.0,
            idle: 0.0,
            wave: [0.0; WAVE_N],
            loud: 0.0,
            flux: 0.0,
            centroid: 0.0,
            t: 0.0,
        }
    }

    pub fn reseed(&mut self, seed: u64) {
        *self = Scope::new(seed);
    }

    pub fn point_count(&self) -> usize {
        N
    }

    /// Begin a morph into a freshly-seeded figure.
    fn restructure(&mut self) {
        self.tgt = Figure::random(&mut self.rng);
        self.morph = 0.0;
        self.idle = 0.0;
    }

    pub fn update(&mut self, b: &Bands, dt: f32) {
        let dt = dt.clamp(0.0, 0.05);
        self.t += dt;
        self.wave = b.wave;
        self.loud = b.loud;
        self.flux = b.flux;
        self.centroid = b.centroid;

        // Smooth, music-locked motion (no random snaps).
        self.yaw += (0.14 + 0.85 * b.mid) * dt;
        self.pitch += (0.06 + 0.45 * b.low) * dt + 0.025 * dt;
        self.roll += 0.04 * dt + 0.35 * b.high * dt;
        self.breathe += dt * (0.25 + 1.1 * b.mid + 0.5 * b.low);

        // Advance an in-flight morph; settle onto the target.
        if self.morph < 1.0 {
            self.morph = (self.morph + dt / MORPH_SECS).min(1.0);
            if self.morph >= 1.0 {
                self.cur = self.tgt;
            }
        }

        // Change figure on a rising broadband transient (cooldown-gated), or
        // on a long idle so quiet passages still evolve.
        self.restruct_cd = (self.restruct_cd - dt).max(0.0);
        self.idle += dt;
        let rising = b.flux > 0.6 && self.prev_flux <= 0.6;
        if self.morph >= 1.0
            && self.restruct_cd <= 0.0
            && (rising || self.idle > 12.0)
        {
            self.restruct_cd = 1.2;
            self.restructure();
        }
        self.prev_flux = b.flux;
    }

    /// Near-monochrome phosphor: keep the palette's hue drift but pull most of
    /// the chroma out and lift luminance so it reads as a vector display.
    fn phosphor(c: [f32; 4]) -> [f32; 4] {
        let lum = 0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2];
        let mix = 0.62;
        [
            ((c[0] * (1.0 - mix) + lum * mix) * 1.18).min(1.0),
            ((c[1] * (1.0 - mix) + lum * mix) * 1.18).min(1.0),
            ((c[2] * (1.0 - mix) + lum * mix) * 1.18).min(1.0),
            c[3],
        ]
    }

    #[allow(clippy::too_many_arguments)]
    pub fn draw(
        &self,
        draw: &Draw,
        pal: &Palette,
        fit: f32,
        scale: f32,
        warp: f32,
        glow: bool,
        _seg: usize,
        tint: [f32; 3],
    ) {
        let (sy, cy) = self.yaw.sin_cos();
        let (sp, cp) = self.pitch.sin_cos();
        let (sr, cr) = self.roll.sin_cos();
        let dist = FIELD * 1.7;
        let amp = FIELD * 0.40 * (0.85 + 0.30 * scale.min(1.6) + 0.10 * self.breathe.sin());
        let e = smoothstep(self.morph);
        // Slow figure-character drift from spectral brightness, beam-noise from
        // the live waveform + flux — subtle, so the shape stays coherent.
        let drift = 1.0 + 0.10 * (self.centroid - 0.5);
        let beam_amp = (0.012 + 0.05 * self.flux) * warp.max(0.2);

        let project = |i: usize| -> (Vec2, f32) {
            let u = i as f32 / N as f32;
            let a = self.cur.at(u);
            let mut q = if e < 1.0 {
                let bpt = self.tgt.at(u);
                a + (bpt - a) * e
            } else {
                a
            };
            q *= drift * amp;
            // beam-signal wobble: the actual waveform perturbs the trace
            let wv = self.wave[(i * WAVE_N / N) % WAVE_N];
            let nz = flow(vec2(q.x, q.y), self.t, self.seed as u32);
            q.x += nz.x * amp * beam_amp + wv * amp * beam_amp * 1.5;
            q.y += nz.y * amp * beam_amp;
            // rotate yaw(Y) -> pitch(X) -> roll(Z)
            let (x1, z1) = (q.x * cy - q.z * sy, q.x * sy + q.z * cy);
            let (y2, z2) = (q.y * cp - z1 * sp, q.y * sp + z1 * cp);
            let (x3, y3) = (x1 * cr - y2 * sr, x1 * sr + y2 * cr);
            let f = dist / (dist + z2.max(-dist * 0.9));
            (vec2(x3 * f, y3 * f) * fit, z2)
        };

        // Build the screen path + per-segment beam speed (for brightness).
        let mut scr: Vec<Vec2> = Vec::with_capacity(N);
        for i in 0..N {
            scr.push(project(i).0);
        }

        let roll_h = self.roll.rem_euclid(std::f32::consts::TAU) / std::f32::consts::TAU;
        let base = Self::phosphor(pal.stroke(0.5, (0.5 + 0.5 * self.loud).min(1.0), roll_h));
        let put = |a: Vec2, c: Vec2, w: f32, col: [f32; 4]| {
            draw.polyline()
                .weight(w)
                .points([a, c])
                .color(srgba(
                    col[0] * tint[0],
                    col[1] * tint[1],
                    col[2] * tint[2],
                    col[3],
                ));
        };

        // Faint continuous beam for path continuity (phosphor base + halo).
        if glow {
            draw.polyline()
                .weight(5.0)
                .points(scr.iter().cloned())
                .color(srgba(
                    base[0] * tint[0],
                    base[1] * tint[1],
                    base[2] * tint[2],
                    0.035,
                ));
        }
        draw.polyline()
            .weight(1.0)
            .points(scr.iter().cloned())
            .color(srgba(
                base[0] * tint[0],
                base[1] * tint[1],
                base[2] * tint[2],
                0.10,
            ));

        // Dithered beam: bright where it moves slowly (real-scope intensity),
        // gated by an ordered dither so it reads as grain, not a solid line.
        let fr = (self.t * 60.0) as u32;
        let s32 = self.seed as u32;
        for i in 1..N {
            let (a, c) = (scr[i - 1], scr[i]);
            let len = (c - a).length().max(1e-3);
            // slow beam -> bright; fast beam -> dim (energy spreads over px)
            let inten = (10.0 / (1.0 + 0.05 * len)).min(1.0);
            let dith = h01(s32 ^ i as u32, fr ^ (i as u32 >> 3));
            if inten < dith * 0.85 {
                continue;
            }
            let mut col = Self::phosphor(pal.stroke(i as f32 / N as f32, 0.6 + 0.4 * self.loud, roll_h));
            col[3] = (0.18 + 0.55 * inten) * (0.7 + 0.3 * self.loud);
            put(a, c, 1.0 + 1.4 * inten, col);
        }

        // Faint CRT grain so the field is alive even between strokes.
        let grain = 90 + (self.loud * 140.0) as usize;
        for k in 0..grain {
            let gx = (h01(s32 ^ 0x00A1 ^ k as u32, fr) - 0.5) * FIELD * fit;
            let gy = (h01(s32 ^ 0x005C ^ k as u32, fr.wrapping_add(7)) - 0.5) * FIELD * fit;
            draw.rect().x_y(gx, gy).w_h(1.0, 1.0).color(srgba(
                base[0] * tint[0],
                base[1] * tint[1],
                base[2] * tint[2],
                0.05,
            ));
        }
    }
}