//! Ripples (docs/backgrounds.md §2): a repository's Diffusion tab. The

//! repository in one margin, the upstreams it takes from beside it and the

//! consumers it diffuses to in the other; its changes flow out along arcs

//! to its consumers and its upstreams' flow in, each stream and node in

//! the status of its Diffusion pill, and a ripple widens from the

//! repository every few seconds. The data is the page's own.

use crate::field::{margins, unit, Dot, Field, Named, Tone};

use crate::scene::Scene;

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

use std::f32::consts::{PI, TAU};

/// Dots round each repository, how far out, and how fast they turn.

const RING: usize = 18;

const RING_R: f32 = 30.0;

const RING_SPEED: f32 = 6.0;

/// Dots flowing along each stream, and their speed in CSS pixels a second:

/// a stream is a flow, quicker than the drift of marks.

const FLOW: usize = 10;

const FLOW_SPEED: f32 = 40.0;

/// A ripple every this many seconds, widening this far over this long.

const RIPPLE_EVERY: f32 = 5.0;

const RIPPLE_R: f32 = 280.0;

const RIPPLE_S: f32 = 3.2;

const RIPPLE_DOTS: usize = 40;

/// One repository on the page: its name and the tone its dots take.

pub struct Node {

    pub name: String,

    pub tone: Tone,

}

pub struct Ripples {

    field: Field,

    /// The repository first, then its upstreams, then its consumers.

    nodes: Vec<Node>,

    ups: usize,

    pos: Vec<(f32, f32)>,

    /// Streams: from, to, and their dots' first index.

    streams: Vec<(usize, usize, usize)>,

    ripple_at: usize,

    w: f32,

    h: f32,

    t: f32,

}

impl Ripples {

    pub fn new(repo: String, upstreams: Vec<Node>, consumers: Vec<Node>, still: bool) -> Ripples {

        let ups = upstreams.len();

        let mut nodes = vec![Node { name: repo, tone: Tone::Mark }];

        nodes.extend(upstreams);

        nodes.extend(consumers);

        let mut field = Field::new(still);

        for (i, n) in nodes.iter().enumerate() {

            let mut core = Dot::new(0.0, 0.0, if i == 0 { 9.0 } else { 7.0 }, 4.0);

            core.tone = n.tone;

            field.dots.push(core);

            for k in 0..RING {

                let mut d = Dot::new(0.0, 0.0, 2.2, 0.0);

                d.tone = n.tone;

                d.group = i as u32;

                d.order = k as u32;

                d.bright = 0.6 + 0.4 * unit(hash(&format!("{}#{k}", n.name)), 0);

                field.dots.push(d);

            }

        }

        // Upstreams flow into the repository; the repository flows out to

        // each consumer, the stream in the consumer's tone.

        let mut streams = Vec::new();

        for (i, node) in nodes.iter().enumerate() {

            let (from, to) = match i {

                0 => continue,

                i if i <= ups => (i, 0),

                i => (0, i),

            };

            streams.push((from, to, field.dots.len()));

            for _ in 0..FLOW {

                let mut d = Dot::new(0.0, 0.0, 2.0, 0.0);

                d.tone = node.tone;

                field.dots.push(d);

            }

        }

        let ripple_at = field.dots.len();

        for _ in 0..RIPPLE_DOTS {

            let mut d = Dot::new(0.0, 0.0, 1.8, 0.0);

            d.bright = 0.0;

            field.dots.push(d);

        }

        let mut r = Ripples { field, nodes, ups, pos: Vec::new(), streams, ripple_at, w: 0.0, h: 0.0, t: 0.0 };

        r.layout(None);

        r

    }

    fn layout(&mut self, avoid: Option<(f32, f32)>) {

        let (w, h) = (self.w, self.h);

        let n = self.nodes.len();

        let cons = n - 1 - self.ups;

        let spread = |i: usize, of: usize, top: f32, bottom: f32| {

            if of <= 1 {

                (top + bottom) / 2.0

            } else {

                top + (bottom - top) * i as f32 / (of - 1) as f32

            }

        };

        let (repo_x, up_x, con_x) = match margins(w, avoid) {

            Some((l, x1)) => (l * 0.62, l * 0.22, x1 + (w - x1) * 0.45),

            None => (w * 0.12, w * 0.04, w * 0.88),

        };

        self.pos = (0..n)

            .map(|i| match i {

                0 => (repo_x, h * 0.5),

                i if i <= self.ups => (up_x, spread(i - 1, self.ups, h * 0.25, h * 0.75)),

                i => (con_x, spread(i - 1 - self.ups, cons, h * 0.15, h * 0.85)),

            })

            .collect();

        self.field.named =

            self.nodes.iter().zip(&self.pos).map(|(nd, &(x, y))| Named { name: nd.name.clone(), x, y, reach: RING_R + 6.0 }).collect();

    }

