use crate::error::Result;
use crate::loader::Loader;
use ansi_term::{Color, Style};
use lazy_static::lazy_static;
use serde::ser::SerializeMap;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{json, Value};
use std::collections::HashMap;
use std::time::Instant;
use std::{fmt, fs, io, path};
use tree_sitter::{Language, PropertySheet};
use tree_sitter_highlight::{highlight, highlight_html, Highlight, HighlightEvent, Properties};

lazy_static! {
    static ref CSS_STYLES_BY_COLOR_ID: Vec<String> =
        serde_json::from_str(include_str!("../vendor/xterm-colors.json")).unwrap();
}

pub struct Theme {
    ansi_styles: Vec<Option<Style>>,
    css_styles: Vec<Option<String>>,
}

impl Theme {
    pub fn load(path: &path::Path) -> io::Result<Self> {
        let json = fs::read_to_string(path)?;
        Ok(serde_json::from_str(&json).unwrap_or_default())
    }

    fn ansi_style(&self, highlight: Highlight) -> Option<&Style> {
        self.ansi_styles[highlight as usize].as_ref()
    }

    fn css_style(&self, highlight: Highlight) -> Option<&str> {
        self.css_styles[highlight as usize]
            .as_ref()
            .map(|s| s.as_str())
    }
}

impl<'de> Deserialize<'de> for Theme {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Theme, D::Error>
    where
        D: Deserializer<'de>,
    {
        let highlight_count = Highlight::Unknown as usize + 1;
        let mut ansi_styles = vec![None; highlight_count];
        let mut css_styles = vec![None; highlight_count];
        if let Ok(colors) = HashMap::<Highlight, Value>::deserialize(deserializer) {
            for (highlight, style_value) in colors {
                let mut style = Style::default();
                parse_style(&mut style, style_value);
                ansi_styles[highlight as usize] = Some(style);
                css_styles[highlight as usize] = Some(style_to_css(style));
            }
        }
        Ok(Self {
            ansi_styles,
            css_styles,
        })
    }
}

impl Serialize for Theme {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let entry_count = self.ansi_styles.iter().filter(|i| i.is_some()).count();
        let mut map = serializer.serialize_map(Some(entry_count))?;
        for (i, style) in self.ansi_styles.iter().enumerate() {
            let highlight = Highlight::from_usize(i).unwrap();
            if highlight == Highlight::Unknown {
                break;
            }
            if let Some(style) = style {
                let color = style.foreground.map(|color| match color {
                    Color::Black => json!("black"),
                    Color::Blue => json!("blue"),
                    Color::Cyan => json!("cyan"),
                    Color::Green => json!("green"),
                    Color::Purple => json!("purple"),
                    Color::Red => json!("red"),
                    Color::White => json!("white"),
                    Color::Yellow => json!("yellow"),
                    Color::RGB(r, g, b) => json!(format!("#{:x?}{:x?}{:x?}", r, g, b)),
                    Color::Fixed(n) => json!(n),
                });
                if style.is_bold || style.is_italic || style.is_underline {
                    let mut entry = HashMap::new();
                    if let Some(color) = color {
                        entry.insert("color", color);
                    }
                    if style.is_bold {
                        entry.insert("bold", Value::Bool(true));
                    }
                    if style.is_italic {
                        entry.insert("italic", Value::Bool(true));
                    }
                    if style.is_underline {
                        entry.insert("underline", Value::Bool(true));
                    }
                    map.serialize_entry(&highlight, &entry)?;
                } else if let Some(color) = color {
                    map.serialize_entry(&highlight, &color)?;
                } else {
                    map.serialize_entry(&highlight, &Value::Null)?;
                }
            } else {
                map.serialize_entry(&highlight, &Value::Null)?;
            }
        }
        map.end()
    }
}

impl Default for Theme {
    fn default() -> Self {
        serde_json::from_str(
            r#"
            {
              "attribute": {"color": 124, "italic": true},
              "comment": {"color": 245, "italic": true},
              "constant.builtin": {"color": 94, "bold": true},
              "constant": 94,
              "constructor": 136,
              "embedded": null,
              "function.builtin": {"color": 26, "bold": true},
              "function": 26,
              "keyword": 56,
              "number": {"color": 94, "bold": true},
              "property": 124,
              "operator": {"color": 239, "bold": true},
              "punctuation.bracket": 239,
              "punctuation.delimiter": 239,
              "string.special": 30,
              "string": 28,
              "tag": 18,
              "type": 23,
              "type.builtin": {"color": 23, "bold": true},
              "variable.builtin": {"bold": true},
              "variable.parameter": {"underline": true}
            }
            "#,
        )
        .unwrap()
    }
}

