//! The mark (docs/backgrounds.md §2): sign in, register and device sign-in.
//! The Oxygen mark's two rings drawn in dots, turning opposite ways so the
//! stream runs through the middle like the mark's infinity, each with its
//! core. Brand only: no data.

use crate::field::{unit, Dot, Field, ZOOM};
use crate::scene::Scene;
use crate::sky::{hash, Colours};
use std::f32::consts::TAU;

/// Dots on the two rings.
const DOTS: usize = 1400;
/// How fast the rings turn, at their rim, in CSS pixels a second.
const RIM_SPEED: f32 = 9.0;

struct Bead {
    ring: usize,
    angle: f32,
    /// Its distance off the ring's line, and its breathing's phase.
    off: f32,
    phase: f32,
}

pub struct Mark {
    field: Field,
    beads: Vec<Bead>,
    w: f32,
    h: f32,
    t: f32,
}

impl Mark {
    pub fn new(still: bool) -> Mark {
        let mut field = Field::new(still);
        let mut beads = Vec::new();
        for i in 0..DOTS {
            let h = hash(&format!("mark#{i}"));
            let ring = i % 2;
            // Off the ring's line by a bell-ish spread, most near it.
            let off = (unit(h, 16) + unit(h, 32) - 1.0) * 18.0;
            beads.push(Bead { ring, angle: unit(h, 0) * TAU, off, phase: unit(h, 48) * TAU });
            let mut d = Dot::new(0.0, 0.0, (1.5 + unit(h, 40) * 1.6) * ZOOM, if i % 11 == 0 { 1.0 } else { 0.0 });
            d.bright = 0.55 + 0.45 * unit(h, 24);
            d.group = ring as u32;
            field.dots.push(d);
        }
        // Join each ring's beads in the order round it.
        for ring in 0..2 {
            let mut idx: Vec<usize> = (0..DOTS).filter(|&i| beads[i].ring == ring).collect();
            idx.sort_by(|&a, &b| beads[a].angle.total_cmp(&beads[b].angle));
            for (k, i) in idx.into_iter().enumerate() {
                field.dots[i].order = k as u32;
            }
        }
        // The two cores.
        for _ in 0..2 {
            field.dots.push(Dot::new(0.0, 0.0, 7.0, 0.0));
        }
        let mut m = Mark { field, beads, w: 0.0, h: 0.0, t: 0.0 };
        m.place();
        m
    }

    /// The rings' radius and centres for this view: large enough to frame
    /// the page, out into its margins, their centres 1.1 radii either side
    /// of the middle, as the mark draws them.
    fn rings(&self) -> (f32, [(f32, f32); 2]) {
        let r = (self.w * 0.2).min(self.h * 0.42).clamp(110.0, 560.0);
        let (cx, cy) = (self.w / 2.0, self.h / 2.0);
        (r, [(cx - r * 1.1, cy), (cx + r * 1.1, cy)])
    }

    fn place(&mut self) {
        let (r, centres) = self.rings();
        let spin = RIM_SPEED / r * self.t;
        for (i, b) in self.beads.iter().enumerate() {
            // The left ring turns one way and the right the other.
            let a = b.angle + if b.ring == 0 { spin } else { -spin };
            let rr = r + b.off + 3.0 * (self.t * 0.4 + b.phase).sin();
            let (cx, cy) = centres[b.ring];
            self.field.dots[i].x = cx + a.cos() * rr;
            self.field.dots[i].y = cy + a.sin() * rr;
        }
        for (k, (cx, cy)) in centres.iter().enumerate() {
            let d = &mut self.field.dots[DOTS + k];
            d.x = *cx;
            d.y = *cy;
        }
    }
}

impl Scene for Mark {
    fn resize(&mut self, w: f32, h: f32, _avoid: Option<(f32, f32)>) {
        self.w = w;
        self.h = h;
        self.place();
    }
    fn point(&mut self, at: Option<(f32, f32)>) {
        self.field.point(at);
    }
    fn step(&mut self, dt: f32) {
        if !self.field.still {
            self.t += dt.clamp(0.0, 0.1);
        }
        self.place();
        self.field.light(dt);
    }
    fn instances(&self, c: &Colours, out: &mut Vec<f32>) {
        self.field.instances(c, out)
    }
    fn links(&self, c: &Colours, out: &mut Vec<f32>) {
        self.field.links(c, out)
    }
    fn label(&self) -> Option<(&str, f32, f32)> {
        None
    }
    fn busy(&self) -> bool {
        self.field.easing()
    }
    fn still(&self) -> bool {
        self.field.still
    }
    fn size(&self) -> (f32, f32) {
        (self.w, self.h)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn two_rings_turn_opposite_ways_about_their_cores() {
        let mut m = Mark::new(false);
        m.resize(1600.0, 900.0, None);
        let (r, centres) = m.rings();
        assert!(centres[0].0 < 800.0 && centres[1].0 > 800.0);
        for (i, b) in m.beads.iter().enumerate() {
            let (cx, cy) = centres[b.ring];
            let d = (m.field.dots[i].x - cx).hypot(m.field.dots[i].y - cy);
            assert!((d - r).abs() <= 22.0, "on its ring: {d} against {r}");
        }
        let before = (m.field.dots[0].x, m.field.dots[0].y);
        m.step(0.1);
        let moved = (m.field.dots[0].x - before.0).hypot(m.field.dots[0].y - before.1);
        assert!(moved > 0.0 && moved < 2.0, "slow: {moved} px in a tenth of a second");
        assert!(m.label().is_none(), "brand only: nothing to name");
    }
}