//! Your sky (docs/backgrounds.md §5): the dashboard's scene, its layout

//! and its motion, with no browser in it so it is tested natively.

//!

//! Each repository is a cluster placed by a hash of its name, so a

//! viewer's sky is the same on every visit; its events of the last 30 days

//! orbit it as marks, brightest when newest, shaped by kind. The cursor

//! lights marks near it without moving them, and joins the lit marks of

//! one repository in the order they happened.

use std::f32::consts::TAU;

/// The scale of marks and orbits: the sky drawn 40% closer than first

/// built (Andy, 2026-10-13).

const ZOOM: f32 = 1.4;

/// How far the cursor lights marks, in CSS pixels (§4).

pub const LIGHT_RADIUS: f32 = 170.0;

/// Seconds a mark takes to light, and to fade.

const LIT_IN: f32 = 0.15;

const LIT_OUT: f32 = 0.6;

/// The fastest a mark drifts, in CSS pixels a second.

pub const MAX_SPEED: f32 = 12.0;

/// How far each depth layer shifts against the cursor, front to back.

const PARALLAX: [f32; 3] = [6.0, 3.0, 1.0];

/// The longest link: only marks that happened one after another and sit

/// near each other are joined, so a busy repository reads as a

/// constellation, not a scribble.

const LINK_MAX: f32 = 85.0;

/// Links fade when the cursor has rested this long, in seconds.

const LINK_REST: f32 = 2.0;

/// A resting cursor this near a cluster's core names it, after this long.

const LABEL_NEAR: f32 = 110.0;

const LABEL_REST: f32 = 0.4;

/// Events older than this many days are not drawn.

pub const DAYS: f32 = 30.0;

/// The most marks one push makes (one a change), and in all.

const PER_PUSH: u32 = 40;

const MAX_MARKS: usize = 3000;

/// A side margin narrower than this holds no clusters: the sky falls back

/// to a ring around the page.

const MIN_MARGIN: f32 = 180.0;

/// The width a cluster gets in a margin's grid.

const CELL: f32 = 260.0;

/// What a mark stands for, which decides its shape.

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

pub enum Kind {

    Push,

    Proposal,

    Issue,

    Release,

    /// A Flow run.

    Run,

    /// The repository itself, its cluster's core.

    Repo,

}

impl Kind {

    /// The code the page's data uses: 0 a push's change, 1 a proposal

    /// event, 2 an issue event, 3 a release, 4 a Flow run.

    pub fn from_code(code: u32) -> Kind {

        match code {

            1 => Kind::Proposal,

            2 => Kind::Issue,

            3 => Kind::Release,

            4 => Kind::Run,

            _ => Kind::Push,

        }

    }

    /// The shape the fragment shader draws: 0 dot, 1 diamond, 2 ring,

    /// 3 four-point star, 4 thin ring (a repository), 5 square.

    pub fn shape(self) -> f32 {

        match self {

            Kind::Push => 0.0,

            Kind::Proposal => 1.0,

            Kind::Issue => 2.0,

            Kind::Release => 3.0,

            Kind::Repo => 4.0,

            Kind::Run => 5.0,

        }

    }

    /// Its radius in CSS pixels.

    fn size(self) -> f32 {

        match self {

            Kind::Push => 2.0,

            Kind::Run => 2.2,

            Kind::Proposal => 3.2,

            Kind::Issue => 3.0,

            Kind::Release => 4.2,

            Kind::Repo => 6.0,

        }

    }

}

/// One repository, as the page gives it.

#[derive(Clone, Debug)]

pub struct Repo {

    pub name: String,

}

/// One event, as the page gives it: its repository (an index into the

/// repositories), its kind, how old it is, and how many marks it makes (a

/// push's changes; one otherwise).

#[derive(Clone, Copy, Debug)]

pub struct Event {

    pub repo: usize,

    pub kind: Kind,

    pub age_days: f32,

    pub n: u32,

}

/// A repository's place: a fraction of the view, and a depth layer.

#[derive(Clone, Debug)]

pub struct Cluster {

    pub name: String,

    pub fx: f32,

    pub fy: f32,

    pub layer: usize,

}

/// One drawn mark, orbiting its cluster.

