// name: Pulsing sphere
// protocol: furumi-visualizer-v2
// bundle-version: 5
//
// A second bundled example with a very different structure from
// scope_spectrum.rhai: instead of a waveform-first visual, it renders a
// hollow terminal "sphere" whose radius, halo and palette respond to audio.
//
// Script entry point:
//   fn render(input) -> Array<Map>
//
// Input map fields supplied by Furumi:
//   width, height              terminal size in cells
//   time, position, progress   animation time and playback progress
//   volume, paused             player state
//   energy, bass, mid, treble  smoothed audio bands in the 0.0..1.0 range
//   beat                       transient pulse estimate in the 0.0..1.0 range
//   seed                       stable per-track number in the 0.0..1.0 range
//   samples                    recent mono waveform samples in the -1.0..1.0 range
//   show_clock, clock          user setting and formatted clock text
//   track_title, track_artist  metadata strings
//
// Useful numeric helpers available to scripts:
//   to_int, to_float           Rhai conversions
//   sin, cos, tan, sqrt, abs, pow
// Scripts cannot import modules; keep every visualization self-contained.
//
// Draw command maps returned from render(input):
//   #{ op: "clear", bg: 0x000000 }
//   #{ op: "cell", x: 10, y: 4, ch: "*", fg: 0x33ffee, bg: 0x000000 }
//   #{ op: "hline", x: 0, y: 4, w: 20, ch: "-", fg: 0x33ffee, bg: 0x000000 }
//   #{ op: "vline", x: 10, y: 0, h: 12, ch: "|", fg: 0x33ffee, bg: 0x000000 }
//   #{ op: "rect", x: 10, y: 6, w: 2, h: 4, ch: "#", fg: 0x33ffee, bg: 0x000000 }
//   #{ op: "trace", x: 0, ys: [4, 5, 3], ch: "*", line_ch: "|", fg: 0xffffff, line_fg: 0x558888, bg: 0x000000 }
//   #{ op: "text", x: 2, y: 1, text: "hello", fg: 0xffffff, bg: 0x000000 }
//
// This script intentionally uses every command type. The sphere itself stays
// hollow: trace commands draw its spectral outline and orbit, hline draws
// latitudes, rect/vline draw the small energy meter, cells create stars and
// burst nodes, and labels use text.

fn clamp(value, low, high) {
    if value < low {
        low
    } else if value > high {
        high
    } else {
        value
    }
}

fn min(left, right) {
    if left < right { left } else { right }
}

fn max(left, right) {
    if left > right { left } else { right }
}

fn rgb(r, g, b) {
    let rr = to_int(clamp(r, 0, 255));
    let gg = to_int(clamp(g, 0, 255));
    let bb = to_int(clamp(b, 0, 255));
    rr * 65536 + gg * 256 + bb
}

fn lerp(left, right, mix) {
    left * (1.0 - mix) + right * mix
}

fn sample_at(samples, nx) {
    let len = samples.len();
    if len <= 0 {
        0.0
    } else {
        let pos = clamp(nx, 0.0, 1.0) * (len - 1);
        let left = to_int(pos);
        let right = if left + 1 < len { left + 1 } else { left };
        let mix = pos - to_float(left);
        lerp(samples[left], samples[right], mix)
    }
}

fn cell(x, y, ch, fg, bg) {
    #{ op: "cell", x: x, y: y, ch: ch, fg: fg, bg: bg }
}

fn hline(x, y, w, ch, fg, bg) {
    #{ op: "hline", x: x, y: y, w: w, ch: ch, fg: fg, bg: bg }
}

fn vline(x, y, h, ch, fg, bg) {
    #{ op: "vline", x: x, y: y, h: h, ch: ch, fg: fg, bg: bg }
}

fn rect(x, y, w, h, ch, fg, bg) {
    #{ op: "rect", x: x, y: y, w: w, h: h, ch: ch, fg: fg, bg: bg }
}

fn trace(x, ys, ch, line_ch, fg, line_fg, bg) {
    #{ op: "trace", x: x, ys: ys, ch: ch, line_ch: line_ch, fg: fg, line_fg: line_fg, bg: bg }
}

fn text(x, y, value, fg, bg) {
    #{ op: "text", x: x, y: y, text: value, fg: fg, bg: bg }
}

