const std = @import("std");
const ui = @import("ui");
const app_config = @import("app_config");
const ghostty_vt = @import("ghostty-vt");
const syntax_highlighting = app_config.syntax_highlighting;
const syntax_minimal_grammars = app_config.syntax_minimal_grammars;
const syntax_full_grammars = app_config.syntax_full_grammars;
const ts = if (syntax_highlighting) @import("tree-sitter") else struct {
    pub const Language = opaque {};
};
const ts_queries = if (syntax_highlighting) @import("ts_queries") else struct {};

extern fn tree_sitter_ada() callconv(.c) *const ts.Language;
extern fn tree_sitter_bash() callconv(.c) *const ts.Language;
extern fn tree_sitter_c() callconv(.c) *const ts.Language;
extern fn tree_sitter_c_sharp() callconv(.c) *const ts.Language;
extern fn tree_sitter_clojure() callconv(.c) *const ts.Language;
extern fn tree_sitter_cpp() callconv(.c) *const ts.Language;
extern fn tree_sitter_css() callconv(.c) *const ts.Language;
extern fn tree_sitter_elixir() callconv(.c) *const ts.Language;
extern fn tree_sitter_erlang() callconv(.c) *const ts.Language;
extern fn tree_sitter_fortran() callconv(.c) *const ts.Language;
extern fn tree_sitter_go() callconv(.c) *const ts.Language;
extern fn tree_sitter_haskell() callconv(.c) *const ts.Language;
extern fn tree_sitter_html() callconv(.c) *const ts.Language;
extern fn tree_sitter_java() callconv(.c) *const ts.Language;
extern fn tree_sitter_javascript() callconv(.c) *const ts.Language;
extern fn tree_sitter_json() callconv(.c) *const ts.Language;
extern fn tree_sitter_kotlin() callconv(.c) *const ts.Language;
extern fn tree_sitter_ocaml() callconv(.c) *const ts.Language;
extern fn tree_sitter_pascal() callconv(.c) *const ts.Language;
extern fn tree_sitter_php() callconv(.c) *const ts.Language;
extern fn tree_sitter_powershell() callconv(.c) *const ts.Language;
extern fn tree_sitter_python() callconv(.c) *const ts.Language;
extern fn tree_sitter_ruby() callconv(.c) *const ts.Language;
extern fn tree_sitter_rust() callconv(.c) *const ts.Language;
extern fn tree_sitter_scala() callconv(.c) *const ts.Language;
extern fn tree_sitter_zig() callconv(.c) *const ts.Language;

pub const accent = if (app_config.app_kind == .replay) [3]u8{ 0xc8, 0x58, 0x58 } else [3]u8{ 0x6e, 0x4f, 0xd0 };
pub const accent_dim = if (app_config.app_kind == .replay) [3]u8{ 0x54, 0x38, 0x38 } else [3]u8{ 0x38, 0x3c, 0x54 };
const dark_tag_bg = if (app_config.app_kind == .replay) [3]u8{ 0x3e, 0x2a, 0x2a } else [3]u8{ 0x2c, 0x2a, 0x3e };

pub const Theme = struct {
    name: []const u8,
    bg: ?[3]u8,
    fg: ?[3]u8,
    tag_bg: [3]u8,
    tag_fg: [3]u8,
    kw: [3]u8,
    str: [3]u8,
    num: [3]u8,
    comment: [3]u8,
    lineno: [3]u8,
    scroll_track: [3]u8,
    scroll_thumb: [3]u8,
    palette: ?[16][3]u8,
};

