//! Backdrops (docs/backgrounds.md): the quiet, moving pictures behind
//! some of OxygenHub's pages, in Rust compiled to WebAssembly and drawn
//! with WebGL2. `sky` is the scene and its motion, with no browser in it;
//! `gl` draws it; this module is the browser around them: the frame loop,
//! the cursor, the window's size, the page's colours and when to stop.

pub mod adrift;
pub mod field;
pub mod gl;
pub mod mark;
pub mod ripples;
pub mod scene;
pub mod sky;
pub mod swarm;

use scene::Scene;
use sky::{Colours, Event, Kind, Repo, Sky};
use std::cell::RefCell;
use std::rc::Rc;
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
use web_sys::{HtmlCanvasElement, HtmlElement, WebGl2RenderingContext, Window};

/// The highest device pixel ratio drawn at: sharp enough, and cheap.
const MAX_DPR: f64 = 1.5;
/// After this long without input a moving backdrop draws its last frame
/// and stops until the next movement (§6).
const STOP_AFTER_S: f64 = 120.0;
/// A still cursor drops the frame rate to half after this long.
const HALF_RATE_AFTER_S: f64 = 3.0;

struct Engine {
    window: Window,
    canvas: HtmlCanvasElement,
    renderer: gl::Renderer,
    scene: Box<dyn Scene>,
    colours: Colours,
    colours_at: f64,
    probe: HtmlElement,
    label: HtmlElement,
    label_text: String,
    inst: Vec<f32>,
    lines: Vec<f32>,
    last: Option<f64>,
    frame: u64,
    running: bool,
    input_at: f64,
    pw: i32,
    ph: i32,
}

type Frame = Rc<RefCell<Option<Closure<dyn FnMut(f64)>>>>;

thread_local! {
    /// The running backdrop, for `arrive`.
    static RUNNING: RefCell<Option<(Rc<RefCell<Engine>>, Frame)>> = const { RefCell::new(None) };
}

impl Engine {
    fn now(&self) -> f64 {
        self.window.performance().map(|p| p.now()).unwrap_or(0.0)
    }

    /// Fit the canvas to the window.
    fn fit(&mut self) {
        let w = self.window.inner_width().ok().and_then(|v| v.as_f64()).unwrap_or(0.0);
        let h = self.window.inner_height().ok().and_then(|v| v.as_f64()).unwrap_or(0.0);
        let dpr = self.window.device_pixel_ratio().clamp(1.0, MAX_DPR);
        self.pw = (w * dpr).round() as i32;
        self.ph = (h * dpr).round() as i32;
        self.canvas.set_width(self.pw.max(1) as u32);
        self.canvas.set_height(self.ph.max(1) as u32);
        // The content column, which the page marks: clusters go beside it.
        let avoid = self
            .window
            .document()
            .and_then(|d| d.query_selector("[data-backdrop-avoid]").ok().flatten())
            .map(|el| el.get_bounding_client_rect())
            .map(|r| (r.left() as f32, r.right() as f32));
        self.scene.resize(w as f32, h as f32, avoid);
    }

    /// The page's backdrop tokens, as the browser computes them, so a
    /// theme switch shows within a second.
    fn read_colours(&mut self) {
        let read = |token: &str, fallback: sky::Rgba| -> sky::Rgba {
            let _ = self.probe.style().set_property("color", &format!("var({token})"));
            self.window
                .get_computed_style(&self.probe)
                .ok()
                .flatten()
                .and_then(|s| s.get_property_value("color").ok())
                .and_then(|c| sky::parse_colour(&c))
                .unwrap_or(fallback)
        };
        self.colours = Colours {
            mark: read("--bd-mark", [0.5, 0.5, 0.55, 0.16]),
            lit: read("--bd-lit", [0.04, 0.41, 0.85, 0.7]),
            link: read("--bd-link", [0.04, 0.41, 0.85, 0.22]),
            ok: read("--ok", [0.1, 0.5, 0.22, 1.0]),
            warn: read("--warn", [0.6, 0.4, 0.0, 1.0]),
            bad: read("--bad", [0.82, 0.14, 0.18, 1.0]),
        };
    }

    /// One animation frame at time `t`; whether another is wanted.
    fn tick(&mut self, t: f64) -> bool {
        if self.window.document().is_some_and(|d| d.hidden()) {
            self.last = None;
            return false;
        }
        let idle = (t - self.input_at) / 1000.0;
        self.frame += 1;
        if !self.scene.still() && idle > HALF_RATE_AFTER_S && self.frame % 2 == 1 {
            return true;
        }
        let dt = self.last.map(|l| ((t - l) / 1000.0) as f32).unwrap_or(0.0);
        self.last = Some(t);
        if t - self.colours_at > 1000.0 {
            self.read_colours();
            self.colours_at = t;
        }
        self.scene.step(dt);
        self.scene.instances(&self.colours, &mut self.inst);
        self.scene.links(&self.colours, &mut self.lines);
        let (w, h) = self.scene.size();
        self.renderer.draw(w, h, self.pw, self.ph, &self.inst, &self.lines);
        self.show_label();
        if self.scene.still() {
            self.scene.busy()
        } else {
            idle < STOP_AFTER_S || self.scene.busy()
        }
    }

