use std::{fmt::Debug, hash::Hash, sync::{Arc, Mutex}};

use layout::{backends::svg::SVGWriter, gv::{self, GraphBuilder}};
use eframe::egui;

#[cfg_attr(
    feature = "persistence",
    derive(serde::Serialize, serde::Deserialize)
)]
#[derive(Clone, Default)]
pub(crate) struct Svg {
    image: egui::ColorImage,
    /// original size of the svg
    svg_size: egui::Vec2,

    #[cfg_attr(feature = "persistence", serde(skip))]
    svg_texture: Arc<Mutex<Option<egui::TextureHandle>>>,
}

impl Svg {
    pub(crate) fn parse_dot_string(dot_str: &str) -> Result<Svg, String> {
        let mut parser = gv::DotParser::new(dot_str);
        let g = match parser.process() {
            Ok(g) => g,
            Err(_) =>
                // errors are printed to sdtout so we ignore them
                return Err("Could not parse dot string.".into()),
        };

        let mut gb = GraphBuilder::new();
        gb.visit_graph(&g);
        let mut graph = gb.get();
        let mut svg = SVGWriter::new();
        graph.do_it(
            false,
            false,
            false,
            &mut svg,
        );
        let content = svg.finalize();

        let svg = match nsvg::parse_str(&content, nsvg::Units::Pixel, 96.0) {
            Ok(svg) => svg,
            Err(nsvg_err) => return Err(format!("{}", nsvg_err)),
        };

        let svg_size = egui::vec2(svg.width(), svg.height());

        let (w, h, data) = match svg.rasterize_to_raw_rgba(1.) {
            Ok(o) => o,
            Err(e) => return Err(format!("{}", e)),
        };

        let image = egui::ColorImage::from_rgba_unmultiplied([w as _, h as _], &data);

        let svg = Svg { image, svg_size, svg_texture: Arc::new(Mutex::new(None)) };

        Ok(svg)
    }

    pub(crate) fn get_texture(&self, ctx: &egui::Context) -> egui::TextureHandle {
        let tx = self.svg_texture.lock().expect("Poisoned");
        if tx.is_some() {
            (*tx).clone().unwrap()
        } else {
            std::mem::drop(tx);
            let svg_texture = ctx.load_texture("svg", self.image.clone(), Default::default());
            *self.svg_texture.lock().expect("Poisoned") = Some(svg_texture.clone());
            svg_texture
        }
    }
}

impl Debug for Svg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[image: {:?}, svg_size: {:?}, svg_texture: {}",
               self.image,
               self.svg_size,
               if self.svg_texture.lock().expect("Poisoned").is_some() {
                   "Some(...)"
               } else {
                   "None"
               }
        )
    }
}

impl Hash for Svg {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        macro_rules! hash_float {
            ($name:expr) => (
                let bits = if $name.is_nan() {
                    // "Canonical" NaN.
                    0x7fc00000
                } else {
                    // A trick taken from the `ordered-float` crate: -0.0 + 0.0 == +0.0.
                    // https://github.com/reem/rust-ordered-float/blob/1841f0541ea0e56779cbac03de2705149e020675/src/lib.rs#L2178-L2181
                    ($name + 0.0).to_bits()
                };
                bits.hash(state);
            );
        }

        hash_float!(self.svg_size.x);
        hash_float!(self.svg_size.y);
        self.image.pixels.hash(state);
        self.image.size.hash(state);
        hash_float!(self.image.source_size.x);
        hash_float!(self.image.source_size.y);
        self.svg_texture.lock().expect("Poisoned").hash(state);
    }
}