const std = @import("std");
const cbor = @import("cbor");
const tp = @import("thespian");
const root = @import("soft_root").root;

const EventHandler = @import("EventHandler");
const Plane = @import("renderer").Plane;
const Buffer = @import("Buffer");
const input = @import("input");

const tui = @import("../tui.zig");
const Widget = @import("../Widget.zig");
const WidgetList = @import("../WidgetList.zig");
const Button = @import("../Button.zig");

const default_min_tabs = 2;

const @"style.config" = struct {
    default_minimum_tabs_shown: usize = 2,

    padding: []const u8 = " ",
    padding_left: usize = 2,
    padding_right: usize = 1,

    clean_indicator: []const u8 = " ",
    clean_indicator_fg: ?colors = null,
    dirty_indicator: []const u8 = "",
    dirty_indicator_fg: ?colors = null,
    close_icon: []const u8 = "󰅖",
    close_icon_fg: colors = .Error,
    save_icon: []const u8 = "󰆓",
    save_icon_fg: ?colors = null,

    spacer: []const u8 = "|",
    spacer_fg: colors = .active_bg,
    spacer_bg: colors = .inactive_bg,

    bar_fg: colors = .inactive_fg,
    bar_bg: colors = .inactive_bg,

    active_fg: colors = .active_fg,
    active_bg: colors = .active_bg,
    active_left: []const u8 = "🭅",
    active_left_fg: colors = .active_bg,
    active_left_bg: colors = .inactive_bg,
    active_right: []const u8 = "🭐",
    active_right_fg: colors = .active_bg,
    active_right_bg: colors = .inactive_bg,

    inactive_fg: colors = .inactive_fg,
    inactive_bg: colors = .inactive_bg,
    inactive_left: []const u8 = " ",
    inactive_left_fg: colors = .inactive_fg,
    inactive_left_bg: colors = .inactive_bg,
    inactive_right: []const u8 = " ",
    inactive_right_fg: colors = .inactive_fg,
    inactive_right_bg: colors = .inactive_bg,

    selected_fg: colors = .active_fg,
    selected_bg: colors = .active_bg,
    selected_left: []const u8 = "🭅",
    selected_left_fg: colors = .active_bg,
    selected_left_bg: colors = .inactive_bg,
    selected_right: []const u8 = "🭐",
    selected_right_fg: colors = .active_bg,
    selected_right_bg: colors = .inactive_bg,

    file_type_icon: bool = true,

    include_files: []const u8 = "",
};
pub const Style = @"style.config";

pub fn create(allocator: std.mem.Allocator, parent: Plane, event_handler: ?EventHandler, arg: ?[]const u8) @import("widget.zig").CreateError!Widget {
    const min_tabs = if (arg) |str_size| std.fmt.parseInt(usize, str_size, 10) catch null else null;
    const self = try allocator.create(TabBar);
    errdefer allocator.destroy(self);
    self.* = try TabBar.init(allocator, parent, event_handler, min_tabs);
    return Widget.to(self);
}

