//! Live operation previews. While a feature dialog is open, its commands are evaluated on a
//! scratch copy of the session ([`solvecraft_engine::Session::preview`]), off the UI thread
//! where threads exist, and the result is drawn in place of the bodies it changes: new surface
//! tinted, removed material as a translucent ghost. The last good preview stays up while the
//! next one computes or when an input makes the feature fail (the error shows in the dialog).
//! Nothing here touches the document or the undo history.

use std::hash::{Hash, Hasher};
use std::sync::mpsc::{Receiver, TryRecvError};

use serde_json::Value;
use solvecraft_engine::Session;
use solvecraft_engine::doc::ModelState;
use solvecraft_engine::geom::{Aabb3, Mesh, Vec3};

use crate::SolveApp;
use crate::gpu::{GpuScene, SceneSlot};
use crate::theme::Tokens;

/// Colours a preview is drawn with (straight sRGBA).
#[derive(Clone, Copy, Debug)]
pub struct Colors {
    pub body: [u8; 4],
    pub added: [u8; 4],
    pub removed: [u8; 4],
    pub edge: [u8; 4],
}

impl Colors {
    pub fn from_tokens(t: &Tokens) -> Colors {
        let c = |c: egui::Color32| c.to_srgba_unmultiplied();
        Colors { body: c(t.body), added: c(t.preview_add), removed: c(t.preview_cut), edge: c(t.body_edge) }
    }
}

/// A computed preview: the scene to draw and the bodies it stands in for.
pub struct Built {
    pub scene: GpuScene,
    pub replaced: Vec<String>,
    /// Why the feature failed, when the scene only shows its tool body.
    pub error: Option<String>,
    /// Extent of what the preview shows (the view's depth range must cover it).
    pub bounds: Aabb3,
}

type Job = Result<Built, String>;

#[derive(Default)]
pub struct PreviewState {
    /// Key of the commands whose result (or error) is shown.
    shown_key: Option<u64>,
    running: Option<(u64, Receiver<Job>)>,
    /// Bodies the preview stands in for (hidden in the model scene).
    pub replaced: Vec<String>,
    /// The preview scene for the GPU and its key (changes whenever the scene does).
    pub slot: SceneSlot,
    pub key: u64,
    /// Is a preview scene up?
    pub active: bool,
    /// Why the current inputs don't make a feature (the last good preview stays up).
    pub error: Option<String>,
    /// A preview is being computed.
    pub busy: bool,
    /// Extent of the preview scene.
    pub bounds: Aabb3,
    /// Time the last preview took (ms), for `ui.inspect`.
    pub ms: f64,
    started: f64,
}

impl PreviewState {
    fn clear(&mut self) {
        self.running = None;
        self.shown_key = None;
        self.error = None;
        self.busy = false;
        if self.active || !self.replaced.is_empty() {
            self.active = false;
            self.bounds = Aabb3::EMPTY;
            self.replaced.clear();
            self.set_scene(GpuScene::default());
        }
    }

    fn set_scene(&mut self, sc: GpuScene) {
        if let Ok(mut slot) = self.slot.lock() {
            *slot = Some(sc);
        }
        self.key = self.key.wrapping_add(1);
    }

    fn apply(&mut self, key: u64, job: Job) {
        self.shown_key = Some(key);
        self.ms = crate::now_ms() - self.started;
        match job {
            Ok(b) => {
                self.replaced = b.replaced;
                self.bounds = b.bounds;
                self.active = true;
                self.error = b.error;
                self.set_scene(b.scene);
            }
            Err(e) => self.error = Some(e),
        }
    }

    /// Errors validate only the current inputs. Keep the last good geometry while
    /// computing new inputs, but never let an obsolete result block their Apply.
    fn poll(&mut self, key: u64) {
        if self.shown_key != Some(key) {
            self.error = None;
        }
        if let Some((k, rx)) = &self.running {
            let k = *k;
            let job = match rx.try_recv() {
                Ok(job) => Some(job),
                Err(TryRecvError::Empty) => None,
                Err(TryRecvError::Disconnected) => Some(Err("the preview failed".into())),
            };
            if let Some(job) = job {
                self.running = None;
                if k == key {
                    self.apply(k, job);
                }
            }
        }
    }
}

