const std = @import("std");
const xlib = @import("x11/xlib.zig");
const Client = @import("client.zig").Client;

pub const Layout = struct {
    symbol: []const u8,
    arrange_fn: ?*const fn (*Monitor) void,
};

pub const Pertag = struct {
    curtag: u32 = 1,
    prevtag: u32 = 1,
    nmasters: [10]i32 = [_]i32{1} ** 10,
    mfacts: [10]f32 = [_]f32{0.55} ** 10,
    sellts: [10]u32 = [_]u32{0} ** 10,
    ltidxs: [10][5]?*const Layout = [_][5]?*const Layout{.{ null, null, null, null, null }} ** 10,
    showbars: [10]bool = [_]bool{true} ** 10,
};

pub const Monitor = struct {
    lt_symbol: [16]u8 = std.mem.zeroes([16]u8),
    mfact: f32 = 0.55,
    nmaster: i32 = 1,
    num: i32 = 0,
    bar_y: i32 = 0,
    mon_x: i32 = 0,
    mon_y: i32 = 0,
    mon_w: i32 = 0,
    mon_h: i32 = 0,
    win_x: i32 = 0,
    win_y: i32 = 0,
    win_w: i32 = 0,
    win_h: i32 = 0,
    gap_inner_h: i32 = 0,
    gap_inner_v: i32 = 0,
    gap_outer_h: i32 = 0,
    gap_outer_v: i32 = 0,
    scroll_offset: i32 = 0,
    sel_tags: u32 = 0,
    sel_lt: u32 = 0,
    tagset: [2]u32 = .{ 1, 1 },
    show_bar: bool = true,
    top_bar: bool = true,
    clients: ?*Client = null,
    sel: ?*Client = null,
    stack: ?*Client = null,
    next: ?*Monitor = null,
    bar_win: xlib.Window = 0,
    lt: [5]?*const Layout = .{ null, null, null, null, null },
    pertag: Pertag = Pertag{},
};

pub var monitors: ?*Monitor = null;
pub var selected_monitor: ?*Monitor = null;

var allocator: std.mem.Allocator = undefined;

pub fn init(alloc: std.mem.Allocator) void {
    allocator = alloc;
}

pub fn create() ?*Monitor {
    const mon = allocator.create(Monitor) catch return null;
    mon.* = Monitor{};
    return mon;
}

pub fn destroy(mon: *Monitor) void {
    allocator.destroy(mon);
}

var root_window: xlib.Window = 0;
var display_handle: ?*xlib.Display = null;

pub fn set_root_window(root: xlib.Window, display: *xlib.Display) void {
    root_window = root;
    display_handle = display;
}

pub fn window_to_monitor(win: xlib.Window) ?*Monitor {
    if (win == root_window and display_handle != null) {
        var root_x: c_int = undefined;
        var root_y: c_int = undefined;
        var dummy_win: xlib.Window = undefined;
        var dummy_int: c_int = undefined;
        var dummy_uint: c_uint = undefined;
        if (xlib.XQueryPointer(display_handle.?, root_window, &dummy_win, &dummy_win, &root_x, &root_y, &dummy_int, &dummy_int, &dummy_uint) != 0) {
            return rect_to_monitor(root_x, root_y, 1, 1);
        }
    }

    var current = monitors;
    while (current) |monitor| {
        if (monitor.bar_win == win) {
            return monitor;
        }
        current = monitor.next;
    }

    const client = @import("client.zig").window_to_client(win);
    if (client) |found_client| {
        return found_client.monitor;
    }

    return selected_monitor;
}

pub fn rect_to_monitor(x: i32, y: i32, width: i32, height: i32) ?*Monitor {
    var result = selected_monitor;
    var max_area: i32 = 0;

    var current = monitors;
    while (current) |monitor| {
        const intersect_x = @max(0, @min(x + width, monitor.win_x + monitor.win_w) - @max(x, monitor.win_x));
        const intersect_y = @max(0, @min(y + height, monitor.win_y + monitor.win_h) - @max(y, monitor.win_y));
        const area = intersect_x * intersect_y;
        if (area > max_area) {
            max_area = area;
            result = monitor;
        }
        current = monitor.next;
    }
    return result;
}

pub fn dir_to_monitor(direction: i32) ?*Monitor {
    var target: ?*Monitor = null;

    if (direction > 0) {
        target = if (selected_monitor) |current| current.next else null;
        if (target == null) {
            target = monitors;
        }
    } else if (selected_monitor == monitors) {
        var last = monitors;
        while (last) |iter| {
            if (iter.next == null) {
                target = iter;
                break;
            }
            last = iter.next;
        }
    } else {
        var previous = monitors;
        while (previous) |iter| {
            if (iter.next == selected_monitor) {
                target = iter;
                break;
            }
            previous = iter.next;
        }
    }
    return target;
}