//! The website's living backgrounds on the phone (E1): the hub's own

//! scenes (backdrop/, copied by scripts/sync-backdrop.sh) stepped here, and

//! drawn by the app from the floats each frame gives (ui/backdrop), as the

//! hub's WebGL draws them in a browser.

use crate::backdrop::adrift::Adrift;

use crate::backdrop::mark::Mark;

use crate::backdrop::scene::Scene;

use crate::backdrop::sky::{Colours, Event, Kind, Repo, Sky};

use std::sync::Mutex;

/// One event of the viewer's own activity, for Your sky: an index into the

/// repositories, its kind (0 a push's change, 1 a proposal event, 2 an

/// issue event, 3 a release, 4 a Flow run), how old it is and how many

/// marks it makes.

#[derive(uniffi::Record)]

pub struct SkyEvent {

    pub repo: u32,

    pub kind: u32,

    pub age_days: f32,

    pub n: u32,

}

/// A frame to draw: marks, 8 floats each (x, y, size, shape, then a

/// premultiplied colour), and links, 12 floats each (two ends, each x, y

/// and a premultiplied colour), as little-endian bytes: a byte array

/// crosses to Kotlin as one copy, where a list of floats would be boxed.

#[derive(uniffi::Record)]

pub struct BackdropFrame {

    pub marks: Vec<u8>,

    pub links: Vec<u8>,

}

fn bytes(v: &[f32]) -> Vec<u8> {

    v.iter().flat_map(|f| f.to_le_bytes()).collect()

}

/// The name a resting finger shows, and where.

#[derive(uniffi::Record)]

pub struct BackdropLabel {

    pub text: String,

    pub x: f32,

    pub y: f32,

}

/// A scene and the colours it is drawn in.

#[derive(uniffi::Object)]

pub struct Backdrop {

    scene: Mutex<Box<dyn Scene + Send>>,

    colours: Mutex<Colours>,

}

fn rgba(c: &[f32], i: usize) -> [f32; 4] {

    [c[i * 4], c[i * 4 + 1], c[i * 4 + 2], c[i * 4 + 3]]

}

impl Backdrop {

    fn of(scene: Box<dyn Scene + Send>) -> std::sync::Arc<Backdrop> {

        let grey = [0.5, 0.55, 0.65, 0.5];

        let colours = Colours { mark: grey, lit: grey, link: grey, ok: grey, warn: grey, bad: grey };

        std::sync::Arc::new(Backdrop { scene: Mutex::new(scene), colours: Mutex::new(colours) })

    }

}

#[uniffi::export]

impl Backdrop {

    /// The OxygenHub mark, as behind the hub's sign-in page.

    #[uniffi::constructor]

    pub fn mark(still: bool) -> std::sync::Arc<Backdrop> {

        Backdrop::of(Box::new(Mark::new(still)))

    }

    /// The quiet field behind the hub's error pages, for an empty screen.

    #[uniffi::constructor]

    pub fn adrift(still: bool) -> std::sync::Arc<Backdrop> {

        Backdrop::of(Box::new(Adrift::new(still)))

    }

    /// Your sky, as on the hub's dashboard: the viewer's own repositories

    /// and their activity, nothing inferred.

    #[uniffi::constructor]

    pub fn sky(repos: Vec<String>, events: Vec<SkyEvent>, w: f32, h: f32, still: bool) -> std::sync::Arc<Backdrop> {

        let repos: Vec<Repo> = repos.into_iter().map(|name| Repo { name }).collect();

        let events: Vec<Event> = events

            .into_iter()

            .filter(|e| (e.repo as usize) < repos.len())

            .map(|e| Event { repo: e.repo as usize, kind: Kind::from_code(e.kind), age_days: e.age_days, n: e.n.max(1) })

            .collect();

        Backdrop::of(Box::new(Sky::new(&repos, &events, w, h, still)))

    }

    /// The colours to draw in, from the app's theme: mark, lit, link, ok,

    /// warn and bad, 4 floats each (red, green, blue, alpha, 0 to 1).

    pub fn colours(&self, rgba_x6: Vec<f32>) {

        if rgba_x6.len() < 24 {

            return;

        }

        let c = &rgba_x6;

        *self.colours.lock().unwrap() =

            Colours { mark: rgba(c, 0), lit: rgba(c, 1), link: rgba(c, 2), ok: rgba(c, 3), warn: rgba(c, 4), bad: rgba(c, 5) };

    }

    /// The view is now `w` by `h` (density-independent pixels).

    pub fn resize(&self, w: f32, h: f32) {

        self.scene.lock().unwrap().resize(w, h, None);

    }

    /// A finger at `(x, y)`, or lifted.

    pub fn point(&self, x: f32, y: f32, down: bool) {

        self.scene.lock().unwrap().point(down.then_some((x, y)));

    }

    /// Move on by `dt` seconds; whether anything but the drift is moving.

    pub fn step(&self, dt: f32) -> bool {

        let mut s = self.scene.lock().unwrap();

        s.step(dt.clamp(0.0, 0.1));

        s.busy()

    }

    /// What to draw now.

    pub fn frame(&self) -> BackdropFrame {

        let (s, c) = (self.scene.lock().unwrap(), self.colours.lock().unwrap());

        let (mut marks, mut links) = (Vec::new(), Vec::new());

        s.instances(&c, &mut marks);

        s.links(&c, &mut links);

        BackdropFrame { marks: bytes(&marks), links: bytes(&links) }

    }

    /// The name a resting finger shows, if any.

    pub fn label(&self) -> Option<BackdropLabel> {

        self.scene.lock().unwrap().label().map(|(t, x, y)| BackdropLabel { text: t.to_string(), x, y })

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn a_sky_of_real_repositories_draws_marks_and_moves() {

        let b = Backdrop::sky(

            vec!["andy/oxygen".into(), "andy/hub".into()],

            vec![SkyEvent { repo: 0, kind: 0, age_days: 1.0, n: 5 }, SkyEvent { repo: 1, kind: 4, age_days: 2.0, n: 1 }, SkyEvent { repo: 9, kind: 0, age_days: 1.0, n: 1 }],

            400.0,

            800.0,

            false,

        );

        b.colours(vec![0.6; 24]);

        b.step(0.016);

        let f = b.frame();

        assert!(!f.marks.is_empty() && f.marks.len() % 32 == 0, "{} bytes", f.marks.len());

        assert_eq!(f.links.len() % 48, 0);

        let first = f.marks.clone();

        for _ in 0..30 {

            b.step(0.033);

        }

        assert_ne!(b.frame().marks, first, "it drifts");

    }

    #[test]

    fn the_mark_and_the_field_draw_too() {

        for b in [Backdrop::mark(false), Backdrop::adrift(true)] {

            b.resize(360.0, 640.0);

            b.step(0.016);

            assert!(!b.frame().marks.is_empty());

        }

    }

}