//! What every scene but the sky shares (docs/backgrounds.md §4): a field

//! of dots that its scene places each frame, lit by the cursor without

//! being moved, joined within a group in order, and named things that a

//! resting cursor names. Dots of a scene with a status (Diffusion's pills)

//! take the page's status colours; every other dot the backdrop tokens.

use crate::sky::{Colours, Rgba};

/// How far the cursor lights dots, in CSS pixels, as in the sky.

pub const LIGHT_RADIUS: f32 = 170.0;

const LIT_IN: f32 = 0.15;

const LIT_OUT: f32 = 0.6;

/// The longest link drawn between two dots of a group.

const LINK_MAX: f32 = 85.0;

const LINK_REST: f32 = 2.0;

const LABEL_NEAR: f32 = 110.0;

const LABEL_REST: f32 = 0.4;

/// A dot's colour: the backdrop's own, or a status where the data has one.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Tone {

    Mark,

    Ok,

    Warn,

    Bad,

}

impl Tone {

    /// A Diffusion pill half's tone as the page names it.

    pub fn from_name(s: &str) -> Tone {

        match s {

            "green" => Tone::Ok,

            "amber" => Tone::Warn,

            "red" => Tone::Bad,

            _ => Tone::Mark,

        }

    }

}

/// One drawn dot.

#[derive(Clone, Copy, Debug)]

pub struct Dot {

    pub x: f32,

    pub y: f32,

    /// Radius in CSS pixels.

    pub size: f32,

    /// The shader's shape (sky::Kind::shape).

    pub shape: f32,

    pub tone: Tone,

    /// 0 to 1: how strongly it shows at rest.

    pub bright: f32,

    pub lit: f32,

    /// Dots of one group are joined in `order` when lit; `NONE` never.

    pub group: u32,

    pub order: u32,

}

impl Dot {

    pub const NONE: u32 = u32::MAX;

    pub fn new(x: f32, y: f32, size: f32, shape: f32) -> Dot {

        Dot { x, y, size, shape, tone: Tone::Mark, bright: 1.0, lit: 0.0, group: Dot::NONE, order: 0 }

    }

}

/// Something with a name the cursor can rest by.

#[derive(Clone, Debug)]

pub struct Named {

    pub name: String,

    pub x: f32,

    pub y: f32,

    /// How far its dots reach: the label sits just above.

    pub reach: f32,

}

pub struct Field {

    pub dots: Vec<Dot>,

    pub named: Vec<Named>,

    pub cursor: Option<(f32, f32)>,

    pub rested: f32,

    pub still: bool,

    link_fade: f32,

}

impl Field {

    pub fn new(still: bool) -> Field {

        Field { dots: Vec::new(), named: Vec::new(), cursor: None, rested: 0.0, still, link_fade: 0.0 }

    }

    pub fn point(&mut self, at: Option<(f32, f32)>) {

        self.cursor = at;

        self.rested = 0.0;

    }

    /// Light the dots near the cursor, after the scene has placed them.

    pub fn light(&mut self, dt: f32) {

        let dt = dt.clamp(0.0, 0.1);

        self.rested += dt;

        let cursor = self.cursor;

        let still = self.still;

        for d in &mut self.dots {

            let target = match cursor {

                Some((x, y)) if (d.x - x).hypot(d.y - y) <= LIGHT_RADIUS => 1.0,

                _ => 0.0,

            };

            d.lit = if still {

                target

            } else if target > d.lit {

                (d.lit + dt / LIT_IN).min(target)

            } else {

                (d.lit - dt / LIT_OUT).max(target)

            };

        }

        let fade_to = if cursor.is_some() && self.rested < LINK_REST { 1.0 } else { 0.0 };

        self.link_fade = if still {

            fade_to

        } else if fade_to > self.link_fade {

            (self.link_fade + dt / LIT_IN).min(1.0)

        } else {

            (self.link_fade - dt / LIT_OUT).max(0.0)

        };

    }

    /// Whether lighting or links are still easing.

    pub fn easing(&self) -> bool {

        self.dots.iter().any(|d| d.lit > 0.0 && d.lit < 1.0) || (self.link_fade > 0.0 && self.link_fade < 1.0)

    }

    fn colour(c: &Colours, tone: Tone, bright: f32, lit: f32) -> Rgba {

        let (rest, hot) = match tone {

            Tone::Mark => (c.mark, c.lit),

            Tone::Ok => (with_alpha(c.ok, 0.45), with_alpha(c.ok, 0.95)),

            Tone::Warn => (with_alpha(c.warn, 0.45), with_alpha(c.warn, 0.95)),

            Tone::Bad => (with_alpha(c.bad, 0.45), with_alpha(c.bad, 0.95)),

        };

        let rest = [rest[0], rest[1], rest[2], rest[3] * bright];

        let t = lit.clamp(0.0, 1.0);

        [

            rest[0] + (hot[0] - rest[0]) * t,

            rest[1] + (hot[1] - rest[1]) * t,

            rest[2] + (hot[2] - rest[2]) * t,

            rest[3] + (hot[3] - rest[3]) * t,

        ]

    }

    /// 8 floats a dot, as sky::Sky::instances lays them out.

    pub fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        out.clear();