/// Keep the preview in step with the open dialog: start a computation when its inputs changed,
/// take finished results. Called once per frame.
pub fn update(app: &mut SolveApp, ctx: &egui::Context) {
    let cmds = match app.dialog.as_ref().filter(|d| d.previews()).map(|d| crate::dialogs::preview_commands(app, d)) {
        Some(Ok(c)) if !c.is_empty() => c,
        _ if crate::sketch_attachment_ui::commands(app).is_some() => crate::sketch_attachment_ui::commands(app).unwrap_or_default(),
        // A parameter being edited in Change Parameters.
        _ if app.params.as_ref().and_then(|p| p.preview_commands()).is_some() => {
            app.params.as_ref().and_then(|p| p.preview_commands()).unwrap_or_default()
        }
        // No dialog, or inputs still missing: nothing to preview.
        _ => {
            app.preview.clear();
            return;
        }
    };
    let colors = Colors::from_tokens(&Tokens::get());
    let mut h = std::collections::hash_map::DefaultHasher::new();
    serde_json::to_string(&cmds).unwrap_or_default().hash(&mut h);
    app.session.revision.hash(&mut h);
    format!("{colors:?}").hash(&mut h);
    let key = h.finish();
    let pv = &mut app.preview;
    pv.poll(key);
    if pv.running.is_none() && pv.shown_key != Some(key) {
        pv.started = crate::now_ms();
        let scratch = app.session.scratch();
        spawn(&mut app.preview, key, scratch, cmds, colors);
    }
    app.preview.busy = app.preview.running.is_some();
    if app.preview.busy {
        ctx.request_repaint_after(std::time::Duration::from_millis(16));
    }
}

#[cfg(not(target_arch = "wasm32"))]
fn spawn(pv: &mut PreviewState, key: u64, scratch: Session, cmds: Vec<(String, Value)>, colors: Colors) {
    let (tx, rx) = std::sync::mpsc::channel();
    let spawned = std::thread::Builder::new().name("preview".into()).spawn(move || {
        let _ = tx.send(compute(&scratch, &cmds, colors));
    });
    match spawned {
        Ok(_) => pv.running = Some((key, rx)),
        Err(e) => pv.apply(key, Err(e.to_string())),
    }
}

/// No threads on the web: compute right away.
#[cfg(target_arch = "wasm32")]
fn spawn(pv: &mut PreviewState, key: u64, scratch: Session, cmds: Vec<(String, Value)>, colors: Colors) {
    pv.apply(key, compute(&scratch, &cmds, colors));
}

/// Evaluate the commands on the scratch session and build the preview scene.
/// Features that add or remove a tool body (extrude, revolve, primitives with join, cut or
/// intersect) show the tool itself: tinted for join, see-through red for cut. Other features
/// show their result in place of the bodies they change. When the feature fails (a boolean the
/// kernel can't do yet), the tool body is still shown, with the error.
pub fn compute(s: &Session, cmds: &[(String, Value)], colors: Colors) -> Job {
    if cmds.iter().any(|(command, _)| command == "sketch.redefine") {
        let preview = s.preview_visible_world(cmds).map_err(|error| error.to_string())?;
        return std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
            let mut built = build(&preview.before, &preview.after, colors);
            built.bounds = state_bounds(&preview.after);
            built
        }))
        .map_err(|_| "the preview failed".to_string());
    }
    // Joints and drives move occurrences: shown on the placed model.
    if let Some(job) = crate::dialogs_assembly::world_preview(s, cmds, colors) {
        return job;
    }
    let real = s.preview(cmds);
    let guard = |f: &dyn Fn() -> Built| std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)).map_err(|_| "the preview failed".to_string());
    match as_new_body(cmds) {
        Some((alt, op)) => {
            let tool = match s.preview(&alt) {
                Ok(t) => t,
                Err(e) => return Err(real.err().map_or_else(|| e.to_string(), |r| r.to_string())),
            };
            let mut b = guard(&|| build_tool(&tool.before, &tool.after, colors, &op))?;
            b.error = real.err().map(|e| e.to_string());
            b.bounds = state_bounds(&tool.after);
            Ok(b)
        }
        None => {
            let p = real.map_err(|e| e.to_string())?;
            let mut b = guard(&|| build(&p.before, &p.after, colors))?;
            b.bounds = state_bounds(&p.after);
            Ok(b)
        }
    }
}