#[derive(Clone, Debug)]

pub struct Mark {

    pub cluster: usize,

    pub kind: Kind,

    /// Its place in its cluster's history, 0 the newest; the core is 0

    /// too and has radius 0.

    pub order: u32,

    pub radius: f32,

    pub angle: f32,

    /// Radians a second, signed.

    pub speed: f32,

    /// 1 for today, fading to 0.3 for a month ago.

    pub bright: f32,

    /// How lit it is now, 0 to 1.

    pub lit: f32,

}

/// Straight RGBA, 0 to 1, as the page's tokens give them.

pub type Rgba = [f32; 4];

/// The three backdrop tokens (§3).

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

pub struct Colours {

    pub mark: Rgba,

    pub lit: Rgba,

    pub link: Rgba,

}

/// The scene.

pub struct Sky {

    pub clusters: Vec<Cluster>,

    pub marks: Vec<Mark>,

    /// The view, in CSS pixels.

    pub w: f32,

    pub h: f32,

    /// Where the cursor is, if it is over the page.

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

    /// Seconds since the cursor last moved.

    pub rested: f32,

    /// Still (reduced motion, or the viewer's choice): no drift, no

    /// parallax, and marks light at once.

    pub still: bool,

    /// The page's content column, left and right, in CSS pixels: clusters

    /// go in the margins beside it, where they can be seen.

    avoid: Option<(f32, f32)>,

    parallax: [(f32, f32); 3],

    link_fade: f32,

}

/// FNV-1a, then splitmix64's finaliser: a small, stable hash, so a

/// repository's place never changes. The finaliser spreads every bit:

/// FNV alone gives names that differ only at the end (`repo#1`, `repo#2`)

/// alike high bits, which drew a cluster's marks as fans at a few angles.

