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,
};

// TODO: Make clearer, document? refactor?
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,
};

// TODO: Make clearer, document? refactor?
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} ** 5,
    pertag: Pertag = .{},
};

// NOTE: `monitors` and `selected_monitor` will soon be removed, they will
// move to `WindowManager` fields in a future refactor step.  All new
// code should prefer receiving a `*Monitor` or `?*Monitor` as a parameter
// rather than reaching into these globals directly.

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

var allocator: std.mem.Allocator = undefined;

/// Must be called once before any other function in this module.
pub fn init(alloc: std.mem.Allocator) void {
    allocator = alloc;
}

/// Allocates and zero-initialises a new `Monitor`.
pub fn create() ?*Monitor {
    const mon = allocator.create(Monitor) catch return null;
    mon.* = Monitor{};
    return mon;
}

/// Frees a monitor previously returned by `create`.
pub fn destroy(mon: *Monitor) void {
    allocator.destroy(mon);
}

/// Returns the monitor whose bar window or client matches `win`, falling
/// back to a pointer-position query when `win` is the root window.
///
/// `display` and `root` are passed explicitly rather than cached in module
/// state, this keeps ownership clear and avoids a stale-pointer hazard.
pub fn window_to_monitor(display: *xlib.Display, root: xlib.Window, win: xlib.Window) ?*Monitor {
    if (win == root) {
        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, root, &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(monitors, win);
    if (client) |found_client| {
        return found_client.monitor;
    }

    return selected_monitor;
}

/// Returns the monitor with the greatest intersection area with the given
/// rectangle, or `selected_monitor` if no intersection is found.
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;
}

/// Returns the next or previous monitor relative to `selected_monitor`.
///
/// Positive `direction` moves forward through the linked list (wrapping to
/// the head); negative moves backward (wrapping to the tail).
///
// TODO:
// - Change direction to an enum/enum_literal
// - Rename function
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) {
        // Already at head, walk to tail.
        var last = monitors;
        while (last) |iter| {
            if (iter.next == null) {
                target = iter;
                break;
            }
            last = iter.next;
        }
    } else {
        // Walk until we find the node just before selected_monitor.
        var previous = monitors;
        while (previous) |iter| {
            if (iter.next == selected_monitor) {
                target = iter;
                break;
            }
            previous = iter.next;
        }
    }
    return target;
}