    /// The name above the cluster a cursor rests by (§4): faded in and out
    /// by CSS, which centres it on `left` and sets its foot on `top`.
    fn show_label(&mut self) {
        let next = self.scene.label().map(|(name, x, y)| (name.to_string(), x, y));
        let style = self.label.style();
        match next {
            Some((name, x, y)) => {
                if name != self.label_text {
                    self.label.set_text_content(Some(&name));
                    self.label_text = name;
                }
                let _ = style.set_property("left", &format!("{}px", x as i32));
                let _ = style.set_property("top", &format!("{}px", y as i32));
                let _ = style.set_property("opacity", "1");
            }
            None => {
                let _ = style.set_property("opacity", "0");
            }
        }
    }
}

/// Ask for a frame unless the loop is already running.
fn wake(engine: &Rc<RefCell<Engine>>, frame: &Frame) {
    let mut e = engine.borrow_mut();
    if e.running {
        return;
    }
    e.running = true;
    if let Some(f) = frame.borrow().as_ref() {
        let _ = e.window.request_animation_frame(f.as_ref().unchecked_ref());
    }
}

fn get(v: &JsValue, key: &str) -> JsValue {
    js_sys::Reflect::get(v, &JsValue::from_str(key)).unwrap_or(JsValue::UNDEFINED)
}

/// The page's data (§5): `{now, repos: [name], events: [[repo, kind, at_ms, n]]}`.
fn read_data(data: &JsValue) -> (Vec<Repo>, Vec<Event>) {
    let now = get(data, "now").as_f64().unwrap_or(0.0);
    let repos: Vec<Repo> =
        js_sys::Array::from(&get(data, "repos")).iter().filter_map(|v| v.as_string()).map(|name| Repo { name }).collect();
    let events: Vec<Event> = js_sys::Array::from(&get(data, "events"))
        .iter()
        .filter_map(|v| {
            let e = js_sys::Array::from(&v);
            let repo = e.get(0).as_f64()? as usize;
            let kind = Kind::from_code(e.get(1).as_f64()? as u32);
            let at = e.get(2).as_f64()?;
            let n = e.get(3).as_f64().unwrap_or(1.0).max(1.0) as u32;
            Some(Event { repo, kind, age_days: ((now - at) / 86_400_000.0).max(0.0) as f32, n })
        })
        .collect();
    (repos, events)
}

fn strings(v: &JsValue) -> Vec<String> {
    js_sys::Array::from(v).iter().filter_map(|x| x.as_string()).collect()
}

/// A Diffusion node, `[name, tone]`.
fn ripple_nodes(v: &JsValue) -> Vec<ripples::Node> {
    js_sys::Array::from(v)
        .iter()
        .filter_map(|n| {
            let n = js_sys::Array::from(&n);
            Some(ripples::Node { name: n.get(0).as_string()?, tone: field::Tone::from_name(&n.get(1).as_string().unwrap_or_default()) })
        })
        .collect()
}

/// New activity, as the page polled it (§5, "Live"): `{events: [[repo
/// name, kind, at_ms, n]]}`. Each joins its cluster with an arrival ring;
/// a scene other than the sky ignores it.
#[wasm_bindgen]
pub fn arrive(data: JsValue) {
    let Some((engine, frame)) = RUNNING.with(|r| r.borrow().clone()) else {
        return;
    };
    let mut any = false;
    // Oldest first, so the newest ends up newest.
    for v in js_sys::Array::from(&get(&data, "events")).iter().rev() {
        let e = js_sys::Array::from(&v);
        let (Some(repo), Some(kind)) = (e.get(0).as_string(), e.get(1).as_f64()) else {
            continue;
        };
        let n = e.get(3).as_f64().unwrap_or(1.0).max(1.0) as u32;
        engine.borrow_mut().scene.arrive(&repo, Kind::from_code(kind as u32), n);
        any = true;
    }
    if any {
        wake(&engine, &frame);
    }
}

/// The scene the page's data names (`scene`), the sky when it names none.
fn read_scene(data: &JsValue, still: bool) -> Box<dyn Scene> {
    match get(data, "scene").as_string().as_deref() {
        Some("mark") => Box::new(mark::Mark::new(still)),
        Some("adrift") => Box::new(adrift::Adrift::new(still)),
        Some("ripples") => Box::new(ripples::Ripples::new(
            get(data, "repo").as_string().unwrap_or_default(),
            ripple_nodes(&get(data, "upstreams")),
            ripple_nodes(&get(data, "consumers")),
            still,
        )),
        Some("swarm") => {
            let images = js_sys::Array::from(&get(data, "images"))
                .iter()
                .map(|img| {
                    let idx =
                        |key: &str| js_sys::Array::from(&get(&img, key)).iter().filter_map(|v| v.as_f64()).map(|v| v as usize).collect();
                    swarm::Image { held: idx("held"), fetching: idx("fetching") }
                })
                .collect();
            Box::new(swarm::Swarm::new(strings(&get(data, "nodes")), images, still))
        }
        _ => {
            let (repos, events) = read_data(data);
            Box::new(Sky::new(&repos, &events, 0.0, 0.0, still))
        }
    }
}