pub const themes = [_]Theme{
    .{
        .name = "dark",
        .bg = null,
        .fg = null,
        .tag_bg = dark_tag_bg,
        .tag_fg = .{ 0x96, 0x96, 0x96 },
        .kw = .{ 0xcc, 0x70, 0xd8 },
        .str = .{ 0x8a, 0xb8, 0x7a },
        .num = .{ 0xd0, 0xc0, 0x70 },
        .comment = .{ 0xf0, 0xf0, 0xf0 },
        .lineno = .{ 0x5a, 0x5a, 0x5a },
        .scroll_track = .{ 0x2a, 0x2a, 0x2a },
        .scroll_thumb = .{ 0x52, 0x52, 0x52 },
        .palette = null,
    },
    .{
        .name = "acme",
        .bg = .{ 0xff, 0xff, 0xea },
        .fg = .{ 0x00, 0x00, 0x00 },
        .tag_bg = .{ 0xea, 0xff, 0xff },
        .tag_fg = .{ 0x00, 0x00, 0x00 },
        .kw = .{ 0x88, 0x22, 0x99 },
        .str = .{ 0x00, 0x77, 0x33 },
        .num = .{ 0xa0, 0x52, 0x00 },
        .comment = .{ 0x55, 0x55, 0x55 },
        .lineno = .{ 0x99, 0x99, 0x80 },
        .scroll_track = .{ 0x99, 0x99, 0x4c },
        .scroll_thumb = .{ 0xff, 0xff, 0xea },
        .palette = .{
            .{ 0x00, 0x00, 0x00 }, .{ 0xaa, 0x22, 0x22 }, .{ 0x22, 0x80, 0x22 }, .{ 0x88, 0x66, 0x00 },
            .{ 0x22, 0x44, 0xbb }, .{ 0x99, 0x33, 0x99 }, .{ 0x11, 0x88, 0x88 }, .{ 0x55, 0x55, 0x55 },
            .{ 0x88, 0x88, 0x88 }, .{ 0xcc, 0x33, 0x33 }, .{ 0x33, 0xaa, 0x33 }, .{ 0xaa, 0x77, 0x00 },
            .{ 0x33, 0x55, 0xdd }, .{ 0xbb, 0x44, 0xbb }, .{ 0x22, 0xaa, 0xaa }, .{ 0x00, 0x00, 0x00 },
        },
    },
};

var theme_idx: usize = 0;

pub fn T() *const Theme {
    return &themes[theme_idx];
}

pub fn nextTheme() void {
    theme_idx = (theme_idx + 1) % themes.len;
}

pub fn currentThemeName() []const u8 {
    return T().name;
}

pub fn setThemeByName(name: []const u8) bool {
    for (themes, 0..) |theme, i| {
        if (std.mem.eql(u8, theme.name, name)) {
            theme_idx = i;
            return true;
        }
    }
    return false;
}

pub fn rgbColor(c: [3]u8) ui.Color {
    return .{ .rgb = c };
}

pub fn colorOpt(c: ?[3]u8) ui.Color {
    return if (c) |x| .{ .rgb = x } else .default;
}

pub const Syn = enum(u8) { none, keyword, string, number, comment };

pub const SynStyle = struct {
    fg: [3]u8,
    bold: bool,
};

pub fn synStyle(s: Syn) ?SynStyle {
    return switch (s) {
        .none => null,
        .keyword => .{ .fg = T().kw, .bold = true },
        .string => .{ .fg = T().str, .bold = false },
        .number => .{ .fg = T().num, .bold = false },
        .comment => .{ .fg = T().comment, .bold = true },
    };
}

fn synFor(name: []const u8) Syn {
    for ([_]struct { []const u8, Syn }{
        .{ "comment", .comment },
        .{ "string", .string },
        .{ "character", .string },
        .{ "number", .number },
        .{ "float", .number },
        .{ "boolean", .number },
        .{ "keyword", .keyword },
        .{ "include", .keyword },
        .{ "operator", .keyword },
        .{ "conditional", .keyword },
        .{ "repeat", .keyword },
    }) |m| {
        if (std.mem.indexOf(u8, name, m[0]) != null) return m[1];
    }
    return .none;
}

fn extIs(ext: []const u8, comptime choices: anytype) bool {
    inline for (choices) |choice| {
        if (std.ascii.eqlIgnoreCase(ext, choice)) return true;
    }
    return false;
}