// A time-varying RGB palette. "shade" is usually 0.0..1.0; larger values are
// allowed and clamped by rgb(). Audio bands shift the hue without Rust knowing
// anything about the visual.
fn palette(input, shade, phase) {
    let t = input.time + input.seed * 8.0 + phase;
    let bass_push = input.bass * 70.0;
    let treble_push = input.treble * 65.0;
    rgb(
        50 + shade * 130 + sin(t * 0.90) * 55 + bass_push,
        70 + shade * 115 + sin(t * 0.63 + 2.1) * 55 + input.mid * 55,
        95 + shade * 145 + cos(t * 0.72 + 0.7) * 55 + treble_push
    )
}

fn wrap01(value) {
    let out = value;
    while out < 0.0 {
        out += 1.0;
    }
    while out > 1.0 {
        out -= 1.0;
    }
    out
}

fn spectral_band(input, phase) {
    if phase < 0.34 {
        input.bass
    } else if phase < 0.68 {
        input.mid
    } else {
        input.treble
    }
}

// Treat the waveform as if it was wrapped around the sphere. The returned
// value is a radial spike amount: low frequencies push broad parts of the
// contour, raw samples add sharp teeth, and beat makes the edge jump outward.
fn edge_spectrum(input, phase) {
    let p = wrap01(phase);
    let wave = abs(sample_at(input.samples, p));
    let neighbor = abs(sample_at(input.samples, wrap01(p + 0.021)));
    let band = spectral_band(input, p);
    let flutter = abs(sin(input.time * (5.0 + p * 7.0) + p * 38.0 + input.seed * 9.0));
    let fine = abs(cos(input.time * (8.0 + p * 4.0) - p * 71.0));
    clamp(
        wave * (0.62 + input.energy * 0.36)
            + neighbor * 0.24
            + band * 0.46
            + input.beat * (0.30 + flutter * 0.64)
            + fine * input.energy * 0.18,
        0.0,
        1.55
    )
}

fn push_starfield(cmds, input, bg) {
    let stars = 34;
    let index = 0;
    while index < stars {
        let x = (index * 37 + to_int(input.seed * 1000.0)) % max(input.width, 1);
        let y = (index * 17 + to_int(input.time * 2.0)) % max(input.height, 1);
        let speed = 0.7 + to_float(index % 5) * 0.15;
        let twinkle = abs(sin(input.time * speed + to_float(index)));
        let fg = rgb(
            45 + twinkle * 120 + input.treble * 80,
            75 + twinkle * 120,
            105 + twinkle * 130
        );
        let ch = if twinkle + input.beat > 1.25 { "*" } else { "." };
        cmds.push(cell(x, y, ch, fg, bg));
        index += 1;
    }
    cmds
}

fn push_orbit(cmds, input, cx, cy, rx, ry, bg) {
    let width = max(rx * 2 + 9, 3);
    let start_x = max(cx - width / 2, 0);
    let max_w = input.width - start_x;
    let actual_w = min(width, max_w);
    let back = [];
    let front = [];
    let i = 0;
    while i < actual_w {
        let nx = to_float(i) / to_float(max(actual_w - 1, 1));
        let angle = nx * 6.28318 + input.time * 0.85;
        let sample = sample_at(input.samples, nx);
        let wobble = (sin(angle + input.bass * 2.0) + sample * 0.28)
            * to_float(max(ry, 1))
            * (0.28 + input.energy * 0.10);
        let y_front = to_int(clamp(
            to_float(cy) + wobble + input.beat * 1.5,
            0.0,
            to_float(input.height - 1)
        ));
        let y_back = to_int(clamp(
            to_float(cy) - wobble - input.beat * 1.5,
            0.0,
            to_float(input.height - 1)
        ));
        front.push(y_front);
        back.push(y_back);
        i += 1;
    }

    let back_fg = palette(input, 0.18, 3.4);
    let front_fg = palette(input, 0.65 + input.beat * 0.25, 0.5);
    cmds.push(trace(start_x, back, ".", ".", back_fg, back_fg, bg));
    cmds.push(trace(start_x, front, "*", ".", front_fg, front_fg, bg));
    cmds
}