        for d in &self.dots {

            let col = Field::colour(c, d.tone, d.bright, d.lit);

            let size = d.size * (1.0 + 0.35 * d.lit);

            out.extend_from_slice(&[d.x, d.y, size, d.shape, col[0] * col[3], col[1] * col[3], col[2] * col[3], col[3]]);

        }

    }

    /// Lit dots of a group joined in order, where near each other.

    pub fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        out.clear();

        if self.link_fade <= 0.0 {

            return;

        }

        let mut lit: Vec<&Dot> = self.dots.iter().filter(|d| d.group != Dot::NONE && d.lit > 0.05).collect();

        lit.sort_by_key(|d| (d.group, d.order));

        for pair in lit.windows(2) {

            let (a, b) = (pair[0], pair[1]);

            if a.group != b.group || (a.x - b.x).hypot(a.y - b.y) > LINK_MAX {

                continue;

            }

            let alpha = c.link[3] * a.lit.min(b.lit) * self.link_fade;

            let col = [c.link[0] * alpha, c.link[1] * alpha, c.link[2] * alpha, alpha];

            out.extend_from_slice(&[a.x, a.y, col[0], col[1], col[2], col[3], b.x, b.y, col[0], col[1], col[2], col[3]]);

        }

    }

    /// The name above the named thing a resting cursor is by.

    pub fn label(&self) -> Option<(&str, f32, f32)> {

        let (x, y) = self.cursor?;

        if self.rested < LABEL_REST {

            return None;

        }

        self.named

            .iter()

            .map(|n| (n, (n.x - x).hypot(n.y - y)))

            .filter(|(n, d)| *d <= LABEL_NEAR.max(n.reach))

            .min_by(|a, b| a.1.total_cmp(&b.1))

            .map(|(n, _)| (n.name.as_str(), n.x, n.y - n.reach - 10.0))

    }

}

fn with_alpha(c: Rgba, a: f32) -> Rgba {

    [c[0], c[1], c[2], a]

}

/// A number from 0 to 1 from bits of a hash (sky::hash).

pub fn unit(h: u64, shift: u32) -> f32 {

    ((h >> shift) & 0xffff) as f32 / 65536.0

}

/// One dot of a knot: its orbit about the knot's centre.

#[derive(Clone, Copy, Debug)]

pub struct Orbit {

    pub radius: f32,

    pub angle: f32,

    /// Radians a second, signed.

    pub speed: f32,

}

impl Orbit {

    pub fn at(&self, centre: (f32, f32), t: f32) -> (f32, f32) {

        let a = self.angle + self.speed * t;

        (centre.0 + a.cos() * self.radius, centre.1 + a.sin() * self.radius)

    }

}

/// `n` dots as a knot like a sky's cluster (sky::Sky, Andy's 2026-10-13

/// tuning): close lanes, more of them the busier, drawn 1.4 times larger,

/// turning one way at the sky's slow speed. `seed` makes it stable.

pub fn knot(seed: &str, n: usize) -> Vec<Orbit> {

    let lanes = (6 + n / 30).min(14) as u32;

    let dir = if crate::sky::hash(seed) & 1 == 0 { 1.0 } else { -1.0 };

    (0..n as u32)

        .map(|k| {

            let h = crate::sky::hash(&format!("{seed}#{k}"));

            let radius = (16.0 + (k % lanes) as f32 * 6.5 + unit(h, 0) * 4.0) * 1.4;

            let speed = dir * (crate::sky::MAX_SPEED / radius).min(0.25) * (0.5 + 0.5 * unit(h, 16));

            Orbit { radius, angle: unit(h, 32) * std::f32::consts::TAU, speed }

        })

        .collect()

}

/// A dot's size drawn as the sky draws its marks (1.4 times larger).

pub const ZOOM: f32 = 1.4;

/// The page's margins beside its content column, when both are wide

/// enough to hold something: (left width, right start).

pub fn margins(w: f32, avoid: Option<(f32, f32)>) -> Option<(f32, f32)> {

    let (x0, x1) = avoid?;

    (x0 >= 180.0 && w - x1 >= 180.0).then_some((x0, x1))

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn the_cursor_lights_and_joins_a_group_and_names_what_it_rests_by() {

        let mut f = Field::new(false);

        for i in 0..4 {

            let mut d = Dot::new(100.0 + i as f32 * 20.0, 100.0, 3.0, 0.0);

            d.group = 0;

            d.order = i;

            f.dots.push(d);

        }

        f.dots.push(Dot::new(900.0, 900.0, 3.0, 0.0));

        f.named.push(Named { name: "earth-1".into(), x: 130.0, y: 100.0, reach: 40.0 });

        f.point(Some((130.0, 100.0)));

        for _ in 0..30 {

            f.light(1.0 / 60.0);

        }

        assert!(f.dots[..4].iter().all(|d| d.lit == 1.0) && f.dots[4].lit == 0.0);

        let c = Colours::default();

        let mut links = Vec::new();

        f.links(&c, &mut links);

        assert_eq!(links.len(), 3 * 12, "three links in order, none to the dot far away");

        assert_eq!(f.label().map(|l| l.0), Some("earth-1"));

        let mut inst = Vec::new();

        f.instances(&c, &mut inst);

        assert_eq!(inst.len(), 5 * 8);

    }

    #[test]

    fn status_tones_come_from_the_pill_names() {

        assert_eq!(Tone::from_name("green"), Tone::Ok);

        assert_eq!(Tone::from_name("amber"), Tone::Warn);

        assert_eq!(Tone::from_name("red"), Tone::Bad);

        assert_eq!(Tone::from_name("grey"), Tone::Mark);

        assert_eq!(margins(2560.0, Some((707.0, 1838.0))), Some((707.0, 1838.0)));

        assert_eq!(margins(1200.0, Some((100.0, 1100.0))), None);

    }

}