pub const TabBar = struct {
    allocator: std.mem.Allocator,
    plane: Plane,
    widget_list: *WidgetList,
    widget_list_widget: Widget,
    event_handler: ?EventHandler,
    tabs: []TabBarTab = &[_]TabBarTab{},
    active_buffer_ref: ?usize = null,
    minimum_tabs_shown: usize,
    place_next: Placement = .atend,

    tab_style: Style,
    tab_style_bufs: [][]const u8,

    const Self = @This();

    const Placement = union(enum) {
        atend,
        before: usize,
        after: usize,
    };

    const TabBarTab = struct {
        buffer_ref: usize,
        widget: Widget,
        view: ?usize,
    };

    fn init(allocator: std.mem.Allocator, parent: Plane, event_handler: ?EventHandler, min_tabs: ?usize) !Self {
        var w = try WidgetList.createH(allocator, parent, "tabs", .dynamic);
        w.render_decoration = null;
        w.ctx = w;
        const tab_style, const tab_style_bufs = root.read_config(Style, allocator);
        return .{
            .allocator = allocator,
            .plane = w.plane,
            .widget_list = w,
            .widget_list_widget = w.widget(),
            .event_handler = event_handler,
            .tab_style = tab_style,
            .tab_style_bufs = tab_style_bufs,
            .minimum_tabs_shown = min_tabs orelse tab_style.default_minimum_tabs_shown,
        };
    }

    pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
        root.free_config(self.allocator, self.tab_style_bufs);
        self.allocator.free(self.tabs);
        self.widget_list_widget.deinit(allocator);
        allocator.destroy(self);
    }

    pub fn layout(self: *Self) Widget.Layout {
        return if (self.tabs.len >= self.minimum_tabs_shown)
            self.widget_list_widget.layout()
        else
            .{ .static = 0 };
    }

    pub fn update(self: *Self) void {
        const drag_source, const drag_btn = tui.get_drag_source();
        self.update_tabs(drag_source) catch {};
        self.widget_list_widget.resize(Widget.Box.from(self.plane));
        self.widget_list_widget.update();
        for (self.widget_list.widgets.items) |*split_widgetstate| if (split_widgetstate.widget.dynamic_cast(WidgetList)) |split|
            for (split.widgets.items) |*widgetstate| if (widgetstate.widget.dynamic_cast(Tab.ButtonType)) |btn| if (btn.drag_pos) |_|
                tui.update_drag_source(&widgetstate.widget, drag_btn);
        tui.refresh_hover(@src());
    }

    pub fn render(self: *Self, theme: *const Widget.Theme) bool {
        self.plane.set_base_style(theme.editor);
        self.plane.erase();
        self.plane.home();
        self.plane.set_style(.{
            .fg = self.tab_style.bar_fg.from_theme(theme),
            .bg = self.tab_style.bar_bg.from_theme(theme),
        });
        self.plane.fill(" ");
        self.plane.home();
        return self.widget_list_widget.render(theme);
    }

    pub fn receive(self: *Self, _: tp.pid_ref, m: tp.message) error{Exit}!bool {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        var file_path: []const u8 = undefined;
        var buffer_ref_a: usize = undefined;
        var buffer_ref_b: usize = undefined;
        if (try m.match(.{"next_tab"})) {
            self.select_next_tab();
        } else if (try m.match(.{"previous_tab"})) {
            self.select_previous_tab();
        } else if (try m.match(.{"move_tab_next"})) {
            self.move_tab_next();
        } else if (try m.match(.{"move_tab_previous"})) {
            self.move_tab_previous();
        } else if (try m.match(.{ "swap_tabs", tp.extract(&buffer_ref_a), tp.extract(&buffer_ref_b) })) {
            self.swap_tabs(buffer_ref_a, buffer_ref_b);
        } else if (try m.match(.{ "place_next_tab", "after", tp.extract(&buffer_ref_a) })) {
            self.place_next_tab(.after, buffer_ref_a);
        } else if (try m.match(.{ "place_next_tab", "before", tp.extract(&buffer_ref_a) })) {
            self.place_next_tab(.before, buffer_ref_a);
        } else if (try m.match(.{ "place_next_tab", "atend" })) {
            self.place_next = .atend;
        } else if (try m.match(.{ "E", "open", tp.extract(&file_path), tp.more })) {
            self.active_buffer_ref = if (buffer_manager.get_buffer_for_file(file_path)) |buffer|
                buffer_manager.buffer_to_ref(buffer)
            else
                null;
        } else if (try m.match(.{ "E", "close" })) {
            self.active_buffer_ref = null;
        }
        return false;
    }

    fn handle_event(self: *Self, from: tp.pid_ref, m: tp.message) tp.result {
        if (self.event_handler) |event_handler| try event_handler.send(from, m);
        if (try m.match(.{ "D", input.event.press, @intFromEnum(input.mouse.BUTTON1), tp.more })) {
            const dragging = for (self.tabs, 0..) |*tab, idx| {
                if (tab.widget.dynamic_cast(Tab.ButtonType)) |btn|
                    if (btn.drag_pos) |_| break idx;
            } else return;
            const hover_ = for (self.tabs, 0..) |*tab, idx| {
                if (tab.widget.dynamic_cast(Tab.ButtonType)) |btn|
                    if (btn.hover) break idx;
            } else return;
            if (dragging != hover_) {
                self.swap_tabs_by_index(dragging, hover_);
                if (self.tabs[dragging].widget.dynamic_cast(Tab.ButtonType)) |btn| btn.hover = false;
                self.update();
            }
        }
    }

    pub fn handle_resize(self: *Self, pos: Widget.Box) void {
        self.widget_list_widget.resize(pos);
        self.plane = self.widget_list.plane;
    }

    pub fn get(self: *const Self, name: []const u8) ?*const Widget {
        return self.widget_list_widget.get(name);
    }

    pub fn walk(self: *Self, ctx: *anyopaque, f: Widget.WalkFn, _: *Widget) bool {
        return self.widget_list_widget.walk(ctx, f);
    }

    pub fn hover(self: *Self) bool {
        return self.widget_list_widget.hover();
    }

    fn update_tabs(self: *Self, drag_source: ?*Widget) !void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        if (!try self.update_tab_buffers()) return;
        var prev_widget_count: usize = 0;
        for (self.widget_list.widgets.items) |*split_widgetstate| if (split_widgetstate.widget.dynamic_cast(WidgetList)) |split| {
            prev_widget_count += 1;
            for (split.widgets.items) |_| prev_widget_count += 1;
        };

        for (self.widget_list.widgets.items) |*split_widget| if (split_widget.widget.dynamic_cast(WidgetList)) |split| {
            for (split.widgets.items) |*widget|
                if (&widget.widget == drag_source) tui.reset_drag_context();
        };
        while (self.widget_list.pop()) |split_widget| if (split_widget.dynamic_cast(WidgetList)) |split| {
            while (split.pop()) |widget| if (widget.dynamic_cast(Tab.ButtonType) == null)
                widget.deinit(self.widget_list.allocator);
            split.deinit(self.widget_list.allocator);
        };

        var max_view: usize = 0;
        for (self.tabs) |tab| max_view = @max(max_view, tab.view orelse 0);

        var widget_count: usize = 0;
        for (0..max_view + 1) |view| {
            var first = true;
            var view_widget_list = try WidgetList.createH(self.allocator, self.widget_list.plane, "split", .dynamic);
            try self.widget_list.add(view_widget_list.widget());
            widget_count += 1;
            for (self.tabs) |tab| {
                const tab_view = tab.view orelse 0;
                if (tab_view != view) continue;
                if (first) {
                    first = false;
                } else {
                    try view_widget_list.add(try self.make_spacer(view_widget_list.plane));
                    widget_count += 1;
                }
                try view_widget_list.add(tab.widget);
                widget_count += 1;
                if (tab.widget.dynamic_cast(Tab.ButtonType)) |btn| {
                    if (buffer_manager.buffer_from_ref(tab.buffer_ref)) |buffer|
                        try btn.update_label(Tab.name_from_buffer(buffer));
                }
            }
        }
        if (prev_widget_count != widget_count)
            tui.refresh_hover(@src());
    }

    fn update_tab_buffers(self: *Self) !bool {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        const buffers = try buffer_manager.list_unordered(self.allocator);
        defer self.allocator.free(buffers);
        const existing_tabs = self.tabs;
        defer self.allocator.free(existing_tabs);
        var result: std.ArrayListUnmanaged(TabBarTab) = .{};
        errdefer result.deinit(self.allocator);

        // add existing tabs in original order if they still exist
        outer: for (existing_tabs) |existing_tab|
            for (buffers) |buffer| if (existing_tab.buffer_ref == buffer_manager.buffer_to_ref(buffer)) {
                if (!buffer.hidden)
                    (try result.addOne(self.allocator)).* = existing_tab;
                continue :outer;
            };

        // add new tabs
        outer: for (buffers) |buffer| {
            for (result.items) |result_tab| if (result_tab.buffer_ref == buffer_manager.buffer_to_ref(buffer))
                continue :outer;
            if (!buffer.hidden)
                try self.place_new_tab(&result, buffer);
        }

        self.tabs = try result.toOwnedSlice(self.allocator);

        if (existing_tabs.len != self.tabs.len)
            return true;
        for (existing_tabs, self.tabs) |tab_a, tab_b| {
            if (tab_a.buffer_ref == tab_b.buffer_ref and
                tab_a.view == tab_b.view)
                continue;
            return true;
        }
        return false;
    }

    fn place_new_tab(self: *Self, result: *std.ArrayListUnmanaged(TabBarTab), buffer: *Buffer) !void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        const buffer_ref = buffer_manager.buffer_to_ref(buffer);
        const tab = try Tab.create(self, buffer_ref, &self.tab_style);
        const pos = switch (self.place_next) {
            .atend => try result.addOne(self.allocator),
            .before => |i| if (i < result.items.len)
                &(try result.addManyAt(self.allocator, i, 1))[0]
            else
                try result.addOne(self.allocator),
            .after => |i| if (i < result.items.len - 1)
                &(try result.addManyAt(self.allocator, i + 1, 1))[0]
            else
                try result.addOne(self.allocator),
        };
        pos.* = .{ .buffer_ref = buffer_ref, .widget = tab, .view = buffer.get_last_view() };
        self.place_next = .atend;
    }

    fn make_spacer(self: @This(), parent: Plane) !Widget {
        return spacer.create(
            self.allocator,
            parent,
            self.tab_style.spacer,
            self.tab_style.spacer_fg,
            self.tab_style.spacer_bg,
            null,
        );
    }

    fn select_next_tab(self: *Self) void {
        tp.trace(tp.channel.debug, .{"select_next_tab"});
        var activate_next = false;
        var first: ?*const TabBarTab = null;
        for (self.tabs) |*tab| {
            if (first == null)
                first = tab;
            if (activate_next)
                return navigate_to_tab(tab);
            if (tab.buffer_ref == self.active_buffer_ref)
                activate_next = true;
        }
        if (first) |tab|
            navigate_to_tab(tab);
    }

    fn select_previous_tab(self: *Self) void {
        tp.trace(tp.channel.debug, .{"select_previous_tab"});
        var goto: ?*const TabBarTab = if (self.tabs.len > 0) &self.tabs[self.tabs.len - 1] else null;
        for (self.tabs) |*tab| {
            if (tab.buffer_ref == self.active_buffer_ref)
                break;
            goto = tab;
        }
        if (goto) |tab| navigate_to_tab(tab);
    }

    fn move_tab_next(self: *Self) void {
        tp.trace(tp.channel.debug, .{"move_tab_next"});
        for (self.tabs, 0..) |*tab, idx| if (tab.buffer_ref == self.active_buffer_ref and idx < self.tabs.len - 1) {
            const tmp = self.tabs[idx + 1];
            self.tabs[idx + 1] = self.tabs[idx];
            self.tabs[idx] = tmp;
            break;
        };
    }

    fn move_tab_previous(self: *Self) void {
        tp.trace(tp.channel.debug, .{"move_tab_previous"});
        for (self.tabs, 0..) |*tab, idx| if (tab.buffer_ref == self.active_buffer_ref and idx > 0) {
            const tmp = self.tabs[idx - 1];
            self.tabs[idx - 1] = self.tabs[idx];
            self.tabs[idx] = tmp;
            break;
        };
    }

    fn swap_tabs(self: *Self, buffer_ref_a: usize, buffer_ref_b: usize) void {
        tp.trace(tp.channel.debug, .{ "swap_tabs", "buffers", buffer_ref_a, buffer_ref_b });
        if (buffer_ref_a == buffer_ref_b) {
            tp.trace(tp.channel.debug, .{ "swap_tabs", "same_buffer" });
            return;
        }
        const tab_a_idx = for (self.tabs, 0..) |*tab, idx| if (tab.buffer_ref == buffer_ref_a) break idx else continue else {
            tp.trace(tp.channel.debug, .{ "swap_tabs", "not_found", "buffer_ref_a" });
            return;
        };
        const tab_b_idx = for (self.tabs, 0..) |*tab, idx| if (tab.buffer_ref == buffer_ref_b) break idx else continue else {
            tp.trace(tp.channel.debug, .{ "swap_tabs", "not_found", "buffer_ref_b" });
            return;
        };
        self.swap_tabs_by_index(tab_a_idx, tab_b_idx);
    }

    fn swap_tabs_by_index(self: *Self, tab_a_idx: usize, tab_b_idx: usize) void {
        const tmp = self.tabs[tab_a_idx];
        self.tabs[tab_a_idx] = self.tabs[tab_b_idx];
        self.tabs[tab_b_idx] = tmp;
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        if (buffer_manager.buffer_from_ref(self.tabs[tab_a_idx].buffer_ref)) |buffer_a|
            if (buffer_manager.buffer_from_ref(self.tabs[tab_b_idx].buffer_ref)) |buffer_b| {
                const view_a = buffer_a.get_last_view();
                const view_b = buffer_b.get_last_view();
                if (view_a != view_b) {
                    buffer_a.set_last_view(view_b);
                    buffer_b.set_last_view(view_a);
                }
            };
        tp.trace(tp.channel.debug, .{ "swap_tabs", "swapped", "indexes", tab_a_idx, tab_b_idx });
    }

    fn place_next_tab(self: *Self, position: enum { before, after }, buffer_ref: usize) void {
        tp.trace(tp.channel.debug, .{ "place_next_tab", position, buffer_ref });
        const tab_idx = for (self.tabs, 0..) |*tab, idx| if (tab.buffer_ref == buffer_ref) break idx else continue else {
            tp.trace(tp.channel.debug, .{ "place_next_tab", "not_found", buffer_ref });
            return;
        };
        self.place_next = switch (position) {
            .before => .{ .before = tab_idx },
            .after => .{ .after = tab_idx },
        };
    }

    fn navigate_to_tab(tab: *const TabBarTab) void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        if (buffer_manager.buffer_from_ref(tab.buffer_ref)) |buffer|
            tp.self_pid().send(.{ "cmd", "navigate", .{ .file = buffer.get_file_path() } }) catch {};
    }

    pub fn write_state(self: *const Self, writer: *std.Io.Writer) error{WriteFailed}!void {
        try cbor.writeArrayHeader(writer, self.tabs.len);
        for (self.tabs) |tab| try cbor.writeValue(writer, ref_to_name(tab.buffer_ref));
    }

    fn ref_to_name(buffer_ref: usize) ?[]const u8 {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        return if (buffer_manager.buffer_from_ref(buffer_ref)) |buffer| buffer.get_file_path() else null;
    }

    pub fn extract_state(self: *Self, iter: *[]const u8) !void {
        var iter2 = iter.*;
        self.allocator.free(self.tabs);
        self.tabs = &.{};

        var result: std.ArrayListUnmanaged(TabBarTab) = .{};
        errdefer result.deinit(self.allocator);

        var count = cbor.decodeArrayHeader(&iter2) catch return error.MatchTabArrayFailed;
        while (count > 0) : (count -= 1) {
            var buffer_name: ?[]const u8 = undefined;
            if (!(cbor.matchValue(&iter2, cbor.extract(&buffer_name)) catch false)) return error.MatchTabBufferNameFailed;
            if (buffer_name) |name| {
                const buffer_ref_, const buffer_view = name_to_ref_and_view(name);
                if (buffer_ref_) |buffer_ref|
                    (try result.addOne(self.allocator)).* = .{
                        .buffer_ref = buffer_ref,
                        .widget = try Tab.create(self, buffer_ref, &self.tab_style),
                        .view = buffer_view,
                    };
            }
        }

        self.tabs = try result.toOwnedSlice(self.allocator);
        iter.* = iter2;
    }

    fn name_to_ref_and_view(buffer_name: []const u8) struct { ?usize, ?usize } {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        return if (buffer_manager.get_buffer_for_file(buffer_name)) |buffer|
            .{ buffer_manager.buffer_to_ref(buffer), buffer.get_last_view() }
        else
            .{ null, null };
    }
};

