//! 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;

/// An arrival's ring (§4): seconds it lasts, and its radius from first to

/// last, in CSS pixels before the zoom.

const RING_S: f32 = 1.2;

const RING_FROM: f32 = 6.0;

const RING_TO: f32 = 46.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), and the page's status colours for the

/// scenes whose data has a status (Diffusion's pills).

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

pub struct Colours {

    pub mark: Rgba,

    pub lit: Rgba,

    pub link: Rgba,

    pub ok: Rgba,

    pub warn: Rgba,

    pub bad: Rgba,

}

/// A widening ring at a cluster's core: something just arrived there.

#[derive(Clone, Copy, Debug)]

pub struct Ring {

    pub cluster: usize,

    /// Seconds since it began.

    pub age: f32,

}

/// 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,

    /// Arrivals' rings, while they widen.

    pub rings: Vec<Ring>,

    /// Marks added since the page loaded, for their places in the lanes.

    arrived: u32,

}

/// 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,

            rings: Vec::new(),

            arrived: 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))

        });

        // One repository's own sky (oxygenhub#196): its cluster sits in the

        // wider margin, a little below the middle, even a narrow one, so

        // it never lands on the page's heading or tabs.

        if n == 1 {

            if let Some((x0, x1)) = self.avoid {

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

                if l.max(r) >= 40.0 && self.w > 0.0 {

                    let cx = if r >= l { x1 + r / 2.0 } else { l / 2.0 };

                    self.clusters[0].fx = cx / self.w;

                    self.clusters[0].fy = 0.6;

                    return;

                }

            }

        }

        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;

    }

    /// New activity in the repository `name` (§5, "Live"): its marks join

    /// its cluster as the newest, and one ring widens from its core. A

    /// repository the sky does not draw is ignored; a still sky adds the

    /// marks without the ring.

    pub fn arrive(&mut self, name: &str, kind: Kind, n: u32) {

        let Some(c) = self.clusters.iter().position(|cl| cl.name == name) else {

            return;

        };

        let add = if kind == Kind::Push { n.clamp(1, PER_PUSH) } else { 1 };

        for m in self.marks.iter_mut().filter(|m| m.cluster == c && m.kind != Kind::Repo) {

            m.order += add;

        }

        let have = self.marks.iter().filter(|m| m.cluster == c && m.kind != Kind::Repo).count() as u32;

        let lanes = (6 + (have + add) / 30).min(14);

        let dir = if hash(name) & 1 == 0 { 1.0 } else { -1.0 };

        for i in 0..add {

            let h = hash(&format!("{name}+{}", self.arrived));

            self.arrived += 1;

            let radius = (16.0 + ((have + i) % 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));

            self.marks.push(Mark { cluster: c, kind, order: add - 1 - i, radius, angle: unit(h, 32) * TAU, speed, bright: 1.0, lit: 0.0 });

        }

        // Over the limit, the cluster's oldest marks make room.

        while self.marks.len() > MAX_MARKS {

            let Some(oldest) = self

                .marks

                .iter()

                .enumerate()

                .filter(|(_, m)| m.cluster == c && m.kind != Kind::Repo)

                .max_by_key(|(_, m)| m.order)

                .map(|(i, _)| i)

            else {

                break;

            };

            self.marks.swap_remove(oldest);

        }

        if !self.still {

            self.rings.retain(|r| r.cluster != c);

            self.rings.push(Ring { cluster: c, age: 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;

        for r in &mut self.rings {

            r.age += dt;

        }

        self.rings.retain(|r| r.age < RING_S);

        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 besides the drift is still changing: lighting,

    /// links or a ring. The engine keeps drawing a moving sky for a while

    /// after the last input anyway (§6), then stops until something is.

    pub fn busy(&self) -> bool {