use std::borrow::Cow;
use std::cell::RefCell;

use nu_ansi_term::{Color as AnsiColor, Style};
use reedline::{
    Color, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, Reedline, StyledText,
    ValidationResult,
};
use tree_sitter_highlight::{Highlight, HighlightConfiguration, HighlightEvent};

pub(super) fn create() -> Reedline {
    Reedline::create()
        .with_highlighter(Box::new(Highlighter::new()))
        .with_validator(Box::new(Validator))
}

pub(super) struct Prompt;

impl reedline::Prompt for Prompt {
    fn render_prompt_left(&self) -> Cow<'_, str> {
        Cow::Borrowed("")
    }

    fn render_prompt_right(&self) -> Cow<'_, str> {
        Cow::Borrowed("")
    }

    fn render_prompt_indicator(&self, _mode: PromptEditMode) -> Cow<'_, str> {
        Cow::Borrowed("> ")
    }

    fn render_prompt_multiline_indicator(&self) -> Cow<'_, str> {
        Cow::Borrowed("… ")
    }

    fn render_prompt_history_search_indicator(&self, search: PromptHistorySearch) -> Cow<'_, str> {
        let failing = match search.status {
            PromptHistorySearchStatus::Passing => "",
            PromptHistorySearchStatus::Failing => "failing ",
        };
        Cow::Owned(format!("({failing}reverse-search: {}) ", search.term))
    }

    fn get_indicator_color(&self) -> Color {
        Color::Green
    }

    fn get_prompt_multiline_color(&self) -> AnsiColor {
        AnsiColor::DarkGray
    }
}

struct Validator;

impl reedline::Validator for Validator {
    fn validate(&self, line: &str) -> ValidationResult {
        if super::is_incomplete(&format!("{line}\n")) {
            ValidationResult::Incomplete
        } else {
            ValidationResult::Complete
        }
    }
}

struct Highlighter {
    config: HighlightConfiguration,
    styles: Vec<Style>,
    highlighter: RefCell<tree_sitter_highlight::Highlighter>,
}

impl Highlighter {
    fn new() -> Self {
        // Plain ANSI colors so the terminal's own palette decides how they look.
        let theme = [
            ("comment", Style::new().fg(AnsiColor::DarkGray)),
            ("keyword", Style::new().fg(AnsiColor::Purple)),
            ("string", Style::new().fg(AnsiColor::Green)),
            ("string.special", Style::new().fg(AnsiColor::Red)),
            ("number", Style::new().fg(AnsiColor::Yellow)),
            ("constant.builtin", Style::new().fg(AnsiColor::Yellow)),
            ("function", Style::new().fg(AnsiColor::Blue)),
            ("constructor", Style::new().fg(AnsiColor::Cyan)),
            ("variable.builtin", Style::new().fg(AnsiColor::Red)),
            ("embedded", Style::new()),
        ];
        let mut config = HighlightConfiguration::new(
            tree_sitter_javascript::LANGUAGE.into(),
            "javascript",
            tree_sitter_javascript::HIGHLIGHT_QUERY,
            "",
            tree_sitter_javascript::LOCALS_QUERY,
        )
        .expect("bundled JavaScript highlight queries are valid");
        config.configure(&theme.map(|(name, _)| name));
        Self {
            config,
            styles: theme.map(|(_, style)| style).to_vec(),
            highlighter: RefCell::new(tree_sitter_highlight::Highlighter::new()),
        }
    }
}

impl reedline::Highlighter for Highlighter {
    fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
        let mut text = StyledText::new();
        let mut highlighter = self.highlighter.borrow_mut();
        let events = highlighter
            .highlight(&self.config, line.as_bytes(), None, None, |_| None)
            .and_then(|events| events.collect::<Result<Vec<_>, _>>());
        let Ok(events) = events else {
            text.push((Style::new(), line.to_owned()));
            return text;
        };
        let mut styles = Vec::new();
        for event in events {
            match event {
                HighlightEvent::HighlightStart(Highlight(index)) => {
                    styles.push(self.styles[index]);
                }
                HighlightEvent::HighlightEnd => {
                    styles.pop();
                }
                HighlightEvent::Source { start, end } => {
                    let style = styles.last().copied().unwrap_or_default();
                    text.push((style, line[start..end].to_owned()));
                }
            }
        }
        text
    }
}

#[cfg(test)]
mod tests {
    use super::Highlighter;
    use nu_ansi_term::Style;
    use reedline::Highlighter as _;

    fn style_of(line: &str, fragment: &str) -> Style {
        let text = Highlighter::new().highlight(line, 0);
        text.buffer
            .iter()
            .find(|(_, text)| text.contains(fragment))
            .unwrap_or_else(|| panic!("{fragment:?} is not in {line:?}"))
            .0
    }

    #[test]
    fn highlighting_preserves_partial_and_unicode_input() {
        let highlighter = Highlighter::new();
        for line in [
            "",
            "const café = \"☕\" +",
            "function greet() {\n  return `hi ${name",
            "/* unterminated",
            "import * as TID from \"jsr:@atcute/tid\"",
            ")}]",
        ] {
            assert_eq!(highlighter.highlight(line, 0).raw_string(), line);
        }
    }

    #[test]
    fn literals_and_keywords_are_distinguished_from_identifiers() {
        let line = "const answer = \"forty\" + 2";
        let plain = style_of(line, "answer");
        assert_ne!(style_of(line, "const"), plain);
        assert_ne!(style_of(line, "\"forty\""), plain);
        assert_ne!(style_of(line, "2"), plain);
    }

    #[test]
    fn template_substitutions_are_not_styled_as_strings() {
        let line = "`total: ${count}`";
        assert_ne!(style_of(line, "count"), style_of(line, "`total: "));
    }
}