//! Drawing a sky with WebGL2 (docs/backgrounds.md §6): every mark in one
//! instanced draw, every link in one line buffer. Shaders are here as
//! string literals; marks are drawn as signed-distance shapes, so they
//! stay crisp at any device pixel ratio.

use wasm_bindgen::prelude::*;
use web_sys::{WebGl2RenderingContext as Gl, WebGlBuffer, WebGlProgram, WebGlShader, WebGlUniformLocation, WebGlVertexArrayObject};

const MARK_VS: &str = r#"#version 300 es
layout(location = 0) in vec2 corner;
layout(location = 1) in vec2 center;
layout(location = 2) in float size;
layout(location = 3) in float shape;
layout(location = 4) in vec4 colour;
uniform vec2 view;
out vec2 uv;
out float vshape;
out vec4 vcolour;
out float px;
void main() {
    float r = size + 1.5;
    vec2 p = center + corner * r;
    uv = corner * r / size;
    vshape = shape;
    vcolour = colour;
    px = 1.0 / size;
    gl_Position = vec4(p.x / view.x * 2.0 - 1.0, 1.0 - p.y / view.y * 2.0, 0.0, 1.0);
}
"#;

const MARK_FS: &str = r#"#version 300 es
precision mediump float;
in vec2 uv;
in float vshape;
in vec4 vcolour;
in float px;
out vec4 frag;
void main() {
    vec2 a = abs(uv);
    float d;
    if (vshape < 0.5) {
        d = length(uv) - 1.0;                       // a push: a dot
    } else if (vshape < 1.5) {
        d = (a.x + a.y) * 0.85 - 1.0;               // a proposal: a diamond
    } else if (vshape < 2.5) {
        d = abs(length(uv) - 0.72) - 0.28;          // an issue: a ring
    } else if (vshape < 3.5) {
        d = min(a.x + 3.5 * a.y, 3.5 * a.x + a.y) * 0.5 - 0.5;  // a release: a star
    } else if (vshape < 4.5) {
        d = abs(length(uv) - 0.85) - 0.12;          // a repository: a thin ring
    } else {
        d = max(a.x, a.y) * 1.15 - 1.0;             // a Flow run: a square
    }
    float cover = 1.0 - smoothstep(-px, px, d);
    frag = vcolour * cover;
}
"#;

const LINE_VS: &str = r#"#version 300 es
layout(location = 0) in vec2 pos;
layout(location = 1) in vec4 colour;
uniform vec2 view;
out vec4 vcolour;
void main() {
    vcolour = colour;
    gl_Position = vec4(pos.x / view.x * 2.0 - 1.0, 1.0 - pos.y / view.y * 2.0, 0.0, 1.0);
}
"#;

const LINE_FS: &str = r#"#version 300 es
precision mediump float;
in vec4 vcolour;
out vec4 frag;
void main() { frag = vcolour; }
"#;

/// Floats per mark instance and per line vertex (sky::Sky's layouts).
const MARK_FLOATS: i32 = 8;
const LINE_FLOATS: i32 = 6;

pub struct Renderer {
    gl: Gl,
    marks: WebGlProgram,
    lines: WebGlProgram,
    mark_view: Option<WebGlUniformLocation>,
    line_view: Option<WebGlUniformLocation>,
    mark_vao: WebGlVertexArrayObject,
    line_vao: WebGlVertexArrayObject,
    instances: WebGlBuffer,
    line_buf: WebGlBuffer,
}

fn shader(gl: &Gl, kind: u32, src: &str) -> Result<WebGlShader, JsValue> {
    let s = gl.create_shader(kind).ok_or("no shader")?;
    gl.shader_source(&s, src);
    gl.compile_shader(&s);
    if gl.get_shader_parameter(&s, Gl::COMPILE_STATUS).as_bool() == Some(true) {
        Ok(s)
    } else {
        Err(gl.get_shader_info_log(&s).unwrap_or_default().into())
    }
}

fn program(gl: &Gl, vs: &str, fs: &str) -> Result<WebGlProgram, JsValue> {
    let p = gl.create_program().ok_or("no program")?;
    gl.attach_shader(&p, &shader(gl, Gl::VERTEX_SHADER, vs)?);
    gl.attach_shader(&p, &shader(gl, Gl::FRAGMENT_SHADER, fs)?);
    gl.link_program(&p);
    if gl.get_program_parameter(&p, Gl::LINK_STATUS).as_bool() == Some(true) {
        Ok(p)
    } else {
        Err(gl.get_program_info_log(&p).unwrap_or_default().into())
    }
}