const Tab = struct {
    tabbar: *TabBar,
    buffer_ref: usize,
    tab_style: *const Style,
    close_pos: ?i32 = null,
    save_pos: ?i32 = null,
    on_event: ?EventHandler = null,

    const Mode = enum { active, inactive, selected };

    const ButtonType = Button.Options(@This()).ButtonType;

    fn create(
        tabbar: *TabBar,
        buffer_ref: usize,
        tab_style: *const Style,
    ) !Widget {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        const buffer = buffer_manager.buffer_from_ref(buffer_ref);
        return Button.create_widget(Tab, tabbar.allocator, tabbar.widget_list.plane, .{
            .ctx = .{ .tabbar = tabbar, .buffer_ref = buffer_ref, .tab_style = tab_style },
            .label = if (buffer) |buf| name_from_buffer(buf) else "???",
            .on_click = Tab.on_click,
            .on_click2 = Tab.on_click2,
            .on_layout = Tab.layout,
            .on_render = Tab.render,
            .on_event = EventHandler.bind(tabbar, TabBar.handle_event),
        });
    }

    fn on_click(self: *@This(), _: *ButtonType, pos: Widget.Pos) void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        if (buffer_manager.buffer_from_ref(self.buffer_ref)) |buffer| {
            if (self.close_pos) |close_pos| if (pos.x == close_pos) {
                tp.self_pid().send(.{ "cmd", "close_buffer", .{buffer.get_file_path()} }) catch {};
                return;
            };
            if (self.save_pos) |save_pos| if (pos.x == save_pos) {
                tp.self_pid().send(.{ "cmd", "save_buffer", .{buffer.get_file_path()} }) catch {};
                return;
            };
            tp.self_pid().send(.{ "cmd", "navigate", .{ .file = buffer.get_file_path() } }) catch {};
        }
    }

    fn on_click2(self: *@This(), _: *ButtonType, _: Widget.Pos) void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        if (buffer_manager.buffer_from_ref(self.buffer_ref)) |buffer|
            tp.self_pid().send(.{ "cmd", "close_buffer", .{buffer.get_file_path()} }) catch {};
    }

    fn render(self: *@This(), btn: *ButtonType, theme: *const Widget.Theme) bool {
        const active = self.tabbar.active_buffer_ref == self.buffer_ref;
        if (btn.drag_pos) |pos| {
            self.render_dragging(&btn.plane, theme);
            const anchor: Widget.Pos = btn.drag_anchor orelse .{};
            var box = Widget.Box.from(btn.plane);
            box.y = @intCast(@max(pos.y, anchor.y) - anchor.y);
            box.x = @intCast(@max(pos.x, anchor.x) - anchor.x);
            if (tui.top_layer(box.to_layer())) |top_layer| {
                self.render_selected(top_layer, btn.opts.label, false, theme, active);
            }
        } else {
            const mode: Mode = if (btn.hover) .selected else if (active) .active else .inactive;
            switch (mode) {
                .selected => self.render_selected(&btn.plane, btn.opts.label, btn.hover, theme, active),
                .active => self.render_active(&btn.plane, btn.opts.label, btn.hover, theme),
                .inactive => self.render_inactive(&btn.plane, btn.opts.label, btn.hover, theme),
            }
        }
        return false;
    }

    fn render_selected(self: *@This(), plane: *Plane, label: []const u8, hover: bool, theme: *const Widget.Theme, active: bool) void {
        plane.set_base_style(theme.editor);
        plane.erase();
        plane.home();
        plane.set_style(.{
            .fg = self.tab_style.inactive_fg.from_theme(theme),
            .bg = self.tab_style.inactive_bg.from_theme(theme),
        });
        plane.fill(" ");
        plane.home();
        if (active) {
            plane.set_style(.{
                .fg = self.tab_style.selected_fg.from_theme(theme),
                .bg = self.tab_style.selected_bg.from_theme(theme),
            });
            plane.fill(" ");
            plane.home();
        }

        plane.set_style(.{
            .fg = self.tab_style.selected_left_fg.from_theme(theme),
            .bg = self.tab_style.selected_left_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.selected_left) catch {};

        plane.set_style(.{
            .fg = self.tab_style.selected_fg.from_theme(theme),
            .bg = self.tab_style.selected_bg.from_theme(theme),
        });
        self.render_content(plane, label, hover, self.tab_style.selected_fg.from_theme(theme), theme);

        plane.set_style(.{
            .fg = self.tab_style.selected_right_fg.from_theme(theme),
            .bg = self.tab_style.selected_right_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.selected_right) catch {};
    }

    fn render_active(self: *@This(), plane: *Plane, label: []const u8, hover: bool, theme: *const Widget.Theme) void {
        plane.set_base_style(theme.editor);
        plane.erase();
        plane.home();
        plane.set_style(.{
            .fg = self.tab_style.inactive_fg.from_theme(theme),
            .bg = self.tab_style.inactive_bg.from_theme(theme),
        });
        plane.fill(" ");
        plane.home();
        plane.set_style(.{
            .fg = self.tab_style.active_fg.from_theme(theme),
            .bg = self.tab_style.active_bg.from_theme(theme),
        });
        plane.fill(" ");
        plane.home();

        plane.set_style(.{
            .fg = self.tab_style.active_left_fg.from_theme(theme),
            .bg = self.tab_style.active_left_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.active_left) catch {};

        plane.set_style(.{
            .fg = self.tab_style.active_fg.from_theme(theme),
            .bg = self.tab_style.active_bg.from_theme(theme),
        });
        self.render_content(plane, label, hover, self.tab_style.active_fg.from_theme(theme), theme);

        plane.set_style(.{
            .fg = self.tab_style.active_right_fg.from_theme(theme),
            .bg = self.tab_style.active_right_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.active_right) catch {};
    }

    fn render_inactive(self: *@This(), plane: *Plane, label: []const u8, hover: bool, theme: *const Widget.Theme) void {
        plane.set_base_style(theme.editor);
        plane.erase();
        plane.home();
        plane.set_style(.{
            .fg = self.tab_style.inactive_fg.from_theme(theme),
            .bg = self.tab_style.inactive_bg.from_theme(theme),
        });
        plane.fill(" ");
        plane.home();

        plane.set_style(.{
            .fg = self.tab_style.inactive_left_fg.from_theme(theme),
            .bg = self.tab_style.inactive_left_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.inactive_left) catch {};

        plane.set_style(.{
            .fg = self.tab_style.inactive_fg.from_theme(theme),
            .bg = self.tab_style.inactive_bg.from_theme(theme),
        });
        self.render_content(plane, label, hover, self.tab_style.inactive_fg.from_theme(theme), theme);

        plane.set_style(.{
            .fg = self.tab_style.inactive_right_fg.from_theme(theme),
            .bg = self.tab_style.inactive_right_bg.from_theme(theme),
        });
        _ = plane.putstr(self.tab_style.inactive_right) catch {};
    }

    fn render_dragging(self: *@This(), plane: *Plane, theme: *const Widget.Theme) void {
        plane.set_base_style(theme.editor);
        plane.erase();
        plane.home();
        plane.set_style(.{
            .fg = self.tab_style.inactive_fg.from_theme(theme),
            .bg = self.tab_style.inactive_bg.from_theme(theme),
        });
        plane.fill(" ");
        plane.home();
    }

    fn render_content(self: *@This(), plane: *Plane, label: []const u8, hover: bool, fg: ?Widget.Theme.Color, theme: *const Widget.Theme) void {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        const buffer_ = buffer_manager.buffer_from_ref(self.buffer_ref);
        const is_dirty = if (buffer_) |buffer| buffer.is_dirty() else false;
        const auto_save = if (buffer_) |buffer| buffer.is_auto_save() else false;
        self.render_padding(plane, .left);
        if (self.tab_style.file_type_icon) if (buffer_) |buffer| if (buffer.file_type_icon) |icon| {
            const color_: ?u24 = if (buffer.file_type_color) |color| if (!(color == 0xFFFFFF or color == 0x000000 or color == 0x000001)) color else null else null;
            if (color_) |color|
                plane.set_style(.{ .fg = .{ .color = color } });
            _ = plane.putstr(icon) catch {};
            if (color_) |_|
                plane.set_style(.{ .fg = fg });
            _ = plane.putstr("  ") catch {};
        };
        _ = plane.putstr(label) catch {};
        _ = plane.putstr(" ") catch {};
        self.close_pos = null;
        self.save_pos = null;
        if (hover) {
            if (is_dirty) {
                if (self.tab_style.save_icon_fg) |color|
                    plane.set_style(.{ .fg = color.from_theme(theme) });
                self.save_pos = plane.cursor_x();
                _ = plane.putstr(self.tabbar.tab_style.save_icon) catch {};
            } else {
                plane.set_style(.{ .fg = self.tab_style.close_icon_fg.from_theme(theme) });
                self.close_pos = plane.cursor_x();
                _ = plane.putstr(self.tabbar.tab_style.close_icon) catch {};
            }
        } else if (is_dirty and !auto_save) {
            if (self.tab_style.dirty_indicator_fg) |color|
                plane.set_style(.{ .fg = color.from_theme(theme) });
            _ = plane.putstr(self.tabbar.tab_style.dirty_indicator) catch {};
        } else {
            if (self.tab_style.clean_indicator_fg) |color|
                plane.set_style(.{ .fg = color.from_theme(theme) });
            _ = plane.putstr(self.tabbar.tab_style.clean_indicator) catch {};
        }
        plane.set_style(.{ .fg = fg });
        self.render_padding(plane, .right);
    }

    fn render_padding(self: *@This(), plane: *Plane, side: enum { left, right }) void {
        var padding: usize = switch (side) {
            .left => self.tab_style.padding_left,
            .right => self.tab_style.padding_right,
        };
        while (padding > 0) : (padding -= 1) _ = plane.putstr(self.tab_style.padding) catch {};
    }

    fn layout(self: *@This(), btn: *ButtonType) Widget.Layout {
        const buffer_manager = tui.get_buffer_manager() orelse @panic("tabs no buffer manager");
        const is_dirty = if (buffer_manager.buffer_from_ref(self.buffer_ref)) |buffer| buffer.is_dirty() else false;
        const active = self.tabbar.active_buffer_ref == self.buffer_ref;
        const len = btn.plane.egc_chunk_width(btn.opts.label, 0, 1);
        const len_padding = padding_len(btn.plane, self.tabbar.tab_style, active, is_dirty);
        return .{ .static = len + len_padding };
    }

    fn padding_len(plane: Plane, tab_style: Style, active: bool, dirty: bool) usize {
        const len_padding = plane.egc_chunk_width(tab_style.padding, 0, 1) * (tab_style.padding_left + tab_style.padding_right);
        const len_file_icon: usize = if (tab_style.file_type_icon) 3 else 0;
        const len_close_icon = plane.egc_chunk_width(tab_style.close_icon, 0, 1);
        const len_dirty_indicator = if (dirty) plane.egc_chunk_width(tab_style.dirty_indicator, 0, 1) else 0;
        const len_dirty_close = @max(len_close_icon, len_dirty_indicator) + 1; // +1 for the leading space
        return len_padding + len_file_icon + len_dirty_close + if (active)
            plane.egc_chunk_width(tab_style.active_left, 0, 1) +
                plane.egc_chunk_width(tab_style.active_right, 0, 1)
        else
            plane.egc_chunk_width(tab_style.inactive_left, 0, 1) +
                plane.egc_chunk_width(tab_style.inactive_right, 0, 1);
    }

    fn name_from_buffer(buffer: *Buffer) []const u8 {
        const file_path = buffer.get_file_path();
        if (file_path.len > 0 and file_path[0] == '*')
            return file_path;
        const basename_begin = std.mem.lastIndexOfScalar(u8, file_path, std.fs.path.sep);
        const basename = if (basename_begin) |begin| file_path[begin + 1 ..] else file_path;
        return basename;
    }

    fn write_state(self: *const @This(), writer: *std.Io.Writer) error{OutOfMemory}!void {
        try cbor.writeArrayHeader(writer, 9);
        try cbor.writeValue(writer, self.get_file_path());
        try cbor.writeValue(writer, self.file_exists);
        try cbor.writeValue(writer, self.file_eol_mode);
        try cbor.writeValue(writer, self.hidden);
        try cbor.writeValue(writer, self.ephemeral);
        try cbor.writeValue(writer, self.meta);
        try cbor.writeValue(writer, self.file_type_name);
    }

    fn extract_state(self: *@This(), iter: *[]const u8) !void {
        _ = self;
        _ = iter;
    }
};

const spacer = struct {
    plane: Plane,
    layout_: Widget.Layout,
    on_event: ?EventHandler,
    content: []const u8,
    fg: colors,
    bg: colors,

    const Self = @This();

    fn create(
        allocator: std.mem.Allocator,
        parent: Plane,
        content: []const u8,
        fg: colors,
        bg: colors,
        event_handler: ?EventHandler,
    ) @import("widget.zig").CreateError!Widget {
        const self: *Self = try allocator.create(Self);
        errdefer allocator.destroy(self);
        self.* = .{
            .plane = try Plane.init(&(Widget.Box{}).opts(@typeName(Self)), parent),
            .layout_ = .{ .static = self.plane.egc_chunk_width(content, 0, 1) },
            .on_event = event_handler,
            .content = content,
            .fg = fg,
            .bg = bg,
        };
        return Widget.to(self);
    }

    pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
        self.plane.deinit();
        allocator.destroy(self);
    }

    pub fn layout(self: *Self) Widget.Layout {
        return self.layout_;
    }

    pub fn render(self: *Self, theme: *const Widget.Theme) bool {
        self.plane.set_base_style(theme.editor);
        self.plane.erase();
        self.plane.home();
        self.plane.set_style(.{
            .fg = self.fg.from_theme(theme),
            .bg = self.bg.from_theme(theme),
        });
        self.plane.fill(" ");
        self.plane.home();
        _ = self.plane.putstr(self.content) catch {};
        return false;
    }

    pub fn receive(self: *Self, from: tp.pid_ref, m: tp.message) error{Exit}!bool {
        var btn: u32 = 0;
        if (try m.match(.{ "D", tp.any, tp.extract(&btn), tp.more })) {
            if (self.on_event) |h| h.send(from, m) catch {};
            return true;
        }
        return false;
    }
};

const colors = enum {
    default_bg,
    default_fg,
    active_bg,
    active_fg,
    inactive_bg,
    inactive_fg,
    selected_bg,
    selected_fg,

    Error,
    Warning,
    Information,
    Hint,

    fn from_theme(color: colors, theme: *const Widget.Theme) ?Widget.Theme.Color {
        return switch (color) {
            .default_bg => theme.editor.bg,
            .default_fg => theme.editor.fg,
            .active_bg => theme.tab_active.bg,
            .active_fg => theme.tab_active.fg,
            .inactive_bg => theme.tab_inactive.bg,
            .inactive_fg => theme.tab_inactive.fg,
            .selected_bg => theme.tab_selected.bg,
            .selected_fg => theme.tab_selected.fg,
            .Error => theme.editor_error.fg,
            .Warning => theme.editor_warning.fg,
            .Information => theme.editor_information.fg,
            .Hint => theme.editor_hint.fg,
        };
    }
};