/*
    * syntax.hpp
    * Syntax highlighting core: token types, state, shared scanners
    * Shared by the MontaukOS text editor (GUI) and edit.elf (CLI)
    * Copyright (c) 2026 Daniel Hammer
*/

// The highlighter turns one line of text into a SynToken per character while
// carrying multi-line state (block comments, HTML tag context, ...) forward
// in a SynState. Frontends map SynToken to their own colors: the GUI editor
// to a Color, edit.elf to an ANSI escape.
//
// Callers include THIS header only; the per-language lang_*.hpp files below
// are not standalone (they rely on the declarations above their include).

#pragma once

#include <stdint.h>

// ============================================================================
// Token types
// ============================================================================

enum SynLanguage : uint8_t {
    SYN_LANG_NONE,
    SYN_LANG_C,
    SYN_LANG_CPP,
    SYN_LANG_LUA,
    SYN_LANG_HTML,
    SYN_LANG_CSS,
    SYN_LANG_JS,
};

enum SynToken : uint8_t {
    SYN_NORMAL,
    SYN_KEYWORD,
    SYN_TYPE,
    SYN_PREPROCESSOR,
    SYN_STRING,
    SYN_CHAR,
    SYN_COMMENT,
    SYN_NUMBER,
    SYN_OPERATOR,
};

#define SYN_RAW_DELIM_MAX 16

// Where an HTML line starts: plain text, inside a tag, inside a comment, or
// inside a <script>/<style> raw-text body.
enum SynHtmlCtx : uint8_t {
    SYN_HTML_TEXT,
    SYN_HTML_TAG,
    SYN_HTML_COMMENT,
    SYN_HTML_SCRIPT,
    SYN_HTML_STYLE,
};

struct SynState {
    int in_block_comment;    // 0 or 1 (bool stored as int for freestanding)
    SynToken long_token;
    int long_bracket_eqs;
    bool in_raw_string;
    char raw_delim[SYN_RAW_DELIM_MAX];
    int raw_delim_len;
    uint8_t html_ctx;       // SynHtmlCtx
    uint8_t html_pending;   // context to enter once the open tag closes
    char html_quote;        // attribute value quote left open on this line
    uint8_t css_depth;      // brace nesting, to tell selectors from properties
    uint8_t css_in_value;   // between ':' and ';' inside a declaration
};

// ============================================================================
// Helpers
// ============================================================================

inline bool syn_is_alpha(char c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
}

inline bool syn_is_alnum(char c) {
    return syn_is_alpha(c) || (c >= '0' && c <= '9');
}

inline bool syn_is_digit(char c) {
    return c >= '0' && c <= '9';
}

inline bool syn_is_hex(char c) {
    return syn_is_digit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
}

inline void syn_set_token(SynToken* out, int out_len, int idx, SynToken tok) {
    if (out && idx >= 0 && idx < out_len)
        out[idx] = tok;
}

inline void syn_fill_tokens(SynToken* out, int out_len, int start, int end, SynToken tok) {
    if (!out) return;
    if (start < 0) start = 0;
    if (end > out_len) end = out_len;
    for (int i = start; i < end; i++)
        out[i] = tok;
}

inline bool syn_streq(const char* buf, int len, const char* kw) {
    int i = 0;
    while (i < len && kw[i]) {
        if (buf[i] != kw[i]) return false;
        i++;
    }
    return i == len && kw[i] == '\0';
}

inline char syn_lower(char c) {
    return (c >= 'A' && c <= 'Z') ? (char)(c + 32) : c;
}

// Case-insensitive literal match at line[i]
inline bool syn_match_ci(const char* line, int len, int i, const char* s) {
    int k = 0;
    while (s[k]) {
        if (i + k >= len) return false;
        if (syn_lower(line[i + k]) != syn_lower(s[k])) return false;
        k++;
    }
    return true;
}

inline SynState syn_make_state() {
    SynState state = {};
    state.in_block_comment = 0;
    state.long_token = SYN_NORMAL;
    state.long_bracket_eqs = -1;
    state.in_raw_string = false;
    state.raw_delim_len = 0;
    state.html_ctx = SYN_HTML_TEXT;
    state.html_pending = SYN_HTML_TEXT;
    state.html_quote = 0;
    state.css_depth = 0;
    state.css_in_value = 0;
    return state;
}

// ============================================================================
// Number consumption
// ============================================================================

inline void syn_scan_digits(const char* line, int len, int& i, bool sep, bool hex) {
    while (i < len) {
        if (hex ? syn_is_hex(line[i]) : syn_is_digit(line[i])) { i++; continue; }
        // C++14 digit separator: a quote wedged between two digits
        if (sep && line[i] == '\'' && i + 1 < len &&
            (hex ? syn_is_hex(line[i + 1]) : syn_is_digit(line[i + 1]))) {
            i += 2;
            continue;
        }
        break;
    }
}