fn state_bounds(st: &ModelState) -> Aabb3 {
    st.bodies.iter().fold(Aabb3::EMPTY, |b, x| b.union(&x.mesh().bounds()))
}

/// The tool bodies a join/cut/intersect adds: opaque and tinted for join, see-through for cut
/// (red) and intersect.
fn build_tool(before: &ModelState, after: &ModelState, c: Colors, op: &str) -> Built {
    let mut sc = GpuScene::default();
    for a in after.bodies.iter().filter(|a| before.body(&a.name).is_none()) {
        let m = a.mesh();
        for t in &m.triangles {
            for k in t {
                let i = *k as usize;
                if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
                    match op {
                        "cut" => sc.xray_tri(p.to_f32(), n.to_f32(), c.removed),
                        "intersect" => sc.xray_tri(p.to_f32(), n.to_f32(), [c.added[0], c.added[1], c.added[2], c.removed[3]]),
                        _ => sc.tri(p.to_f32(), n.to_f32(), c.added),
                    }
                }
            }
        }
        let edge = if op == "cut" { [c.removed[0], c.removed[1], c.removed[2], 255] } else { c.edge };
        for (ei, e) in m.edges.iter().enumerate() {
            if m.shaded_edge_visible(ei) {
                for w in e.windows(2) {
                    sc.line(w[0].to_f32(), w[1].to_f32(), edge, 1.3, op != "join");
                }
            }
        }
    }
    Built { scene: sc, replaced: Vec::new(), error: None, bounds: Aabb3::EMPTY }
}

/// The same commands making a new body instead of joining, cutting or intersecting, and the
/// operation they had.
fn as_new_body(cmds: &[(String, Value)]) -> Option<(Vec<(String, Value)>, String)> {
    let mut out = cmds.to_vec();
    let mut changed: Option<String> = None;
    for (_, p) in &mut out {
        let p = if p.get("command").is_some() { p.get_mut("params")? } else { p };
        if let Some(op) = p.get_mut("operation")
            && let Some(o) = op.as_str().filter(|o| *o != "new").map(str::to_string)
        {
            *op = Value::from("new");
            changed = Some(o);
        }
    }
    changed.map(|op| (out, op))
}

fn same(a: &Mesh, b: &Mesh) -> bool {
    a.triangles.len() == b.triangles.len() && a.positions == b.positions
}

/// The preview scene: changed and new bodies (new surface tinted) and, as a ghost, the old
/// version of changed or removed bodies.
pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {
    let mut sc = GpuScene::default();
    let mut replaced = Vec::new();
    for a in &after.bodies {
        let am = a.mesh();
        let old = before.body(&a.name).map(|b| b.mesh());
        if old.as_ref().is_some_and(|bm| same(bm, &am)) {
            continue;
        }
        let nf = am.tri_face.iter().max().map_or(0, |m| *m as usize + 1);
        let added: Vec<bool> = (0..nf).map(|f| old.as_ref().is_none_or(|bm| face_is_new(&am, f, bm))).collect();
        // Material removed from a body (a hole, a pocket): its new faces also show through the
        // body in the cut colour, so the cut is seen from any side.
        let cut = old.as_ref().is_some_and(|bm| am.measure().volume < bm.measure().volume - 1e-6);
        for (t, f) in am.triangles.iter().zip(&am.tri_face) {
            let new = added.get(*f as usize).copied().unwrap_or(true);
            let col = if new { c.added } else { c.body };
            for k in t {
                let i = *k as usize;
                if let (Some(p), Some(n)) = (am.positions.get(i), am.normals.get(i)) {
                    sc.tri(p.to_f32(), n.to_f32(), col);
                    if new && cut {
                        sc.xray_tri(p.to_f32(), n.to_f32(), c.removed);
                    }
                }
            }
        }
        for (ei, e) in am.edges.iter().enumerate() {
            if !am.shaded_edge_visible(ei) {
                continue;
            }
            for w in e.windows(2) {
                sc.line(w[0].to_f32(), w[1].to_f32(), c.edge, 1.3, false);
            }
        }
        if old.is_some() {
            replaced.push(a.name.clone());
        }
    }
    for b in &before.bodies {
        let gone = after.body(&b.name).is_none();
        if !gone && !replaced.contains(&b.name) {
            continue;
        }
        let m = b.mesh();
        for t in &m.triangles {
            for k in t {
                let i = *k as usize;
                if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {
                    sc.ghost_tri(p.to_f32(), n.to_f32(), c.removed);
                }
            }
        }
        if gone {
            replaced.push(b.name.clone());
        }
    }
    Built { scene: sc, replaced, error: None, bounds: Aabb3::EMPTY }
}

