use std::cell::RefCell;
use std::sync::{Mutex};
use std::rc::Rc;

use log::{Level, info, debug};
use wasm_bindgen::prelude::*;

use state::State;

mod line;
mod point;
mod state;

struct RenderLoop {
    inner: Rc<RefCell<Option<Closure<dyn FnMut(f64)>>>>,
}

impl RenderLoop {
    fn new<T: FnMut(f64) -> bool + 'static>(mut fun: T) -> Self {
        let inner = Rc::new(RefCell::new(None));
        let rloop = inner.clone();

        *inner.borrow_mut() = Some(Closure::new(move |t| {
            if fun(t) {
                request_animation_frame(rloop.borrow().as_ref().expect("can borrow rloop"));
            }
        }));
        Self { inner }
    }

    fn start(&self) -> Result<(), JsValue> {
        request_animation_frame(self.inner.borrow().as_ref().ok_or("closure exists")?);
        Ok(())
    }
}

impl Clone for RenderLoop {
    fn clone(&self) -> Self  {
        Self { inner: self.inner.clone() }
    }
}

fn window() -> web_sys::Window {
    web_sys::window().expect("no window")
}

fn document() -> web_sys::Document {
    window().document().expect("no document")
}

fn canvas() -> Result<web_sys::HtmlCanvasElement, JsValue> {
    let x = document()
        .query_selector("canvas")?
        .expect("canvas element");
    Ok(x.dyn_into::<web_sys::HtmlCanvasElement>()?)
}

fn fps() -> Result<web_sys::HtmlElement, JsValue> {
    let x = document()
        .query_selector("#fps")?
        .expect("fps counter exists");
    Ok(x.dyn_into::<web_sys::HtmlElement>()?)
}

fn go() -> Result<web_sys::HtmlElement, JsValue> {
    let x = document()
        .query_selector("button")?
        .expect("go button exists");
    Ok(x.dyn_into::<web_sys::HtmlElement>()?)
}

fn request_animation_frame(f: &Closure<dyn FnMut(f64)>) {
    window()
        .request_animation_frame(f.as_ref().unchecked_ref())
        .expect("should register `requestAnimationFrame` OK");
}

#[wasm_bindgen(start)]
pub fn init() -> Result<(), JsValue> {
    console_log::init_with_level(Level::Debug).expect("couldn't init console log");
    info!("wasm init");

    let paused = Rc::new(Mutex::new(true));
    let p1 = paused.clone();

    let mut s = State::new(canvas()?, fps()?)?;
    s.render_frame(0.0)?;

    let render_loop = RenderLoop::new(move |t| {
        s.render_frame(t).expect("should render frame");
        !*paused.lock().unwrap()
    });
    render_loop.start()?;

    let a = Closure::<dyn FnMut()>::new(move || {
        let mut p = p1.lock().unwrap();
        debug!("go clicked: {}", *p);
        *p = !*p;
        let text = if *p {
            "go"
        } else {
            render_loop.start().expect("start render loop");
            "pause"
        };
        go().expect("go button works").set_text_content(Some(text));
    });
    go()?.set_onclick(Some(a.as_ref().unchecked_ref()));
    // otherwise it gets dropped after we're done, invalidating the
    // handler.
    a.forget();

    Ok(())
}