fn push_pulse_ring(cmds, input, cx, cy, rx, ry, bg) {
    let ring_rx = rx + 2 + to_int(input.beat * 5.0 + input.energy * 2.0);
    let ring_ry = ry + 1 + to_int(input.beat * 3.0 + input.bass * 2.0);
    let left = max(cx - ring_rx, 0);
    let right = min(cx + ring_rx, input.width - 1);
    let width = right - left + 1;
    if width <= 2 {
        return cmds;
    }

    let top = [];
    let bottom = [];
    let i = 0;
    while i < width {
        let nx = if width > 1 { to_float(i) / to_float(width - 1) * 2.0 - 1.0 } else { 0.0 };
        let phase = to_float(i) / to_float(max(width - 1, 1));
        let inside = max(1.0 - nx * nx, 0.0);
        let spike = edge_spectrum(input, phase) * (1.0 + input.energy * 3.0 + input.beat * 2.0);
        let y = sqrt(inside) * (to_float(ring_ry) + spike);
        top.push(to_int(clamp(to_float(cy) - y, 0.0, to_float(input.height - 1))));
        bottom.push(to_int(clamp(to_float(cy) + y, 0.0, to_float(input.height - 1))));
        i += 1;
    }

    let color = palette(input, 0.14 + input.beat * 0.35, 4.8);
    cmds.push(trace(left, top, ".", ".", color, color, bg));
    cmds.push(trace(left, bottom, ".", ".", color, color, bg));
    cmds
}

fn push_sphere(cmds, input, cx, cy, rx, ry, bg) {
    let left = max(cx - rx, 0);
    let right = min(cx + rx, input.width - 1);
    let width = right - left + 1;
    if width <= 2 {
        return cmds;
    }

    let top = [];
    let bottom = [];
    let glow_top = [];
    let glow_bottom = [];
    let i = 0;
    while i < width {
        let nx = if width > 1 { to_float(i) / to_float(width - 1) * 2.0 - 1.0 } else { 0.0 };
        let inside = max(1.0 - nx * nx, 0.0);
        let phase = to_float(i) / to_float(max(width - 1, 1));
        let top_spike = edge_spectrum(input, phase) * (1.0 + input.energy * 3.4 + input.beat * 3.0);
        let bottom_spike = edge_spectrum(input, 1.0 - phase) * (1.0 + input.energy * 3.4 + input.beat * 3.0);
        let edge = sqrt(inside) * to_float(ry);
        let top_y = to_int(clamp(to_float(cy) - edge - top_spike, 0.0, to_float(input.height - 1)));
        let bottom_y = to_int(clamp(to_float(cy) + edge + bottom_spike, 0.0, to_float(input.height - 1)));
        let glow = 1 + to_int(max(top_spike, bottom_spike) * 0.35 + input.beat * 2.0);

        top.push(top_y);
        bottom.push(bottom_y);
        glow_top.push(clamp(top_y - glow, 0, input.height - 1));
        glow_bottom.push(clamp(bottom_y + glow, 0, input.height - 1));
        i += 1;
    }

    let glow = palette(input, 0.22 + input.energy * 0.22, 3.1);
    let outline = palette(input, 0.82 + input.beat * 0.45, 0.3);
    let bridge = palette(input, 0.42 + input.mid * 0.25, 2.2);
    cmds.push(trace(left, glow_top, ".", ".", glow, glow, bg));
    cmds.push(trace(left, glow_bottom, ".", ".", glow, glow, bg));
    cmds.push(trace(left, top, "*", ".", outline, bridge, bg));
    cmds.push(trace(left, bottom, "*", ".", outline, bridge, bg));

    let equator = palette(input, 0.50 + input.bass * 0.25, 5.6);
    cmds.push(hline(left, cy, width, "-", equator, bg));
    if ry > 4 {
        let latitude = palette(input, 0.35 + input.treble * 0.20, 1.8);
        let span = max(width - width / 3, 3);
        let lat_x = left + (width - span) / 2;
        let lat_y = max(cy - ry / 2, 0);
        cmds.push(hline(lat_x, lat_y, span, ".", latitude, bg));
        cmds.push(hline(lat_x, min(cy + ry / 2, input.height - 1), span, ".", latitude, bg));
    }

    let nodes = 42;
    let node = 0;
    while node < nodes {
        let phase = to_float(node) / to_float(nodes);
        let angle = phase * 6.28318 + input.time * (0.10 + input.treble * 0.08);
        let spectrum = edge_spectrum(input, phase);
        let burst = spectrum * (1.4 + input.energy * 4.2 + input.beat * 3.5);
        let x = to_int(clamp(to_float(cx) + cos(angle) * (to_float(rx) + burst), 0.0, to_float(input.width - 1)));
        let y = to_int(clamp(to_float(cy) + sin(angle) * (to_float(ry) + burst * 0.58), 0.0, to_float(input.height - 1)));
        let fg = palette(input, 0.48 + spectrum * 0.36 + input.beat * 0.30, angle);
        let ch = if spectrum > 1.05 { "*" } else if spectrum > 0.72 { "+" } else { "." };
        cmds.push(cell(x, y, ch, fg, bg));
        if spectrum > 1.18 {
            let spike_x = to_int(clamp(to_float(cx) + cos(angle) * (to_float(rx) + burst + 1.5), 0.0, to_float(input.width - 1)));
            let spike_y = to_int(clamp(to_float(cy) + sin(angle) * (to_float(ry) + (burst + 1.5) * 0.58), 0.0, to_float(input.height - 1)));
            cmds.push(cell(spike_x, spike_y, ".", fg, bg));
        }
        node += 1;
    }

    cmds
}

