const std = @import("std");
const xlib = @import("x11/xlib.zig");
const Monitor = @import("monitor.zig").Monitor;

pub const Client = struct {
    name: [256]u8 = std.mem.zeroes([256]u8),
    min_aspect: f32 = 0,
    max_aspect: f32 = 0,
    x: i32 = 0,
    y: i32 = 0,
    width: i32 = 0,
    height: i32 = 0,
    old_x: i32 = 0,
    old_y: i32 = 0,
    old_width: i32 = 0,
    old_height: i32 = 0,
    base_width: i32 = 0,
    base_height: i32 = 0,
    increment_width: i32 = 0,
    increment_height: i32 = 0,
    max_width: i32 = 0,
    max_height: i32 = 0,
    min_width: i32 = 0,
    min_height: i32 = 0,
    hints_valid: bool = false,
    border_width: i32 = 0,
    old_border_width: i32 = 0,
    tags: u32 = 0,
    is_fixed: bool = false,
    is_floating: bool = false,
    is_urgent: bool = false,
    never_focus: bool = false,
    old_state: bool = false,
    is_fullscreen: bool = false,
    next: ?*Client = null,
    stack_next: ?*Client = null,
    monitor: ?*Monitor = null,
    window: xlib.Window = 0,
};

/// Initialises a new `Client` for the given X window.
pub fn create(allocator: std.mem.Allocator, window: xlib.Window) ?*Client {
    const client = allocator.create(Client) catch return null;
    client.* = Client{ .window = window };
    return client;
}

/// Frees a client previously returned by `create`.
pub fn destroy(allocator: std.mem.Allocator, client: *Client) void {
    allocator.destroy(client);
}

/// Prepends `client` to the front of its monitor's client list.
pub fn attach(client: *Client) void {
    if (client.monitor) |monitor| {
        client.next = monitor.clients;
        monitor.clients = client;
    }
}

/// Removes `client` from its monitor's client list.
pub fn detach(client: *Client) void {
    if (client.monitor) |monitor| {
        var current_ptr: *?*Client = &monitor.clients;
        while (current_ptr.*) |current| {
            if (current == client) {
                current_ptr.* = client.next;
                return;
            }
            current_ptr = &current.next;
        }
    }
}

/// Prepends `client` to the front of its monitor's focus stack.
pub fn attach_stack(client: *Client) void {
    if (client.monitor) |monitor| {
        client.stack_next = monitor.stack;
        monitor.stack = client;
    }
}

/// Removes `client` from its monitor's focus stack.
pub fn detach_stack(client: *Client) void {
    if (client.monitor) |monitor| {
        var current_ptr: *?*Client = &monitor.stack;
        while (current_ptr.*) |current| {
            if (current == client) {
                current_ptr.* = client.stack_next;
                return;
            }
            current_ptr = &current.stack_next;
        }
    }
}

/// Searches all monitors for a client whose X window matches `window`.
///
/// `monitors` is the head of the monitor linked list.
pub fn window_to_client(monitors: ?*Monitor, window: xlib.Window) ?*Client {
    var current_monitor = monitors;
    while (current_monitor) |monitor| {
        var current_client = monitor.clients;
        while (current_client) |client| {
            if (client.window == window) return client;
            current_client = client.next;
        }
        current_monitor = monitor.next;
    }
    return null;
}

/// Returns true if `client` is visible on its monitor's currently selected
/// tag set.
pub fn is_visible(client: *Client) bool {
    if (client.monitor) |monitor| {
        return (client.tags & monitor.tagset[monitor.sel_tags]) != 0;
    }
    return false;
}

/// Returns true if `client` is visible on the given tag bitmask.
pub fn is_visible_on_tag(client: *Client, tags: u32) bool {
    return (client.tags & tags) != 0;
}

/// Returns the first non-floating, visible client at or after `client`.
pub fn next_tiled(client: ?*Client) ?*Client {
    var current = client;
    while (current) |iter| {
        if (!iter.is_floating and is_visible(iter)) return iter;
        current = iter.next;
    }
    return null;
}

/// Returns the first non-floating client on `client`'s monitor that shares
/// any tag with `client`. Used for `attach_aside` ordering.
pub fn next_tagged(client: *Client) ?*Client {
    const monitor = client.monitor orelse return null;
    var walked = monitor.clients;
    while (walked) |iter| {
        if (!iter.is_floating and is_visible_on_tag(iter, client.tags)) return iter;
        walked = iter.next;
    }
    return null;
}

/// Inserts `client` just after the first client that shares its tags,
/// falling back to prepend if none exists.
pub fn attach_aside(client: *Client) void {
    const at = next_tagged(client);
    if (at == null) {
        attach(client);
        return;
    }
    client.next = at.?.next;
    at.?.next = client;
}

/// Counts non-floating, visible clients on `monitor`.
pub fn count_tiled(monitor: *Monitor) u32 {
    var count: u32 = 0;
    var current = next_tiled(monitor.clients);
    while (current) |client| {
        count += 1;
        current = next_tiled(client.next);
    }
    return count;
}

/// Returns the tiled client on `monitor` whose bounds contain (`point_x`,
/// `point_y`), excluding `exclude`.  Returns null if none found.
pub fn tiled_window_at(exclude: *Client, monitor: *Monitor, point_x: i32, point_y: i32) ?*Client {
    const tags = monitor.tagset[monitor.sel_tags];
    var current = monitor.clients;

    while (current) |client| {
        if (client != exclude and !client.is_floating and (client.tags & tags) != 0) {
            const client_w = client.width + client.border_width * 2;
            const client_h = client.height + client.border_width * 2;

            if (point_x >= client.x and point_x < client.x + client_w and
                point_y >= client.y and point_y < client.y + client_h)
            {
                return client;
            }
        }
        current = client.next;
    }
    return null;
}

/// Moves `client` to just before `target` in the monitor's client list.
/// Does nothing if they are on different monitors.
pub fn insert_before(client: *Client, target: *Client) void {
    const monitor = target.monitor orelse return;
    if (client.monitor != monitor) return;

    detach(client);

    if (monitor.clients == target) {
        client.next = target;
        monitor.clients = client;
        return;
    }

    var current = monitor.clients;
    while (current) |iter| {
        if (iter.next == target) {
            client.next = target;
            iter.next = client;
            return;
        }
        current = iter.next;
    }
}

/// Swaps the positions of `client_a` and `client_b` in their shared monitor's
/// client list.  Does nothing if they are on different monitors.
pub fn swap_clients(client_a: *Client, client_b: *Client) void {
    const monitor = client_a.monitor orelse return;
    if (client_b.monitor != monitor) return;

    var prev_a: ?*Client = null;
    var prev_b: ?*Client = null;
    var iter = monitor.clients;

    while (iter) |client| {
        if (client.next == client_a) prev_a = client;
        if (client.next == client_b) prev_b = client;
        iter = client.next;
    }

    const next_a = client_a.next;
    const next_b = client_b.next;

    if (next_a == client_b) {
        client_a.next = next_b;
        client_b.next = client_a;
        if (prev_a) |prev| prev.next = client_b else monitor.clients = client_b;
    } else if (next_b == client_a) {
        client_b.next = next_a;
        client_a.next = client_b;
        if (prev_b) |prev| prev.next = client_a else monitor.clients = client_a;
    } else {
        client_a.next = next_b;
        client_b.next = next_a;
        if (prev_a) |prev| prev.next = client_b else monitor.clients = client_b;
        if (prev_b) |prev| prev.next = client_a else monitor.clients = client_a;
    }
}