inline void syn_consume_number(const char* line, int len, int& i,
                               SynToken* out, int out_len, bool c_style_suffixes,
                               bool digit_sep = false) {
    int start = i;

    if (line[i] == '0' && i + 1 < len && (line[i + 1] == 'x' || line[i + 1] == 'X')) {
        i += 2;
        syn_scan_digits(line, len, i, digit_sep, true);
        if (i < len && line[i] == '.' && !(i + 1 < len && line[i + 1] == '.')) {
            i++;
            syn_scan_digits(line, len, i, digit_sep, true);
        }
        if (i < len && (line[i] == 'p' || line[i] == 'P')) {
            int exp = i + 1;
            if (exp < len && (line[exp] == '+' || line[exp] == '-')) exp++;
            if (exp < len && syn_is_digit(line[exp])) {
                i = exp;
                syn_scan_digits(line, len, i, digit_sep, false);
            }
        }
    } else {
        if (line[i] == '.') i++;
        syn_scan_digits(line, len, i, digit_sep, false);
        if (i < len && line[i] == '.' && !(i + 1 < len && line[i + 1] == '.')) {
            i++;
            syn_scan_digits(line, len, i, digit_sep, false);
        }
        if (i < len && (line[i] == 'e' || line[i] == 'E')) {
            int exp = i + 1;
            if (exp < len && (line[exp] == '+' || line[exp] == '-')) exp++;
            if (exp < len && syn_is_digit(line[exp])) {
                i = exp;
                syn_scan_digits(line, len, i, digit_sep, false);
            }
        }
    }

    if (c_style_suffixes) {
        while (i < len && (line[i] == 'u' || line[i] == 'U' ||
                           line[i] == 'l' || line[i] == 'L' ||
                           line[i] == 'f' || line[i] == 'F' ||
                           line[i] == 'z' || line[i] == 'Z'))
            i++;
    }

    syn_fill_tokens(out, out_len, start, i, SYN_NUMBER);
}

// Defined below, once every language's classifier is in scope
inline SynToken syn_classify_word(SynLanguage lang, const char* buf, int len);

#include <syntax/lang_c.hpp>
#include <syntax/lang_lua.hpp>
#include <syntax/lang_html.hpp>

// ============================================================================
// Word classification
// ============================================================================

inline SynToken syn_classify_word(SynLanguage lang, const char* buf, int len) {
    switch (lang) {
    case SYN_LANG_C:   return syn_classify_c_word(buf, len);
    case SYN_LANG_CPP: return syn_classify_cpp_word(buf, len);
    case SYN_LANG_LUA: return syn_classify_lua_word(buf, len);
    case SYN_LANG_JS:  return syn_classify_js_word(buf, len);
    default:           return SYN_NORMAL;
    }
}

inline void syn_highlight_line(const char* line, int len, SynToken* out, int out_len,
                               SynLanguage lang, SynState& state) {
    if (!line || len <= 0) return;
    switch (lang) {
    case SYN_LANG_C:
    case SYN_LANG_CPP:
        syn_highlight_line_c(line, len, out, out_len, state, lang);
        break;
    case SYN_LANG_LUA:
        syn_highlight_line_lua(line, len, out, out_len, state);
        break;
    case SYN_LANG_HTML:
        syn_highlight_line_html(line, len, out, out_len, state);
        break;
    case SYN_LANG_CSS: {
        int i = 0;
        syn_highlight_css_range(line, len, i, out, out_len, state);
        break;
    }
    case SYN_LANG_JS: {
        int i = 0;
        syn_highlight_js_range(line, len, i, out, out_len, state);
        break;
    }
    default:
        syn_fill_tokens(out, out_len, 0, len, SYN_NORMAL);
        break;
    }
}

// ============================================================================
// Language detection
// ============================================================================

inline bool syn_path_ends_with(const char* path, const char* suffix) {
    if (!path || !suffix) return false;
    int path_len = 0;
    while (path[path_len]) path_len++;
    int suffix_len = 0;
    while (suffix[suffix_len]) suffix_len++;
    if (path_len < suffix_len) return false;
    for (int i = 0; i < suffix_len; i++) {
        if (path[path_len - suffix_len + i] != suffix[i])
            return false;
    }
    return true;
}

inline SynLanguage syn_detect_language(const char* filepath) {
    if (!filepath || filepath[0] == '\0') return SYN_LANG_NONE;
    if (syn_path_ends_with(filepath, ".cpp") || syn_path_ends_with(filepath, ".cc") ||
        syn_path_ends_with(filepath, ".cxx") || syn_path_ends_with(filepath, ".c++") ||
        syn_path_ends_with(filepath, ".hpp") || syn_path_ends_with(filepath, ".hh") ||
        syn_path_ends_with(filepath, ".hxx") || syn_path_ends_with(filepath, ".h++") ||
        syn_path_ends_with(filepath, ".ipp") || syn_path_ends_with(filepath, ".tpp") ||
        syn_path_ends_with(filepath, ".inl"))
        return SYN_LANG_CPP;
    if (syn_path_ends_with(filepath, ".c") || syn_path_ends_with(filepath, ".h"))
        return SYN_LANG_C;
    if (syn_path_ends_with(filepath, ".lua"))
        return SYN_LANG_LUA;
    if (syn_path_ends_with(filepath, ".html") || syn_path_ends_with(filepath, ".htm") ||
        syn_path_ends_with(filepath, ".xhtml"))
        return SYN_LANG_HTML;
    if (syn_path_ends_with(filepath, ".css"))
        return SYN_LANG_CSS;
    if (syn_path_ends_with(filepath, ".js") || syn_path_ends_with(filepath, ".mjs"))
        return SYN_LANG_JS;
    return SYN_LANG_NONE;
}