//! The swarm (docs/backgrounds.md §2): Admin › Runners › Images. The hub

//! and the runners as nodes, each ringed by a dot for every image it

//! holds; while a runner fetches an image, chunks (small squares) stream

//! to it from every holder, the hub and its peers alike, as Jetstream's

//! swarm fetches them. The data is the page's own snapshot.

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

use crate::scene::Scene;

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

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

/// Chunks streaming along each holder-to-fetcher path, their speed, and

/// the most streams drawn.

const CHUNKS: usize = 8;

const CHUNK_SPEED: f32 = 40.0;

const MAX_STREAMS: usize = 40;

/// One image: the nodes that hold it and those fetching it now.

pub struct Image {

    pub held: Vec<usize>,

    pub fetching: Vec<usize>,

}

struct Held {

    node: usize,

    radius: f32,

    angle: f32,

    speed: f32,

}

pub struct Swarm {

    field: Field,

    /// The hub first, then the runners.

    names: Vec<String>,

    pos: Vec<(f32, f32)>,

    held: Vec<Held>,

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

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

    w: f32,

    h: f32,

    t: f32,

}

impl Swarm {

    pub fn new(names: Vec<String>, images: Vec<Image>, still: bool) -> Swarm {

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

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

            field.dots.push(Dot::new(0.0, 0.0, if i == 0 { 10.0 } else { 8.0 }, 4.0));

        }

        let mut held = Vec::new();

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

        for (n, img) in images.iter().enumerate() {

            for &node in img.held.iter().filter(|&&n| n < names.len()) {

                let k = count[node];

                count[node] += 1;

                let h = hash(&format!("{}#{n}", names[node]));

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

                held.push(Held {

                    node,

                    radius,

                    angle: unit(h, 16) * TAU,

                    speed: (MAX_SPEED / radius).min(0.2) * (0.5 + 0.5 * unit(h, 32)),

                });

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

                d.group = node as u32;

                d.order = k;

                d.bright = 0.7;

                field.dots.push(d);

            }

        }

        let mut streams = Vec::new();

        'images: for img in &images {

            for &to in img.fetching.iter().filter(|&&n| n < names.len()) {

                for &from in img.held.iter().filter(|&&n| n < names.len() && n != to) {

                    if streams.len() == MAX_STREAMS {

                        break 'images;

                    }

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

                    for _ in 0..CHUNKS {

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

                        d.bright = 0.0;

                        field.dots.push(d);

                    }

                }

            }

        }

        let mut s = Swarm { field, names, pos: Vec::new(), held, streams, w: 0.0, h: 0.0, t: 0.0 };

        s.layout(None);

        s

    }

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

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

        let runners = self.names.len().saturating_sub(1);

        let (hub_x, run_x) = match margins(w, avoid) {

            Some((l, x1)) => (l * 0.5, x1 + (w - x1) * 0.5),

            None => (w * 0.1, w * 0.9),

        };

        self.pos = (0..self.names.len())

            .map(|i| match i {

                0 => (hub_x, h * 0.5),

                _ if runners <= 1 => (run_x, h * 0.5),

                i => (run_x, h * 0.2 + h * 0.6 * (i - 1) as f32 / (runners - 1) as f32),

            })

            .collect();

        self.field.named = self

            .names

            .iter()

            .zip(&self.pos)

            .enumerate()

            .map(|(i, (name, &(x, y)))| {

                let reach = self.held.iter().filter(|h| h.node == i).map(|h| h.radius).fold(12.0, f32::max);

                Named { name: name.clone(), x, y, reach }

            })

            .collect();

    }

    fn place(&mut self) {

        let n = self.names.len();

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

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

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

        }

        for (k, hd) in self.held.iter().enumerate() {

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

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

            self.field.dots[n + k].x = x + a.cos() * hd.radius;

            self.field.dots[n + k].y = y + a.sin() * hd.radius;

        }

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

            // Peers' streams bow one way, the hub's the other, so they

            // read as separate sources.

            let bow = if from == 0 { -0.12 } else { 0.12 };

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

            for k in 0..CHUNKS {

                let s = (k as f32 / CHUNKS as f32 + self.t * CHUNK_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();

            }

        }

    }

}

impl Scene for Swarm {

    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::*;

    #[test]

    fn chunks_stream_to_a_fetching_runner_from_every_holder() {

        let names = vec!["hub".to_string(), "earth-1".to_string(), "plex-1".to_string()];

        let images = vec![Image { held: vec![0, 1], fetching: vec![2] }, Image { held: vec![0, 1, 2], fetching: vec![] }];

        let mut s = Swarm::new(names, images, false);

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

        assert!(s.pos[0].0 < 707.0 && s.pos[1].0 > 1838.0 && s.pos[2].0 > 1838.0, "the hub on one side, runners on the other");

        assert_eq!(s.held.len(), 5, "a dot for every image each node holds");

        assert_eq!(s.streams.iter().map(|&(a, b, _)| (a, b)).collect::<Vec<_>>(), vec![(0, 2), (1, 2)], "from the hub and the peer");

        let first = s.streams[0].2;

        let before = s.field.dots[first].x;

        s.step(0.1);

        assert_ne!(before, s.field.dots[first].x);

        s.point(Some(s.pos[1]));

        for _ in 0..30 {

            s.step(0.02);

        }

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

    }

}