pub fn hash(s: &str) -> u64 {

    let mut h: u64 = 0xcbf2_9ce4_8422_2325;

    for b in s.as_bytes() {

        h ^= *b as u64;

        h = h.wrapping_mul(0x0100_0000_01b3);

    }

    h = (h ^ (h >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);

    h = (h ^ (h >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);

    h ^ (h >> 31)

}

/// A number from 0 to 1 from bits of a hash.

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

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

}

impl Sky {

    /// The sky of `repos` and their `events` (newest first, as the page

    /// lists them), in a view of `w` by `h` CSS pixels.

    pub fn new(repos: &[Repo], events: &[Event], w: f32, h: f32, still: bool) -> Sky {

        // The most active repositories in front, the quiet ones behind.

        let mut activity = vec![0u32; repos.len()];

        for e in events {

            if e.repo < repos.len() && e.age_days <= DAYS {

                activity[e.repo] += 1;

            }

        }

        let mut rank: Vec<usize> = (0..repos.len()).collect();

        rank.sort_by_key(|&i| std::cmp::Reverse(activity[i]));

        let mut layer = vec![2usize; repos.len()];

        for (pos, &i) in rank.iter().enumerate() {

            layer[i] = (pos * 3 / repos.len().max(1)).min(2);

        }

        let clusters: Vec<Cluster> =

            repos.iter().enumerate().map(|(i, r)| Cluster { name: r.name.clone(), fx: 0.5, fy: 0.5, layer: layer[i] }).collect();

        let mut marks: Vec<Mark> = Vec::new();

        for i in 0..clusters.len() {

            marks.push(Mark { cluster: i, kind: Kind::Repo, order: 0, radius: 0.0, angle: 0.0, speed: 0.0, bright: 0.9, lit: 0.0 });

        }

        // Each event's marks: a push is a dot for each change it brought.

        let expanded: Vec<Event> = events

            .iter()

            .filter(|e| e.repo < repos.len() && e.age_days <= DAYS)

            .flat_map(|e| std::iter::repeat_n(*e, if e.kind == Kind::Push { e.n.clamp(1, PER_PUSH) as usize } else { 1 }))

            .take(MAX_MARKS)

            .collect();

        // A busy repository gets more lanes, so its marks spread out.

        let mut count = vec![0u32; repos.len()];

        for e in &expanded {

            count[e.repo] += 1;

        }

        let mut seen = vec![0u32; repos.len()];

        for e in &expanded {

            let k = seen[e.repo];

            seen[e.repo] += 1;

            let lanes = (6 + count[e.repo] / 30).min(14);

            let h = hash(&format!("{}#{k}", repos[e.repo].name));

            // Each repository turns one way; its marks keep their lanes, so

            // two clusters' streams cross without touching.

            let dir = if hash(&repos[e.repo].name) & 1 == 0 { 1.0 } else { -1.0 };

            // Lanes close together: each repository a tight knot.

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

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

            marks.push(Mark {

                cluster: e.repo,

                kind: e.kind,

                order: k,

                radius,

                angle: unit(h, 32) * TAU,

                speed,

                bright: 1.0 - 0.7 * (e.age_days / DAYS).clamp(0.0, 1.0),

                lit: 0.0,

            });

        }

        let mut sky =

            Sky { clusters, marks, w, h, cursor: None, rested: 0.0, still, avoid: None, parallax: [(0.0, 0.0); 3], link_fade: 0.0 };

        sky.layout();

        sky

    }

    /// The view is now `w` by `h`, its content column between `avoid`'s

    /// left and right.

    pub fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>) {

        self.w = w;

        self.h = h;

        self.avoid = avoid;

        self.layout();

    }

    /// Place the clusters. In the margins beside the content when both are

    /// wide enough: repositories in the order of their names' hashes, split

    /// between the sides by their widths, each side a staggered grid from

    /// top to bottom, so the sky fills the space the page leaves. Otherwise

    /// a ring around the middle. The same repositories in the same view

    /// always land in the same places.

    fn layout(&mut self) {

        let n = self.clusters.len();

        let mut order: Vec<usize> = (0..n).collect();

        order.sort_by_key(|&i| hash(&self.clusters[i].name));

        let margins = self.avoid.and_then(|(x0, x1)| {

            let (l, r) = (x0.max(0.0), (self.w - x1).max(0.0));

            (l >= MIN_MARGIN && r >= MIN_MARGIN).then_some((l, r, x1))

        });

        match margins {

            Some((l, r, x1)) => {

                let left = (((n as f32) * l / (l + r)).round() as usize).min(n);

                let (a, b) = order.split_at(left);

                self.grid(a, 0.0, l);

                self.grid(b, x1, self.w);

            }

            None => {

                for c in &mut self.clusters {

                    let h = hash(&c.name);

                    let a = unit(h, 0) * TAU;

                    let d = 0.25 + 0.3 * unit(h, 16).sqrt();

                    c.fx = (0.5 + d * a.cos()).clamp(0.03, 0.97);

                    c.fy = (0.5 + 0.9 * d * a.sin()).clamp(0.05, 0.95);

                }

            }

        }

    }

    /// Lay `ids` out in a staggered grid between `x0` and `x1`.

    fn grid(&mut self, ids: &[usize], x0: f32, x1: f32) {

        if ids.is_empty() || self.w <= 0.0 || self.h <= 0.0 {

            return;

        }

        let (top, bottom) = (self.h * 0.1, self.h * 0.97);

        let width = x1 - x0;

        let cols = ((width / CELL) as usize).clamp(1, 3);

        let rows = ids.len().div_ceil(cols);

        let (cw, ch) = (width / cols as f32, (bottom - top) / rows as f32);

        for (j, &i) in ids.iter().enumerate() {

            let (col, row) = (j % cols, j / cols);

            let h = hash(&self.clusters[i].name);

            let stagger = if cols > 1 && row % 2 == 1 { cw * 0.25 } else { 0.0 };

            let cx = x0 + (col as f32 + 0.5) * cw + stagger + (unit(h, 0) - 0.5) * 0.3 * cw;

            let cy = top + (row as f32 + 0.5) * ch + (unit(h, 16) - 0.5) * 0.3 * ch;

            self.clusters[i].fx = cx.clamp(x0 + 24.0, x1 - 24.0) / self.w;

            self.clusters[i].fy = cy / self.h;

        }

    }

    /// The cursor moved to `(x, y)`, or left the page.

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

        self.cursor = at;

        self.rested = 0.0;

    }

    /// Where cluster `c`'s core is now.

    pub fn core(&self, c: usize) -> (f32, f32) {

        let cl = &self.clusters[c];

        let (px, py) = self.parallax[cl.layer];

        (cl.fx * self.w + px, cl.fy * self.h + py)

    }

    /// Where mark `m` is now.

    pub fn position(&self, m: &Mark) -> (f32, f32) {

        let (cx, cy) = self.core(m.cluster);

        (cx + m.angle.cos() * m.radius, cy + m.angle.sin() * m.radius)

    }

    /// Move the scene on by `dt` seconds.

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

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

        self.rested += dt;

        if !self.still {

            for m in &mut self.marks {

                m.angle = (m.angle + m.speed * dt) % TAU;

            }

            let ease = 1.0 - (-dt * 4.0).exp();

            for (l, p) in self.parallax.iter_mut().enumerate() {

                let (tx, ty) = match self.cursor {

                    Some((x, y)) if self.w > 0.0 && self.h > 0.0 => {

                        (-(x - self.w / 2.0) / (self.w / 2.0) * PARALLAX[l], -(y - self.h / 2.0) / (self.h / 2.0) * PARALLAX[l])

                    }

                    _ => (0.0, 0.0),

                };

                p.0 += (tx - p.0) * ease;

                p.1 += (ty - p.1) * ease;

            }

        }

        let lit_targets: Vec<f32> = self

            .marks

            .iter()

            .map(|m| match self.cursor {

                Some((x, y)) => {

                    let (mx, my) = self.position(m);

                    if (mx - x).hypot(my - y) <= LIGHT_RADIUS {

                        1.0

                    } else {

                        0.0

                    }

                }

                None => 0.0,

            })

            .collect();

        for (m, target) in self.marks.iter_mut().zip(lit_targets) {

            m.lit = if self.still {

                target

            } else if target > m.lit {

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

            } else {

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

            };

        }

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

        self.link_fade = if self.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 anything is still changing: a frame is worth drawing.

    pub fn busy(&self) -> bool {

        !self.still || self.marks.iter().any(|m| m.lit > 0.0 && m.lit < 1.0) || (self.link_fade > 0.0 && self.link_fade < 1.0)

    }

    /// One instance per mark: centre x, y and radius in CSS pixels, its

    /// shape, and its colour premultiplied, 8 floats each.

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

        out.clear();

        for m in &self.marks {

            let (x, y) = self.position(m);

            let rest = [c.mark[0], c.mark[1], c.mark[2], c.mark[3] * m.bright];

            let col = mix(rest, c.lit, m.lit);

            let size = m.kind.size() * ZOOM * (1.0 + 0.35 * m.lit);

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

        }

    }

    /// The links among lit marks: each repository's lit marks in the order

    /// they happened, its core to its newest lit mark. Two vertices a

    /// link, x, y and a premultiplied colour each, 6 floats a vertex.

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

        out.clear();

        if self.link_fade <= 0.0 {

            return;

        }

        for ci in 0..self.clusters.len() {

            let mut lit: Vec<&Mark> = self.marks.iter().filter(|m| m.cluster == ci && m.lit > 0.05).collect();

            lit.sort_by_key(|m| (m.kind != Kind::Repo, m.order));

            for pair in lit.windows(2) {

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

                if (a.0 - b.0).hypot(a.1 - b.1) > LINK_MAX {

                    continue;

                }

                let alpha = c.link[3] * pair[0].lit.min(pair[1].lit) * self.link_fade;

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

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

            }

        }

    }

    /// How far a cluster's marks reach from its core.

    fn reach(&self, c: usize) -> f32 {

        self.marks.iter().filter(|m| m.cluster == c).map(|m| m.radius).fold(0.0, f32::max)

    }

    /// The name to show for a resting cursor, and where: centred just

    /// above the nearest cluster within reach, clear of its marks.

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

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

        if self.rested < LABEL_REST {

            return None;

        }

        (0..self.clusters.len())

            .map(|i| (i, self.core(i)))

            .map(|(i, (cx, cy))| (i, cx, cy, (cx - x).hypot(cy - y)))

            .filter(|t| t.3 <= LABEL_NEAR)

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

            .map(|(i, cx, cy, _)| (self.clusters[i].name.as_str(), cx, cy - self.reach(i) - 10.0))