pub fn highlightFile(gpa: std.mem.Allocator, path: []const u8, content: []const u8) ![]u8 {
    if (!syntax_highlighting) return &.{};
    const ext = std.fs.path.extension(path);
    const selected = blk: {
        const Selected = struct {
            lang: *const ts.Language,
            query_src: []const u8,
        };

        if (syntax_full_grammars) {
            if (extIs(ext, .{ ".adb", ".ads", ".ada" })) {
                break :blk Selected{ .lang = tree_sitter_ada(), .query_src = ts_queries.ada_highlights };
            } else if (extIs(ext, .{ ".sh", ".bash", ".zsh" })) {
                break :blk Selected{ .lang = tree_sitter_bash(), .query_src = ts_queries.bash_highlights };
            }
        }
        if (syntax_minimal_grammars) {
            if (extIs(ext, .{ ".c", ".h" })) {
                break :blk Selected{ .lang = tree_sitter_c(), .query_src = ts_queries.c_highlights };
            }
        }
        if (syntax_full_grammars) {
            if (extIs(ext, .{ ".cs", ".csx" })) {
                break :blk Selected{ .lang = tree_sitter_c_sharp(), .query_src = ts_queries.c_sharp_highlights };
            } else if (extIs(ext, .{ ".clj", ".cljs", ".cljc", ".edn" })) {
                break :blk Selected{ .lang = tree_sitter_clojure(), .query_src = ts_queries.clojure_highlights };
            }
        }
        if (syntax_minimal_grammars) {
            if (extIs(ext, .{ ".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx" })) {
                break :blk Selected{ .lang = tree_sitter_cpp(), .query_src = ts_queries.cpp_highlights };
            }
        }
        if (syntax_full_grammars) {
            if (extIs(ext, .{".css"})) {
                break :blk Selected{ .lang = tree_sitter_css(), .query_src = ts_queries.css_highlights };
            } else if (extIs(ext, .{ ".ex", ".exs" })) {
                break :blk Selected{ .lang = tree_sitter_elixir(), .query_src = ts_queries.elixir_highlights };
            } else if (extIs(ext, .{ ".erl", ".hrl" })) {
                break :blk Selected{ .lang = tree_sitter_erlang(), .query_src = ts_queries.erlang_highlights };
            } else if (extIs(ext, .{ ".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08" })) {
                break :blk Selected{ .lang = tree_sitter_fortran(), .query_src = ts_queries.fortran_highlights };
            } else if (extIs(ext, .{".go"})) {
                break :blk Selected{ .lang = tree_sitter_go(), .query_src = ts_queries.go_highlights };
            } else if (extIs(ext, .{ ".hs", ".lhs" })) {
                break :blk Selected{ .lang = tree_sitter_haskell(), .query_src = ts_queries.haskell_highlights };
            } else if (extIs(ext, .{ ".html", ".htm" })) {
                break :blk Selected{ .lang = tree_sitter_html(), .query_src = ts_queries.html_highlights };
            } else if (extIs(ext, .{".java"})) {
                break :blk Selected{ .lang = tree_sitter_java(), .query_src = ts_queries.java_highlights };
            } else if (extIs(ext, .{ ".js", ".jsx", ".mjs", ".cjs" })) {
                break :blk Selected{ .lang = tree_sitter_javascript(), .query_src = ts_queries.javascript_highlights };
            } else if (extIs(ext, .{".json"})) {
                break :blk Selected{ .lang = tree_sitter_json(), .query_src = ts_queries.json_highlights };
            } else if (extIs(ext, .{ ".kt", ".kts" })) {
                break :blk Selected{ .lang = tree_sitter_kotlin(), .query_src = ts_queries.kotlin_highlights };
            } else if (extIs(ext, .{ ".ml", ".mli" })) {
                break :blk Selected{ .lang = tree_sitter_ocaml(), .query_src = ts_queries.ocaml_highlights };
            } else if (extIs(ext, .{ ".pas", ".pp", ".p" })) {
                break :blk Selected{ .lang = tree_sitter_pascal(), .query_src = ts_queries.pascal_highlights };
            } else if (extIs(ext, .{ ".php", ".phtml", ".php3", ".php4", ".php5" })) {
                break :blk Selected{ .lang = tree_sitter_php(), .query_src = ts_queries.php_highlights };
            } else if (extIs(ext, .{ ".ps1", ".psm1", ".psd1" })) {
                break :blk Selected{ .lang = tree_sitter_powershell(), .query_src = ts_queries.powershell_highlights };
            } else if (extIs(ext, .{ ".py", ".pyw" })) {
                break :blk Selected{ .lang = tree_sitter_python(), .query_src = ts_queries.python_highlights };
            } else if (extIs(ext, .{ ".rb", ".rake" })) {
                break :blk Selected{ .lang = tree_sitter_ruby(), .query_src = ts_queries.ruby_highlights };
            } else if (extIs(ext, .{".rs"})) {
                break :blk Selected{ .lang = tree_sitter_rust(), .query_src = ts_queries.rust_highlights };
            } else if (extIs(ext, .{ ".scala", ".sc" })) {
                break :blk Selected{ .lang = tree_sitter_scala(), .query_src = ts_queries.scala_highlights };
            }
        }
        if (syntax_minimal_grammars) {
            if (extIs(ext, .{ ".zig", ".zon" })) {
                break :blk Selected{ .lang = tree_sitter_zig(), .query_src = ts_queries.zig_highlights };
            }
        }
        return &.{};
    };

    const styles = try gpa.alloc(u8, content.len);
    errdefer gpa.free(styles);
    @memset(styles, 0);

    const parser = ts.Parser.create();
    defer parser.destroy();
    parser.setLanguage(selected.lang) catch return styles;
    const tree = parser.parseString(content, null) orelse return styles;
    defer tree.destroy();

    var error_offset: u32 = 0;
    const query = ts.Query.create(selected.lang, selected.query_src, &error_offset) catch return styles;
    defer query.destroy();
    const cursor = ts.QueryCursor.create();
    defer cursor.destroy();
    cursor.exec(query, tree.rootNode());

    while (cursor.nextMatch()) |match| {
        for (match.captures) |cap| {
            const syn = synFor(query.captureNameForId(cap.index) orelse "");
            if (syn == .none) continue;
            var b: usize = cap.node.startByte();
            const end = @min(@as(usize, cap.node.endByte()), styles.len);
            while (b < end) : (b += 1) styles[b] = @intFromEnum(syn);
        }
    }
    return styles;
}