/// Start a backdrop on `canvas` with the page's `data`: the scene it names
/// (docs/backgrounds.md §2), the dashboard's sky by default. `still`
/// is the viewer's choice of a still backdrop; reduced motion asks for
/// one too. Without WebGL2 there is no backdrop, and nothing breaks.
#[wasm_bindgen]
pub fn start(canvas: HtmlCanvasElement, data: JsValue, still: bool) -> Result<(), JsValue> {
    let window = web_sys::window().ok_or("no window")?;
    let document = window.document().ok_or("no document")?;
    let reduced = window.match_media("(prefers-reduced-motion: reduce)").ok().flatten().is_some_and(|m| m.matches());
    let still = still || reduced;

    let options = js_sys::Object::new();
    js_sys::Reflect::set(&options, &"alpha".into(), &true.into())?;
    js_sys::Reflect::set(&options, &"premultipliedAlpha".into(), &true.into())?;
    js_sys::Reflect::set(&options, &"antialias".into(), &false.into())?;
    js_sys::Reflect::set(&options, &"powerPreference".into(), &"low-power".into())?;
    let gl: WebGl2RenderingContext = canvas.get_context_with_context_options("webgl2", &options)?.ok_or("no WebGL2")?.dyn_into()?;
    let renderer = gl::Renderer::new(gl)?;

    let body = document.body().ok_or("no body")?;
    let probe: HtmlElement = document.create_element("span")?.dyn_into()?;
    probe.set_attribute("style", "position:fixed;visibility:hidden;pointer-events:none")?;
    probe.set_attribute("aria-hidden", "true")?;
    body.append_child(&probe)?;
    let label: HtmlElement = document.create_element("div")?.dyn_into()?;
    label.set_class_name("bd-label");
    label.set_attribute("aria-hidden", "true")?;
    body.append_child(&label)?;

    let scene = read_scene(&data, still);
    let colours = Colours::default();
    let engine = Rc::new(RefCell::new(Engine {
        window: window.clone(),
        canvas,
        renderer,
        scene,
        colours,
        colours_at: f64::NEG_INFINITY,
        probe,
        label,
        label_text: String::new(),
        inst: Vec::new(),
        lines: Vec::new(),
        last: None,
        frame: 0,
        running: false,
        input_at: 0.0,
        pw: 0,
        ph: 0,
    }));
    {
        let mut e = engine.borrow_mut();
        e.fit();
        e.input_at = e.now();
    }

    // The frame loop: each frame asks for the next while it is wanted.
    let frame: Frame = Rc::new(RefCell::new(None));
    {
        let (engine, again) = (engine.clone(), frame.clone());
        *frame.borrow_mut() = Some(Closure::new(move |t: f64| {
            let more = engine.borrow_mut().tick(t);
            let mut e = engine.borrow_mut();
            if more {
                if let Some(f) = again.borrow().as_ref() {
                    let _ = e.window.request_animation_frame(f.as_ref().unchecked_ref());
                }
            } else {
                e.running = false;
            }
        }));
    }

    // The cursor lights marks; it never moves them.
    {
        let (engine, frame) = (engine.clone(), frame.clone());
        let moved = Closure::<dyn FnMut(web_sys::MouseEvent)>::new(move |ev: web_sys::MouseEvent| {
            {
                let mut e = engine.borrow_mut();
                e.scene.point(Some((ev.client_x() as f32, ev.client_y() as f32)));
                e.input_at = e.now();
            }
            wake(&engine, &frame);
        });
        window.add_event_listener_with_callback("mousemove", moved.as_ref().unchecked_ref())?;
        moved.forget();
    }
    {
        let (engine, frame) = (engine.clone(), frame.clone());
        let left = Closure::<dyn FnMut(web_sys::MouseEvent)>::new(move |ev: web_sys::MouseEvent| {
            if ev.related_target().is_none() {
                engine.borrow_mut().scene.point(None);
                wake(&engine, &frame);
            }
        });
        document.add_event_listener_with_callback("mouseout", left.as_ref().unchecked_ref())?;
        left.forget();
    }
    {
        let (engine, frame) = (engine.clone(), frame.clone());
        let resized = Closure::<dyn FnMut()>::new(move || {
            engine.borrow_mut().fit();
            wake(&engine, &frame);
        });
        window.add_event_listener_with_callback("resize", resized.as_ref().unchecked_ref())?;
        resized.forget();
    }
    {
        let (engine, frame) = (engine.clone(), frame.clone());
        let shown = Closure::<dyn FnMut()>::new(move || {
            let visible = engine.borrow().window.document().is_some_and(|d| !d.hidden());
            if visible {
                engine.borrow_mut().last = None;
                wake(&engine, &frame);
            }
        });
        document.add_event_listener_with_callback("visibilitychange", shown.as_ref().unchecked_ref())?;
        shown.forget();
    }

    RUNNING.with(|r| *r.borrow_mut() = Some((engine.clone(), frame.clone())));
    wake(&engine, &frame);
    Ok(())
}