impl fmt::Debug for Theme {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{{")?;
        let mut first = true;
        for (i, style) in self.ansi_styles.iter().enumerate() {
            if let Some(style) = style {
                let highlight = Highlight::from_usize(i).unwrap();
                if !first {
                    write!(f, ", ")?;
                }
                write!(f, "{:?}: {:?}", highlight, style)?;
                first = false;
            }
        }
        write!(f, "}}")?;
        Ok(())
    }
}

fn parse_style(style: &mut Style, json: Value) {
    if let Value::Object(entries) = json {
        for (property_name, value) in entries {
            match property_name.as_str() {
                "bold" => *style = style.bold(),
                "italic" => *style = style.italic(),
                "underline" => *style = style.underline(),
                "color" => {
                    if let Some(color) = parse_color(value) {
                        *style = style.fg(color);
                    }
                }
                _ => {}
            }
        }
    } else if let Some(color) = parse_color(json) {
        *style = style.fg(color);
    }
}

fn parse_color(json: Value) -> Option<Color> {
    match json {
        Value::Number(n) => match n.as_u64() {
            Some(n) => Some(Color::Fixed(n as u8)),
            _ => None,
        },
        Value::String(s) => match s.to_lowercase().as_str() {
            "black" => Some(Color::Black),
            "blue" => Some(Color::Blue),
            "cyan" => Some(Color::Cyan),
            "green" => Some(Color::Green),
            "purple" => Some(Color::Purple),
            "red" => Some(Color::Red),
            "white" => Some(Color::White),
            "yellow" => Some(Color::Yellow),
            s => {
                if s.starts_with("#") && s.len() >= 7 {
                    if let (Ok(red), Ok(green), Ok(blue)) = (
                        u8::from_str_radix(&s[1..3], 16),
                        u8::from_str_radix(&s[3..5], 16),
                        u8::from_str_radix(&s[5..7], 16),
                    ) {
                        Some(Color::RGB(red, green, blue))
                    } else {
                        None
                    }
                } else {
                    None
                }
            }
        },
        _ => None,
    }
}

fn style_to_css(style: Style) -> String {
    use std::fmt::Write;
    let mut result = "style='".to_string();
    if style.is_bold {
        write!(&mut result, "font-weight: bold;").unwrap();
    }
    if style.is_italic {
        write!(&mut result, "font-style: italic;").unwrap();
    }
    if let Some(color) = style.foreground {
        write!(&mut result, "color: {};", color_to_css(color)).unwrap();
    }
    result.push('\'');
    result
}

fn color_to_css(color: Color) -> &'static str {
    match color {
        Color::Black => "black",
        Color::Blue => "blue",
        Color::Red => "red",
        Color::Green => "green",
        Color::Yellow => "yellow",
        Color::Cyan => "cyan",
        Color::Purple => "purple",
        Color::White => "white",
        Color::Fixed(n) => CSS_STYLES_BY_COLOR_ID[n as usize].as_str(),
        _ => panic!("Unsupported color type"),
    }
}

pub fn ansi(
    loader: &Loader,
    theme: &Theme,
    source: &[u8],
    language: Language,
    property_sheet: &PropertySheet<Properties>,
    print_time: bool,
) -> Result<()> {
    use std::io::Write;
    let stdout = io::stdout();
    let mut stdout = stdout.lock();

    let time = Instant::now();
    let mut highlight_stack = Vec::new();
    for event in highlight(source, language, property_sheet, |s| {
        language_for_injection_string(loader, s)
    })? {
        match event {
            HighlightEvent::Source(s) => {
                if let Some(style) = highlight_stack.last().and_then(|s| theme.ansi_style(*s)) {
                    write!(&mut stdout, "{}", style.paint(s))?;
                } else {
                    write!(&mut stdout, "{}", s)?;
                }
            }
            HighlightEvent::HighlightStart(h) => {
                highlight_stack.push(h);
            }
            HighlightEvent::HighlightEnd => {
                highlight_stack.pop();
            }
        }
    }

    if print_time {
        let duration = time.elapsed();
        let duration_ms = duration.as_secs() * 1000 + duration.subsec_nanos() as u64 / 1000000;
        eprintln!("{} ms", duration_ms);
    }

    Ok(())
}

pub const HTML_HEADER: &'static str = "
<!doctype HTML>
<head>
  <title>Tree-sitter Highlighting</title>
  <style>
    body {
      font-family: monospace
    }
    .line-number {
      user-select: none;
      text-align: right;
      color: rgba(27,31,35,.3);
      padding: 0 10px;
    }
    .line {
      white-space: pre;
    }
  </style>
</head>
<body>
";

pub const HTML_FOOTER: &'static str = "
</body>
";

pub fn html(
    loader: &Loader,
    theme: &Theme,
    source: &[u8],
    language: Language,
    property_sheet: &PropertySheet<Properties>,
) -> Result<()> {
    use std::io::Write;
    let stdout = io::stdout();
    let mut stdout = stdout.lock();
    write!(&mut stdout, "<table>\n")?;
    let lines = highlight_html(
        source,
        language,
        property_sheet,
        |s| language_for_injection_string(loader, s),
        |highlight| {
            if let Some(css_style) = theme.css_style(highlight) {
                css_style
            } else {
                ""
            }
        },
    )?;
    for (i, line) in lines.into_iter().enumerate() {
        write!(
            &mut stdout,
            "<tr><td class=line-number>{}</td><td class=line>{}</td></tr>\n",
            i + 1,
            line
        )?;
    }
    write!(&mut stdout, "</table>\n")?;
    Ok(())
}

fn language_for_injection_string<'a>(
    loader: &'a Loader,
    string: &str,
) -> Option<(Language, &'a PropertySheet<Properties>)> {
    match loader.language_configuration_for_injection_string(string) {
        Err(message) => {
            eprintln!(
                "Failed to load language for injection string '{}': {}",
                string, message.0
            );
            None
        }
        Ok(None) => None,
        Ok(Some((language, configuration))) => {
            match configuration.highlight_property_sheet(language) {
                Err(message) => {
                    eprintln!(
                        "Failed to load property sheet for injection string '{}': {}",
                        string, message.0
                    );
                    None
                }
                Ok(None) => None,
                Ok(Some(sheet)) => Some((language, sheet)),
            }
        }
    }
}