use std::fmt::{self, Write};

use crate::{

    diagnostic_chain::DiagnosticChain, protocol::Diagnostic, ReportHandler, Severity, SourceCode,

};

/**

[`ReportHandler`] that renders JSON output. It's a machine-readable output.

*/

#[derive(Debug, Clone)]

pub struct JSONReportHandler;

impl JSONReportHandler {

    /// Create a new [`JSONReportHandler`]. There are no customization

    /// options.

    pub const fn new() -> Self {

        Self

    }

}

impl Default for JSONReportHandler {

    fn default() -> Self {

        Self::new()

    }

}

struct Escape<'a>(&'a str);

impl fmt::Display for Escape<'_> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        for c in self.0.chars() {

            let escape = match c {

                '\\' => Some(r"\\"),

                '"' => Some(r#"\""#),

                '\r' => Some(r"\r"),

                '\n' => Some(r"\n"),

                '\t' => Some(r"\t"),

                '\u{08}' => Some(r"\b"),

                '\u{0c}' => Some(r"\f"),

                _ => None,

            };

            if let Some(escape) = escape {

                f.write_str(escape)?;

            } else {

                f.write_char(c)?;

            }

        }

        Ok(())

    }

}

const fn escape(input: &'_ str) -> Escape<'_> {

    Escape(input)

}

impl JSONReportHandler {

    /// Render a [`Diagnostic`]. This function is mostly internal and meant to

    /// be called by the toplevel [`ReportHandler`] handler, but is made public

    /// to make it easier (possible) to test in isolation from global state.

    pub fn render_report(

        &self,

        f: &mut impl fmt::Write,

        diagnostic: &(dyn Diagnostic),

    ) -> fmt::Result {

        self._render_report(f, diagnostic, None)

    }

    fn _render_report(

        &self,

        f: &mut impl fmt::Write,

        diagnostic: &(dyn Diagnostic),

        parent_src: Option<&dyn SourceCode>,

    ) -> fmt::Result {

        write!(f, r#"{{"message": "{}","#, escape(&diagnostic.to_string()))?;

        if let Some(code) = diagnostic.code() {

            write!(f, r#""code": "{}","#, escape(&code.to_string()))?;

        }

        let severity = match diagnostic.severity() {

            Some(Severity::Error) | None => "error",

            Some(Severity::Warning) => "warning",

            Some(Severity::Advice) => "advice",

        };

        write!(f, r#""severity": "{:}","#, severity)?;

        if let Some(cause_iter) = diagnostic

            .diagnostic_source()

            .map(DiagnosticChain::from_diagnostic)

            .or_else(|| diagnostic.source().map(DiagnosticChain::from_stderror))

        {

            write!(f, r#""causes": ["#)?;

            let mut add_comma = false;

            for error in cause_iter {

                if add_comma {

                    write!(f, ",")?;

                } else {

                    add_comma = true;

                }

                write!(f, r#""{}""#, escape(&error.to_string()))?;

            }

            write!(f, "],")?;

        } else {

            write!(f, r#""causes": [],"#)?;

        }

        if let Some(url) = diagnostic.url() {

            write!(f, r#""url": "{}","#, &url.to_string())?;

        }

        if let Some(help) = diagnostic.help() {

            write!(f, r#""help": "{}","#, escape(&help.to_string()))?;

        }

        let src = diagnostic.source_code().or(parent_src);

        if let Some(src) = src {

            self.render_snippets(f, diagnostic, src)?;

        }

        if let Some(labels) = diagnostic.labels() {

            write!(f, r#""labels": ["#)?;

            let mut add_comma = false;

            for label in labels {

                if add_comma {

                    write!(f, ",")?;

                } else {

                    add_comma = true;

                }

                write!(f, "{{")?;

                if let Some(label_name) = label.label() {

                    write!(f, r#""label": "{}","#, escape(label_name))?;

                }

                write!(f, r#""span": {{"#)?;

                write!(f, r#""offset": {},"#, label.offset())?;

                write!(f, r#""length": {}"#, label.len())?;

                write!(f, "}}}}")?;

            }

            write!(f, "],")?;

        } else {

            write!(f, r#""labels": [],"#)?;

        }

        if let Some(relateds) = diagnostic.related() {

            write!(f, r#""related": ["#)?;

            let mut add_comma = false;

            for related in relateds {

                if add_comma {

                    write!(f, ",")?;

                } else {

                    add_comma = true;

                }

                self._render_report(f, related, src)?;

            }

            write!(f, "]")?;

        } else {

            write!(f, r#""related": []"#)?;

        }

        write!(f, "}}")

    }

    fn render_snippets(

        &self,

        f: &mut impl fmt::Write,

        diagnostic: &(dyn Diagnostic),

        source: &dyn SourceCode,

    ) -> fmt::Result {

        if let Some(mut labels) = diagnostic.labels() {

            if let Some(label) = labels.next() {

                if let Ok(span_content) = source.read_span(label.inner(), 0, 0) {

                    let filename = span_content.name().unwrap_or_default();

                    return write!(f, r#""filename": "{}","#, escape(filename));

                }

            }

        }

        write!(f, r#""filename": "","#)

    }

}

impl ReportHandler for JSONReportHandler {

    fn debug(&self, diagnostic: &(dyn Diagnostic), f: &mut fmt::Formatter<'_>) -> fmt::Result {

        self.render_report(f, diagnostic)

    }

}

#[test]

fn test_escape() {

    assert_eq!(escape("a\nb").to_string(), r"a\nb");

    assert_eq!(escape("C:\\Miette").to_string(), r"C:\\Miette");

}