fn palColor(idx: u8) ui.Color {
    if (T().palette) |p| if (idx < 16) return rgbColor(p[idx]);
    return .{ .index = idx };
}

fn ghostColor(color: ghostty_vt.Style.Color, is_bg: bool) ui.Color {
    return switch (color) {
        .none => colorOpt(if (is_bg) T().bg else T().fg),
        .palette => |idx| palColor(idx),
        .rgb => |rgb| .{ .rgb = .{ rgb.r, rgb.g, rgb.b } },
    };
}

pub fn cellStyle(ci: ghostty_vt.PageList.Cell) ui.Style {
    const style = ci.style();
    var vs: ui.Style = .{
        .fg = ghostColor(style.fg_color, false),
        .bg = ghostColor(style.bg_color, true),
        .bold = style.flags.bold,
        .dim = style.flags.faint,
        .italic = style.flags.italic,
        .blink = style.flags.blink,
        .reverse = style.flags.inverse,
        .invisible = style.flags.invisible,
        .strikethrough = style.flags.strikethrough,
        .ul_style = switch (style.flags.underline) {
            .none => .off,
            .single => .single,
            .double => .double,
            .curly => .curly,
            .dotted => .dotted,
            .dashed => .dashed,
        },
    };
    switch (ci.cell.content_tag) {
        .bg_color_palette => vs.bg = palColor(ci.cell.content.color_palette.data),
        .bg_color_rgb => {
            const rgb = ci.cell.content.color_rgb;
            vs.bg = .{ .rgb = .{ rgb.r, rgb.g, rgb.b } };
        },
        else => {},
    }
    return vs;
}