/// Is face `f` of `m` new surface, i.e. not on the old mesh? Decided by a vote of points on it
/// (triangle centroids spread over the face).
fn face_is_new(m: &Mesh, f: usize, old: &Mesh) -> bool {
    let cents: Vec<Vec3> = m
        .triangles
        .iter()
        .zip(&m.tri_face)
        .filter(|(_, tf)| **tf as usize == f)
        .filter_map(|(t, _)| m.tri(t))
        .map(|[a, b, c]| (a + b + c) / 3.0)
        .collect();
    if cents.is_empty() {
        return true;
    }
    let step = cents.len().div_ceil(9);
    let samples: Vec<&Vec3> = cents.iter().step_by(step.max(1)).collect();
    let off = samples.iter().filter(|p| !on_surface(old, ***p)).count();
    off * 3 > samples.len()
}

/// Does `p` lie on the surface of mesh `m` (within its tessellation tolerance)?
fn on_surface(m: &Mesh, p: Vec3) -> bool {
    let bb = m.bounds();
    let tol = (bb.diagonal() * 2e-3).max(1e-4);
    if bb.is_empty() {
        return false;
    }
    m.triangles.iter().filter_map(|t| m.tri(t)).any(|[a, b, c]| point_triangle_dist(p, a, b, c) < tol)
}