fn push_meter(cmds, input, bg) {
    if input.height < 5 || input.width < 20 {
        return cmds;
    }
    let y = input.height - 2;
    let w = min(input.width - 4, 48);
    let x = 2;
    let base = rgb(18, 34, 42);
    let fill = palette(input, 0.65 + input.energy * 0.35, 5.2);
    let filled = to_int(clamp(input.energy * to_float(w), 1.0, to_float(w)));
    cmds.push(hline(x, y, w, "-", base, bg));
    cmds.push(rect(x, y, filled, 1, " ", fill, fill));
    let progress = to_int(clamp(input.progress * to_float(w), 0.0, to_float(w)));
    if progress > 0 {
        cmds.push(hline(x, y - 1, progress, ".", fill, bg));
        cmds.push(vline(min(x + progress, x + w - 1), y - 1, 2, "|", fill, bg));
    }
    cmds
}

fn push_labels(cmds, input, bg) {
    let fg = rgb(180 + input.treble * 60, 230, 245);
    let dim = rgb(70, 120 + input.energy * 80, 130 + input.energy * 80);
    if input.show_clock {
        cmds.push(text(1, 0, " " + input.clock + " ", fg, rgb(2, 18, 24)));
    }
    if input.track_title != "" && input.height > 4 {
        cmds.push(text(2, input.height - 1, input.track_title, fg, bg));
    }
    if input.track_artist != "" && input.height > 5 {
        cmds.push(text(2, input.height - 3, input.track_artist, dim, bg));
    }
    if input.paused {
        cmds.push(text(2, 1, "paused", dim, bg));
    }
    cmds
}

fn render(input) {
    let cmds = [];
    let bg = rgb(1, 4, 10);
    cmds.push(#{ op: "clear", bg: bg });

    if input.width <= 8 || input.height <= 6 {
        return cmds;
    }

    cmds = push_starfield(cmds, input, bg);

    let cx = input.width / 2;
    let cy = input.height / 2;
    let max_ry = max((input.height - 6) / 2, 2);
    let max_rx = max(input.width / 3, 4);
    let base = min(to_float(max_ry), to_float(max_rx) / 2.0) * 0.78;
    let activity = clamp(input.energy * 0.72 + input.bass * 0.50 + input.beat * 1.00, 0.0, 1.18);
    let pulse = 0.34
        + activity * 0.58
        + input.volume * 0.04
        + input.beat * 0.18
        + abs(sin(input.time * 2.8 + input.position * 0.07)) * (0.03 + input.energy * 0.07);
    let ry = max(to_int(base * pulse), 2);
    let rx = max(to_int(to_float(ry) * (1.85 + input.treble * 0.28)), 4);

    cmds = push_pulse_ring(cmds, input, cx, cy, rx, ry, bg);
    cmds = push_orbit(cmds, input, cx, cy, rx, ry, bg);
    cmds = push_sphere(cmds, input, cx, cy, rx, ry, bg);
    cmds = push_meter(cmds, input, bg);
    cmds = push_labels(cmds, input, bg);
    cmds
}