//! Syntax highlighting for the response and body views.
//!
//! A hand-rolled tokenizer rather than a syntax-definition crate: cielago only
//! ever shows JSON, the occasional XML/HTML error page, and plain text, and
//! `syntect`-class dependencies dwarf the rest of the binary.
//!
//! Highlighting is line-oriented — every token type here (JSON strings
//! included, since they cannot contain a raw newline) starts and ends on one
//! line — so a line can be rendered without scanning the ones before it.

use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Syntax {
    Json,
    Xml,
    Plain,
}

/// Guess the syntax from the first non-blank character, the same way
/// [`crate::app`] picks a temp-file extension for `$EDITOR`.
pub fn detect(text: &str) -> Syntax {
    match text.trim_start().chars().next() {
        Some('{') | Some('[') => Syntax::Json,
        Some('<') => Syntax::Xml,
        _ => Syntax::Plain,
    }
}

const KEY: Color = Color::Cyan;
const STRING: Color = Color::Green;
const NUMBER: Color = Color::Yellow;
const LITERAL: Color = Color::Magenta;
const PUNCT: Color = Color::DarkGray;
const TAG: Color = Color::Blue;

/// Highlight `text`, one [`Line`] per input line.
///
/// `marks_vars` additionally paints `{{variable}}` placeholders — wanted in the
/// request body, where they are live template syntax, but not in a response,
/// where the same braces are just bytes the server sent.
pub fn highlight(text: &str, marks_vars: bool) -> Vec<Line<'static>> {
    let syntax = detect(text);
    text.split('\n')
        .map(|line| match syntax {
            Syntax::Json => json_line(line, marks_vars),
            Syntax::Xml => xml_line(line, marks_vars),
            Syntax::Plain => {
                let mut spans = Vec::new();
                push_text(&mut spans, line, Style::default(), marks_vars);
                Line::from(spans)
            }
        })
        .collect()
}

// ----- JSON -----

fn json_line(line: &str, marks_vars: bool) -> Line<'static> {
    let chars: Vec<char> = line.chars().collect();
    let mut spans: Vec<Span<'static>> = Vec::new();
    let mut i = 0;

    while i < chars.len() {
        let c = chars[i];
        match c {
            '"' => {
                let start = i;
                i = end_of_string(&chars, i);
                // A string followed by `:` is an object key.
                let is_key = chars[i..]
                    .iter()
                    .find(|c| !c.is_whitespace())
                    .is_some_and(|c| *c == ':');
                let color = if is_key { KEY } else { STRING };
                let text: String = chars[start..i].iter().collect();
                push_text(&mut spans, &text, Style::default().fg(color), marks_vars);
            }
            '-' | '0'..='9' => {
                let start = i;
                while i < chars.len() && is_number_char(chars[i]) {
                    i += 1;
                }
                spans.push(span(&chars[start..i], NUMBER));
            }
            c if c.is_ascii_alphabetic() => {
                let start = i;
                while i < chars.len() && chars[i].is_ascii_alphanumeric() {
                    i += 1;
                }
                let word: String = chars[start..i].iter().collect();
                let color = match word.as_str() {
                    "true" | "false" | "null" => LITERAL,
                    _ => Color::Reset,
                };
                spans.push(Span::styled(word, Style::default().fg(color)));
            }
            '{' | '}' | '[' | ']' | ',' | ':' => {
                let start = i;
                i += 1;
                spans.push(span(&chars[start..i], PUNCT));
            }
            _ => {
                let start = i;
                i += 1;
                spans.push(Span::raw(chars[start..i].iter().collect::<String>()));
            }
        }
    }
    Line::from(spans)
}

/// Index just past the closing quote of the string starting at `i`, or the end
/// of the line for an unterminated one.
fn end_of_string(chars: &[char], i: usize) -> usize {
    let mut i = i + 1;
    while i < chars.len() {
        match chars[i] {
            '\\' => i += 2,
            '"' => return (i + 1).min(chars.len()),
            _ => i += 1,
        }
    }
    chars.len()
}

fn is_number_char(c: char) -> bool {
    c.is_ascii_digit() || matches!(c, '-' | '+' | '.' | 'e' | 'E')
}

// ----- XML / HTML -----

/// Markup is coloured structurally: everything between `<` and `>` is a tag,
/// with its name, attribute names and quoted values distinguished; anything
/// else is text.
fn xml_line(line: &str, marks_vars: bool) -> Line<'static> {
    let chars: Vec<char> = line.chars().collect();
    let mut spans: Vec<Span<'static>> = Vec::new();
    let mut i = 0;

    while i < chars.len() {
        if chars[i] != '<' {
            let start = i;
            while i < chars.len() && chars[i] != '<' {
                i += 1;
            }
            let text: String = chars[start..i].iter().collect();
            push_text(&mut spans, &text, Style::default(), marks_vars);
            continue;
        }

        // `<` … `>`: opening punctuation plus the tag name, then attributes.
        let start = i;
        i += 1;
        while i < chars.len() && matches!(chars[i], '/' | '!' | '?') {
            i += 1;
        }
        while i < chars.len() && !chars[i].is_whitespace() && !matches!(chars[i], '>' | '/') {
            i += 1;
        }
        spans.push(span(&chars[start..i], TAG));

        while i < chars.len() && chars[i] != '>' {
            match chars[i] {
                '"' | '\'' => {
                    let quote = chars[i];
                    let start = i;
                    i += 1;
                    while i < chars.len() && chars[i] != quote {
                        i += 1;
                    }
                    i = (i + 1).min(chars.len());
                    let text: String = chars[start..i].iter().collect();
                    push_text(&mut spans, &text, Style::default().fg(STRING), marks_vars);
                }
                c if c.is_whitespace() || c == '=' || c == '/' => {
                    let start = i;
                    i += 1;
                    spans.push(span(&chars[start..i], PUNCT));
                }
                _ => {
                    let start = i;
                    while i < chars.len()
                        && !chars[i].is_whitespace()
                        && !"=>/\"'".contains(chars[i])
                    {
                        i += 1;
                    }
                    spans.push(span(&chars[start..i], KEY));
                }
            }
        }
        if i < chars.len() {
            spans.push(span(&chars[i..i + 1], TAG));
            i += 1;
        }
    }
    Line::from(spans)
}