pub fn point_triangle_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 {
    let n = (b - a).cross(c - a);
    let Some(nn) = n.normalized() else { return f64::INFINITY };
    let h = (p - a).dot(nn);
    let q = p - nn * h;
    let inside = [(a, b), (b, c), (c, a)].iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(n) >= -1e-12);
    if inside { h.abs() } else { [(a, b), (b, c), (c, a)].iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min) }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn colors() -> Colors {
        Colors { body: [1, 1, 1, 255], added: [2, 2, 2, 255], removed: [3, 3, 3, 100], edge: [0, 0, 0, 255] }
    }

    #[test]
    fn correcting_inputs_clears_old_errors_and_discards_late_old_jobs() {
        let mut pv = PreviewState {
            shown_key: Some(1),
            error: Some("unknown_angle".into()),
            active: true,
            replaced: vec!["Turn".into()],
            key: 9,
            ..PreviewState::default()
        };
        let (tx, rx) = std::sync::mpsc::channel();
        pv.running = Some((1, rx));
        pv.poll(2);
        assert!(pv.error.is_none(), "the corrected inputs can Apply while their preview computes");
        assert!(pv.running.is_some());
        assert!(pv.active);
        assert_eq!(pv.replaced, ["Turn"]);
        assert_eq!(pv.key, 9, "the last good geometry stays visible");
        tx.send(Err("unknown_angle".into())).unwrap();
        pv.poll(2);
        assert!(pv.error.is_none(), "a late obsolete result cannot disable Apply again");
        assert!(pv.running.is_none());
        assert_eq!(pv.shown_key, Some(1));
        assert_eq!(pv.key, 9);

        let (tx, rx) = std::sync::mpsc::channel();
        pv.running = Some((2, rx));
        tx.send(Err("current invalid expression".into())).unwrap();
        pv.poll(2);
        assert_eq!(pv.error.as_deref(), Some("current invalid expression"));
        assert_eq!(pv.shown_key, Some(2));
        pv.poll(2);
        assert_eq!(pv.error.as_deref(), Some("current invalid expression"), "current errors still prevent invalid Apply");
    }

    fn count(bytes: &[u8], stride: usize, col: [u8; 4]) -> usize {
        bytes.chunks(stride).filter(|v| v.get(24..28) == Some(&col[..])).count()
    }

    #[test]
    fn a_hole_shows_its_cut_through_the_body() {
        let mut s = solvecraft_engine::Session::default();
        s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20})).unwrap();
        let p = s.preview(&[("solid.hole".to_string(), json!({"position": [20, 15, 20], "diameter": 5, "depth": 10}))]).unwrap();
        let b = build(&p.before, &p.after, colors());
        // The hole's walls are drawn see-through in the cut colour (seen from any side).
        assert!(count(&b.scene.xray, 28, colors().removed) > 0);
        // A feature that only adds material shows no cut.
        let p = s.preview(&[("solid.box".to_string(), json!({"length": 10, "width": 10, "height": 30, "operation": "join"}))]).unwrap();
        assert_eq!(count(&build(&p.before, &p.after, colors()).scene.xray, 28, colors().removed), 0);
    }

    fn plate() -> Session {
        let mut s = Session::default();
        for (id, p) in [
            ("sketch.create", json!({"plane": "XY"})),
            ("sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 30]})),
            ("sketch.finish", json!({})),
            ("solid.extrude", json!({"distance": 20})),
        ] {
            s.execute(id, &p).unwrap();
        }
        s
    }

    /// A fillet preview stands in for the body: the round face is new, the rest is kept, and the
    /// old body is the ghost. The session is unchanged.
    #[test]
    fn fillet_preview_scene() {
        let s = plate();
        let (rev, undo) = (s.revision, s.undo.len());
        let b = compute(&s, &[("solid.fillet".into(), json!({"edges": [[0, 0, 10]], "radius": 3}))], colors()).unwrap();
        assert_eq!(b.replaced, vec!["Body1".to_string()]);
        let added = count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().added);
        let kept = count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().body);
        assert!(added > 0 && kept > 0, "added {added} kept {kept}");
        assert!(!b.scene.ghost.is_empty());
        assert_eq!(s.revision, rev);
        assert_eq!(s.undo.len(), undo);
    }

    /// A cut shows its tool see-through and replaces nothing.
    #[test]
    fn cut_preview_scene() {
        let mut s = plate();
        s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();
        s.execute("sketch.circle.center", &json!({"center": [20, 15], "radius": 5})).unwrap();
        s.execute("sketch.finish", &json!({})).unwrap();
        let b = compute(&s, &[("solid.extrude".into(), json!({"distance": 20, "operation": "cut"}))], colors()).unwrap();
        assert!(b.replaced.is_empty());
        assert!(b.scene.tris.is_empty() && !b.scene.xray.is_empty());
        assert!(b.error.is_none());
    }

    /// A new body is all new surface and replaces nothing; a bad value is an error.
    #[test]
    fn extrude_preview_scene() {
        let mut s = Session::default();
        s.execute("sketch.create", &json!({"plane": "XY"})).unwrap();
        s.execute("sketch.circle.center", &json!({"center": [0, 0], "radius": 5})).unwrap();
        s.execute("sketch.finish", &json!({})).unwrap();
        let b = compute(&s, &[("solid.extrude".into(), json!({"distance": "15 mm"}))], colors()).unwrap();
        assert!(b.replaced.is_empty());
        assert_eq!(count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().body), 0);
        assert!(b.scene.ghost.is_empty());
        assert!(compute(&s, &[("solid.extrude".into(), json!({"distance": "1 +"}))], colors()).is_err());
        assert!(s.model.state().bodies.is_empty());
    }
}