const std = @import("std");
const xlib = @import("../x11/xlib.zig");
const monitor_mod = @import("../monitor.zig");
const blocks_mod = @import("blocks/blocks.zig");
const config_mod = @import("../config/config.zig");
const ColorScheme = config_mod.ColorScheme;

const Monitor = monitor_mod.Monitor;
const Block = blocks_mod.Block;

fn get_layout_symbol(layout_index: u32, config: config_mod.Config) []const u8 {
    return switch (layout_index) {
        0 => config.layout_tile_symbol,
        1 => config.layout_monocle_symbol,
        2 => config.layout_floating_symbol,
        3 => config.layout_scrolling_symbol,
        4 => "[#]",
        else => "[?]",
    };
}

pub const Bar = struct {
    window: xlib.Window,
    pixmap: xlib.Pixmap,
    graphics_context: xlib.GC,
    xft_draw: ?*xlib.XftDraw,
    width: i32,
    height: i32,
    monitor: *Monitor,

    font: ?*xlib.XftFont,
    font_height: i32,

    scheme_normal: ColorScheme,
    scheme_selected: ColorScheme,
    scheme_occupied: ColorScheme,
    scheme_urgent: ColorScheme,
    hide_vacant_tags: bool,

    allocator: std.mem.Allocator,
    blocks: std.ArrayList(Block),
    needs_redraw: bool,
    next: ?*Bar,

    /// Creates a bar window for `monitor` using the given config.
    /// Returns null on allocation failure or if the font cannot be loaded.
    pub fn create(
        allocator: std.mem.Allocator,
        display: *xlib.Display,
        screen: c_int,
        monitor: *Monitor,
        config: config_mod.Config,
    ) ?*Bar {
        const bar = allocator.create(Bar) catch return null;

        const visual = xlib.XDefaultVisual(display, screen);
        const colormap = xlib.XDefaultColormap(display, screen);
        const depth = xlib.XDefaultDepth(display, screen);
        const root = xlib.XRootWindow(display, screen);

        const font_name_z = allocator.dupeZ(u8, config.font) catch {
            allocator.destroy(bar);
            return null;
        };
        defer allocator.free(font_name_z);

        const font = xlib.XftFontOpenName(display, screen, font_name_z);
        if (font == null) {
            allocator.destroy(bar);
            return null;
        }

        const font_height = font.*.ascent + font.*.descent;
        const bar_height: i32 = @intCast(@as(i32, font_height) + 8);

        const window = xlib.c.XCreateSimpleWindow(
            display,
            root,
            monitor.mon_x,
            monitor.mon_y,
            @intCast(monitor.mon_w),
            @intCast(bar_height),
            0,
            0,
            0x1a1b26,
        );

        var attributes: xlib.c.XSetWindowAttributes = undefined;
        attributes.override_redirect = xlib.True;
        attributes.event_mask = xlib.c.ExposureMask | xlib.c.ButtonPressMask;
        _ = xlib.c.XChangeWindowAttributes(display, window, xlib.c.CWOverrideRedirect | xlib.c.CWEventMask, &attributes);

        const pixmap = xlib.XCreatePixmap(
            display,
            window,
            @intCast(monitor.mon_w),
            @intCast(bar_height),
            @intCast(depth),
        );

        const graphics_context = xlib.XCreateGC(display, pixmap, 0, null);
        const xft_draw = xlib.XftDrawCreate(display, pixmap, visual, colormap);

        _ = xlib.XMapWindow(display, window);

        bar.* = Bar{
            .window = window,
            .pixmap = pixmap,
            .graphics_context = graphics_context,
            .xft_draw = xft_draw,
            .width = monitor.mon_w,
            .height = bar_height,
            .monitor = monitor,
            .font = font,
            .font_height = font_height,
            .scheme_normal = config.scheme_normal,
            .scheme_selected = config.scheme_selected,
            .scheme_occupied = config.scheme_occupied,
            .scheme_urgent = config.scheme_urgent,
            .hide_vacant_tags = config.hide_vacant_tags,
            .allocator = allocator,
            .blocks = .empty,
            .needs_redraw = true,
            .next = null,
        };

        monitor.bar_win = window;
        monitor.win_y = monitor.mon_y + bar_height;
        monitor.win_h = monitor.mon_h - bar_height;

        return bar;
    }

    /// Destroys the bar's X resources and frees the allocation.
    // TODO: Remove `allocator` param as its already stored in `Bar`.
    pub fn destroy(self: *Bar, allocator: std.mem.Allocator, display: *xlib.Display) void {
        if (self.xft_draw) |xft_draw| xlib.XftDrawDestroy(xft_draw);
        if (self.font) |font| xlib.XftFontClose(display, font);

        _ = xlib.XFreeGC(display, self.graphics_context);
        _ = xlib.XFreePixmap(display, self.pixmap);
        _ = xlib.c.XDestroyWindow(display, self.window);
        self.blocks.deinit(self.allocator);
        allocator.destroy(self);
    }

    pub fn add_block(self: *Bar, block: Block) void {
        self.blocks.append(self.allocator, block) catch {};
    }

    pub fn clear_blocks(self: *Bar) void {
        self.blocks.clearRetainingCapacity();
    }

    pub fn invalidate(self: *Bar) void {
        self.needs_redraw = true;
    }

    /// Redraws the bar if marked dirty. Tags are taken from `config.tags`
    pub fn draw(self: *Bar, display: *xlib.Display, config: config_mod.Config) void {
        if (!self.needs_redraw) return;

        self.fill_rect(display, 0, 0, self.width, self.height, self.scheme_normal.background);

        var x_position: i32 = 0;
        const padding: i32 = 8;
        const monitor = self.monitor;
        const current_tags = monitor.tagset[monitor.sel_tags];

        for (config.tags, 0..) |tag, index| {
            const tag_mask: u32 = @as(u32, 1) << @intCast(index);
            const is_selected = (current_tags & tag_mask) != 0;
            const is_occupied = has_clients_on_tag(monitor, tag_mask);

            if (self.hide_vacant_tags and !is_occupied and !is_selected) continue;

            const scheme = if (is_selected)
                self.scheme_selected
            else if (is_occupied)
                self.scheme_occupied
            else
                self.scheme_normal;

            const tag_text_width = self.text_width(display, tag);
            const tag_width = tag_text_width + padding * 2;

            if (is_selected) {
                self.fill_rect(display, x_position, self.height - 3, tag_width, 3, scheme.border);
            }

            const text_y = @divTrunc(self.height + self.font_height, 2) - 4;
            self.draw_text(display, x_position + padding, text_y, tag, scheme.foreground);
            x_position += tag_width;
        }

        x_position += padding;

        const layout_symbol = get_layout_symbol(monitor.sel_lt, config);
        self.draw_text(display, x_position, @divTrunc(self.height + self.font_height, 2) - 4, layout_symbol, self.scheme_normal.foreground);
        x_position += self.text_width(display, layout_symbol) + padding;

        var block_x: i32 = self.width - padding;
        var block_index: usize = self.blocks.items.len;
        while (block_index > 0) {
            block_index -= 1;
            const block = &self.blocks.items[block_index];
            const content = block.get_content();
            const content_width = self.text_width(display, content);
            block_x -= content_width;
            self.draw_text(display, block_x, @divTrunc(self.height + self.font_height, 2) - 4, content, block.color());
            if (block.underline) {
                self.fill_rect(display, block_x, self.height - 2, content_width, 2, block.color());
            }
            block_x -= padding;
        }

        _ = xlib.XCopyArea(display, self.pixmap, self.window, self.graphics_context, 0, 0, @intCast(self.width), @intCast(self.height), 0, 0);
        _ = xlib.XSync(display, xlib.False);

        self.needs_redraw = false;
    }

    /// Returns the index of the tag the user clicked on, or null if the
    /// click was outside the tag area.
    pub fn handle_click(self: *Bar, display: *xlib.Display, click_x: i32, config: config_mod.Config) ?usize {
        var x_position: i32 = 0;
        const padding: i32 = 8;
        const monitor = self.monitor;
        const current_tags = monitor.tagset[monitor.sel_tags];

        for (config.tags, 0..) |tag, index| {
            const tag_mask = @as(u32, 1) << @intCast(index);
            const is_selected = (current_tags & tag_mask) != 0;
            const is_occupied = has_clients_on_tag(monitor, tag_mask);

            if (self.hide_vacant_tags and !is_occupied and !is_selected) continue;

            const tag_text_width = self.text_width(display, tag);
            const tag_width = tag_text_width + padding * 2;

            if (click_x >= x_position and click_x < x_position + tag_width) {
                return index;
            }
            x_position += tag_width;
        }
        return null;
    }

    /// Updates all blocks and marks the bar dirty if any block changed.
    pub fn update_blocks(self: *Bar) void {
        var changed = false;
        for (self.blocks.items) |*block| {
            if (block.update()) changed = true;
        }
        if (changed) self.needs_redraw = true;
    }

    fn fill_rect(self: *Bar, display: *xlib.Display, x: i32, y: i32, width: i32, height: i32, color: c_ulong) void {
        _ = xlib.XSetForeground(display, self.graphics_context, color);
        _ = xlib.XFillRectangle(display, self.pixmap, self.graphics_context, x, y, @intCast(width), @intCast(height));
    }

    fn draw_text(self: *Bar, display: *xlib.Display, x: i32, y: i32, text: []const u8, color: c_ulong) void {
        if (self.xft_draw == null or self.font == null) return;

        var xft_color: xlib.XftColor = undefined;
        var render_color: xlib.XRenderColor = undefined;
        render_color.red = @intCast((color >> 16 & 0xff) * 257);
        render_color.green = @intCast((color >> 8 & 0xff) * 257);
        render_color.blue = @intCast((color & 0xff) * 257);
        render_color.alpha = 0xffff;

        const visual = xlib.XDefaultVisual(display, 0);
        const colormap = xlib.XDefaultColormap(display, 0);

        _ = xlib.XftColorAllocValue(display, visual, colormap, &render_color, &xft_color);
        xlib.XftDrawStringUtf8(self.xft_draw, &xft_color, self.font, x, y, text.ptr, @intCast(text.len));
        xlib.XftColorFree(display, visual, colormap, &xft_color);
    }

    fn text_width(self: *Bar, display: *xlib.Display, text: []const u8) i32 {
        if (self.font == null) return 0;

        var extents: xlib.XGlyphInfo = undefined;
        xlib.XftTextExtentsUtf8(display, self.font, text.ptr, @intCast(text.len), &extents);
        return extents.xOff;
    }
};

// Bar list helpers >.<

/// Marks all bars in the list as needing a redraw.
pub fn invalidate_bars(bars: ?*Bar) void {
    var current = bars;
    while (current) |bar| {
        bar.invalidate();
        current = bar.next;
    }
}

/// Destroys all bars in the list and frees their resources.
pub fn destroy_bars(bars: ?*Bar, allocator: std.mem.Allocator, display: *xlib.Display) void {
    var current = bars;
    while (current) |bar| {
        const next = bar.next;
        bar.destroy(allocator, display);
        current = next;
    }
}

/// Returns the bar whose window matches `win`, or null.
pub fn window_to_bar(bars: ?*Bar, win: xlib.Window) ?*Bar {
    var current = bars;
    while (current) |bar| {
        if (bar.window == win) return bar;
        current = bar.next;
    }
    return null;
}

fn has_clients_on_tag(monitor: *Monitor, tag_mask: u32) bool {
    var current = monitor.clients;
    while (current) |client| {
        if ((client.tags & tag_mask) != 0) return true;
        current = client.next;
    }
    return false;
}