// ----- shared -----

fn span(chars: &[char], color: Color) -> Span<'static> {
    Span::styled(chars.iter().collect::<String>(), Style::default().fg(color))
}

/// Push `text` in `style`, breaking out `{{variable}}` placeholders when
/// `marks_vars` is set so template syntax stands out from literal content.
fn push_text(spans: &mut Vec<Span<'static>>, text: &str, style: Style, marks_vars: bool) {
    if text.is_empty() {
        return;
    }
    if !marks_vars {
        spans.push(Span::styled(text.to_string(), style));
        return;
    }
    let var_style = Style::default()
        .fg(LITERAL)
        .add_modifier(Modifier::BOLD | Modifier::ITALIC);
    let mut rest = text;
    while let Some(start) = rest.find("{{") {
        let Some(end) = rest[start + 2..].find("}}") else {
            break;
        };
        if start > 0 {
            spans.push(Span::styled(rest[..start].to_string(), style));
        }
        let stop = start + 2 + end + 2;
        spans.push(Span::styled(rest[start..stop].to_string(), var_style));
        rest = &rest[stop..];
    }
    if !rest.is_empty() {
        spans.push(Span::styled(rest.to_string(), style));
    }
}

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

    /// (text, fg colour) pairs, for asserting on what a line renders as.
    fn tokens(line: &Line<'static>) -> Vec<(String, Option<Color>)> {
        line.spans
            .iter()
            .map(|s| (s.content.to_string(), s.style.fg))
            .collect()
    }

    fn colored(line: &Line<'static>, text: &str) -> Option<Color> {
        tokens(line)
            .into_iter()
            .find(|(t, _)| t == text)
            .and_then(|(_, c)| c)
    }

    #[test]
    fn detects_syntax_from_first_char() {
        assert_eq!(detect("  {\"a\": 1}"), Syntax::Json);
        assert_eq!(detect("[1]"), Syntax::Json);
        assert_eq!(detect("<html>"), Syntax::Xml);
        assert_eq!(detect("plain words"), Syntax::Plain);
        assert_eq!(detect(""), Syntax::Plain);
    }

    #[test]
    fn json_keys_and_values_differ() {
        let lines = highlight(
            "{\n  \"name\": \"ada\",\n  \"n\": -1.5e3,\n  \"ok\": true\n}",
            false,
        );
        assert_eq!(lines.len(), 5);
        assert_eq!(colored(&lines[1], "\"name\""), Some(KEY));
        assert_eq!(colored(&lines[1], "\"ada\""), Some(STRING));
        assert_eq!(colored(&lines[2], "-1.5e3"), Some(NUMBER));
        assert_eq!(colored(&lines[3], "true"), Some(LITERAL));
        assert_eq!(colored(&lines[0], "{"), Some(PUNCT));
    }

    #[test]
    fn json_strings_keep_escapes_and_colons_inside() {
        let lines = highlight("{\"a\": \"x\\\": y\"}", false);
        assert_eq!(colored(&lines[0], "\"a\""), Some(KEY));
        // The escaped quote must not end the string early, and the `:` inside
        // it must not promote the value to a key.
        assert_eq!(colored(&lines[0], "\"x\\\": y\""), Some(STRING));
    }

    #[test]
    fn unterminated_json_string_does_not_panic() {
        let lines = highlight("{\"a\": \"oops", false);
        assert_eq!(colored(&lines[0], "\"oops"), Some(STRING));
    }

    #[test]
    fn every_character_survives_highlighting() {
        for text in [
            "{\"a\": [1, 2, {\"b\": null}], \"c\": \"é☃\"}",
            "<a href=\"/x\">hi &amp; bye</a>",
            "not markup at all",
        ] {
            let rendered: String = highlight(text, true)
                .iter()
                .map(|l| {
                    l.spans
                        .iter()
                        .map(|s| s.content.as_ref())
                        .collect::<String>()
                })
                .collect::<Vec<_>>()
                .join("\n");
            assert_eq!(rendered, text);
        }
    }

    #[test]
    fn xml_tags_attributes_and_text() {
        let lines = highlight("<a href=\"/x\">hi</a>", false);
        assert_eq!(colored(&lines[0], "<a"), Some(TAG));
        assert_eq!(colored(&lines[0], "href"), Some(KEY));
        assert_eq!(colored(&lines[0], "\"/x\""), Some(STRING));
        assert_eq!(colored(&lines[0], "hi"), None);
        assert_eq!(colored(&lines[0], "</a"), Some(TAG));
    }

    #[test]
    fn variables_are_marked_only_when_asked() {
        let body = "{\"id\": \"{{uuid}}\"}";
        let marked = highlight(body, true);
        assert_eq!(colored(&marked[0], "{{uuid}}"), Some(LITERAL));
        assert_eq!(colored(&marked[0], "\""), Some(STRING));

        let plain = highlight(body, false);
        assert_eq!(colored(&plain[0], "\"{{uuid}}\""), Some(STRING));
    }

    #[test]
    fn unclosed_variable_is_left_alone() {
        let lines = highlight("value {{oops", true);
        assert_eq!(tokens(&lines[0]).len(), 1);
    }
}