fn float_attrib(gl: &Gl, loc: u32, size: i32, stride: i32, offset: i32, divisor: u32) {
    gl.enable_vertex_attrib_array(loc);
    gl.vertex_attrib_pointer_with_i32(loc, size, Gl::FLOAT, false, stride * 4, offset * 4);
    gl.vertex_attrib_divisor(loc, divisor);
}

impl Renderer {
    pub fn new(gl: Gl) -> Result<Renderer, JsValue> {
        let marks = program(&gl, MARK_VS, MARK_FS)?;
        let lines = program(&gl, LINE_VS, LINE_FS)?;
        let mark_view = gl.get_uniform_location(&marks, "view");
        let line_view = gl.get_uniform_location(&lines, "view");

        // Marks: one shared quad, and one instance per mark.
        let mark_vao = gl.create_vertex_array().ok_or("no vertex array")?;
        gl.bind_vertex_array(Some(&mark_vao));
        let quad = gl.create_buffer().ok_or("no buffer")?;
        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&quad));
        let corners: [f32; 8] = [-1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0];
        // Safety: the view is used at once, before anything can allocate.
        unsafe {
            let view = js_sys::Float32Array::view(&corners);
            gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STATIC_DRAW);
        }
        float_attrib(&gl, 0, 2, 2, 0, 0);
        let instances = gl.create_buffer().ok_or("no buffer")?;
        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&instances));
        float_attrib(&gl, 1, 2, MARK_FLOATS, 0, 1);
        float_attrib(&gl, 2, 1, MARK_FLOATS, 2, 1);
        float_attrib(&gl, 3, 1, MARK_FLOATS, 3, 1);
        float_attrib(&gl, 4, 4, MARK_FLOATS, 4, 1);

        // Links: plain lines, two vertices each.
        let line_vao = gl.create_vertex_array().ok_or("no vertex array")?;
        gl.bind_vertex_array(Some(&line_vao));
        let line_buf = gl.create_buffer().ok_or("no buffer")?;
        gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&line_buf));
        float_attrib(&gl, 0, 2, LINE_FLOATS, 0, 0);
        float_attrib(&gl, 1, 4, LINE_FLOATS, 2, 0);
        gl.bind_vertex_array(None);

        gl.enable(Gl::BLEND);
        // Colours are premultiplied.
        gl.blend_func(Gl::ONE, Gl::ONE_MINUS_SRC_ALPHA);
        Ok(Renderer { gl, marks, lines, mark_view, line_view, mark_vao, line_vao, instances, line_buf })
    }

    /// Draw one frame: `instances` and `lines` as sky::Sky lays them out,
    /// in a view of `w` by `h` CSS pixels on a canvas of `pw` by `ph`.
    pub fn draw(&self, w: f32, h: f32, pw: i32, ph: i32, instances: &[f32], lines: &[f32]) {
        let gl = &self.gl;
        gl.viewport(0, 0, pw, ph);
        gl.clear_color(0.0, 0.0, 0.0, 0.0);
        gl.clear(Gl::COLOR_BUFFER_BIT);

        if !lines.is_empty() {
            gl.use_program(Some(&self.lines));
            gl.uniform2f(self.line_view.as_ref(), w, h);
            gl.bind_vertex_array(Some(&self.line_vao));
            gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&self.line_buf));
            // Safety: as above, the view does not outlive this call.
            unsafe {
                let view = js_sys::Float32Array::view(lines);
                gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STREAM_DRAW);
            }
            gl.draw_arrays(Gl::LINES, 0, lines.len() as i32 / LINE_FLOATS);
        }

        if !instances.is_empty() {
            gl.use_program(Some(&self.marks));
            gl.uniform2f(self.mark_view.as_ref(), w, h);
            gl.bind_vertex_array(Some(&self.mark_vao));
            gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&self.instances));
            unsafe {
                let view = js_sys::Float32Array::view(instances);
                gl.buffer_data_with_array_buffer_view(Gl::ARRAY_BUFFER, &view, Gl::STREAM_DRAW);
            }
            gl.draw_arrays_instanced(Gl::TRIANGLE_STRIP, 0, 4, instances.len() as i32 / MARK_FLOATS);
        }
        gl.bind_vertex_array(None);
    }
}