    fn place(&mut self) {

        let mut at = 0;

        let spin = RING_SPEED / RING_R * self.t;

        for (i, &(x, y)) in self.pos.iter().enumerate() {

            self.field.dots[at].x = x;

            self.field.dots[at].y = y;

            at += 1;

            for k in 0..RING {

                let a = k as f32 / RING as f32 * TAU + if i % 2 == 0 { spin } else { -spin };

                self.field.dots[at].x = x + a.cos() * RING_R;

                self.field.dots[at].y = y + a.sin() * RING_R;

                at += 1;

            }

        }

        // Streams: a gentle arc from each source to its destination, its

        // dots evenly spaced and moving along it, faded at the ends.

        for &(from, to, first) in &self.streams {

            let (a, b) = (self.pos[from], self.pos[to]);

            let len = (b.0 - a.0).hypot(b.1 - a.1).max(1.0);

            let ctrl = ((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0 - len * 0.18);

            for k in 0..FLOW {

                let s = (k as f32 / FLOW as f32 + self.t * FLOW_SPEED / len).fract();

                let u = 1.0 - s;

                let d = &mut self.field.dots[first + k];

                d.x = u * u * a.0 + 2.0 * u * s * ctrl.0 + s * s * b.0;

                d.y = u * u * a.1 + 2.0 * u * s * ctrl.1 + s * s * b.1;

                d.bright = (s * PI).sin();

            }

        }

        // The ripple: a ring of dots widening from the repository.

        let p = (self.t % RIPPLE_EVERY) / RIPPLE_S;

        let (x, y) = self.pos[0];

        for k in 0..RIPPLE_DOTS {

            let d = &mut self.field.dots[self.ripple_at + k];

            let a = k as f32 / RIPPLE_DOTS as f32 * TAU;

            let r = RING_R + RIPPLE_R * p.min(1.0);

            d.x = x + a.cos() * r;

            d.y = y + a.sin() * r;

            d.bright = if self.field.still || p >= 1.0 { 0.0 } else { 0.8 * (1.0 - p) };

        }

    }

}

impl Scene for Ripples {

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

        self.w = w;

        self.h = h;

        self.layout(avoid);

        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)> {

        self.field.label()

    }

    fn busy(&self) -> bool {

        !self.field.still || 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::*;

    fn node(name: &str, tone: Tone) -> Node {

        Node { name: name.into(), tone }

    }

    #[test]

    fn upstreams_flow_in_and_consumers_out_in_their_pills_tones() {

        let mut r = Ripples::new(

            "andy/api".into(),

            vec![node("andy/base", Tone::Ok)],

            vec![node("andy/game", Tone::Ok), node("andy/other", Tone::Bad)],

            false,

        );

        r.resize(2560.0, 1270.0, Some((707.0, 1838.0)));

        assert!(r.pos[0].0 < 707.0 && r.pos[1].0 < r.pos[0].0, "the repository and its upstream in the left margin");

        assert!(r.pos[2].0 > 1838.0 && r.pos[3].0 > 1838.0, "its consumers in the right");

        assert_eq!(r.streams, vec![(1, 0, 4 * (RING + 1)), (0, 2, 4 * (RING + 1) + FLOW), (0, 3, 4 * (RING + 1) + 2 * FLOW)]);

        let bad_stream = r.streams[2].2;

        assert!(r.field.dots[bad_stream..bad_stream + FLOW].iter().all(|d| d.tone == Tone::Bad), "a failing consumer's stream is red");

        let before = r.field.dots[bad_stream].x;

        r.step(0.1);

        assert_ne!(before, r.field.dots[bad_stream].x, "streams flow");

        r.point(Some(r.pos[3]));

        for _ in 0..30 {

            r.step(0.02);

        }

        assert_eq!(r.label().map(|l| l.0), Some("andy/other"));

    }

    #[test]

    fn still_keeps_the_ripple_away() {

        let mut r = Ripples::new("andy/api".into(), vec![], vec![node("andy/game", Tone::Mark)], true);

        r.resize(1600.0, 900.0, None);

        r.step(0.1);

        assert!(r.field.dots[r.ripple_at..].iter().all(|d| d.bright == 0.0));

    }

}