const std = @import("std");
const client_mod = @import("../client.zig");
const monitor_mod = @import("../monitor.zig");
const xlib = @import("../x11/xlib.zig");

const Client = client_mod.Client;
const Monitor = monitor_mod.Monitor;

pub const layout = monitor_mod.Layout{
    .symbol = "[]=",
    .arrange_fn = tile,
};

pub var display_handle: ?*xlib.Display = null;
pub var screen_width: i32 = 0;
pub var screen_height: i32 = 0;
pub var bar_height: i32 = 0;

pub fn set_display(display: *xlib.Display) void {
    display_handle = display;
}

pub fn set_screen_size(width: i32, height: i32) void {
    screen_width = width;
    screen_height = height;
}

pub fn set_bar_height(height: i32) void {
    bar_height = height;
}

pub fn tile(monitor: *Monitor) void {
    var gap_outer_h: i32 = 0;
    var gap_outer_v: i32 = 0;
    var gap_inner_h: i32 = 0;
    var gap_inner_v: i32 = 0;
    var client_count: u32 = 0;

    get_gaps(monitor, &gap_outer_h, &gap_outer_v, &gap_inner_h, &gap_inner_v, &client_count);
    if (client_count == 0) return;

    const nmaster: i32 = monitor.nmaster;
    const nmaster_count: u32 = @intCast(@max(0, nmaster));

    const master_x: i32 = monitor.win_x + gap_outer_v;
    var master_y: i32 = monitor.win_y + gap_outer_h;
    const master_height: i32 = monitor.win_h - 2 * gap_outer_h - gap_inner_h * (@as(i32, @intCast(@min(client_count, nmaster_count))) - 1);
    var master_width: i32 = monitor.win_w - 2 * gap_outer_v;

    var stack_x: i32 = master_x;
    var stack_y: i32 = monitor.win_y + gap_outer_h;
    const stack_height: i32 = monitor.win_h - 2 * gap_outer_h - gap_inner_h * (@as(i32, @intCast(client_count)) - nmaster - 1);
    var stack_width: i32 = master_width;

    if (nmaster > 0 and client_count > nmaster_count) {
        stack_width = @intFromFloat(@as(f32, @floatFromInt(master_width - gap_inner_v)) * (1.0 - monitor.mfact));
        master_width = master_width - gap_inner_v - stack_width;
        stack_x = master_x + master_width + gap_inner_v;
    }

    var master_facts: f32 = 0;
    var stack_facts: f32 = 0;
    var master_rest: i32 = 0;
    var stack_rest: i32 = 0;
    get_facts(monitor, master_height, stack_height, &master_facts, &stack_facts, &master_rest, &stack_rest);

    var index: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |client| : (current = client_mod.next_tiled(client.next)) {
        if (index < nmaster_count) {
            const height = @as(i32, @intFromFloat(@as(f32, @floatFromInt(master_height)) / master_facts)) + (if (index < @as(u32, @intCast(master_rest))) @as(i32, 1) else @as(i32, 0)) - 2 * client.border_width;
            resize(client, master_x, master_y, master_width - 2 * client.border_width, height, false);
            master_y += get_client_height(client) + gap_inner_h;
        } else {
            const stack_index = index - nmaster_count;
            const height = @as(i32, @intFromFloat(@as(f32, @floatFromInt(stack_height)) / stack_facts)) + (if (stack_index < @as(u32, @intCast(stack_rest))) @as(i32, 1) else @as(i32, 0)) - 2 * client.border_width;
            resize(client, stack_x, stack_y, stack_width - 2 * client.border_width, height, false);
            stack_y += get_client_height(client) + gap_inner_h;
        }
        index += 1;
    }
}

fn get_gaps(monitor: *Monitor, gap_outer_h: *i32, gap_outer_v: *i32, gap_inner_h: *i32, gap_inner_v: *i32, client_count: *u32) void {
    var count: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |client| : (current = client_mod.next_tiled(client.next)) {
        count += 1;
    }

    gap_outer_h.* = monitor.gap_outer_h;
    gap_outer_v.* = monitor.gap_outer_v;
    gap_inner_h.* = monitor.gap_inner_h;
    gap_inner_v.* = monitor.gap_inner_v;
    client_count.* = count;
}

fn get_facts(monitor: *Monitor, master_size: i32, stack_size: i32, master_factor: *f32, stack_factor: *f32, master_rest: *i32, stack_rest: *i32) void {
    var count: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |client| : (current = client_mod.next_tiled(client.next)) {
        count += 1;
    }

    const nmaster_count: u32 = @intCast(@max(0, monitor.nmaster));
    const master_facts: f32 = @floatFromInt(@min(count, nmaster_count));
    const stack_facts: f32 = @floatFromInt(if (count > nmaster_count) count - nmaster_count else 0);

    var master_total: i32 = 0;
    var stack_total: i32 = 0;

    if (master_facts > 0) {
        master_total = @as(i32, @intFromFloat(@as(f32, @floatFromInt(master_size)) / master_facts)) * @as(i32, @intFromFloat(master_facts));
    }
    if (stack_facts > 0) {
        stack_total = @as(i32, @intFromFloat(@as(f32, @floatFromInt(stack_size)) / stack_facts)) * @as(i32, @intFromFloat(stack_facts));
    }

    master_factor.* = master_facts;
    stack_factor.* = stack_facts;
    master_rest.* = master_size - master_total;
    stack_rest.* = stack_size - stack_total;
}

fn get_client_width(client: *Client) i32 {
    return client.width + 2 * client.border_width;
}

fn get_client_height(client: *Client) i32 {
    return client.height + 2 * client.border_width;
}

pub fn apply_size_hints(client: *Client, target_x: *i32, target_y: *i32, target_width: *i32, target_height: *i32, interact: bool) bool {
    const monitor = client.monitor orelse return false;

    target_width.* = @max(1, target_width.*);
    target_height.* = @max(1, target_height.*);

    if (interact) {
        if (target_x.* > screen_width) {
            target_x.* = screen_width - get_client_width(client);
        }
        if (target_y.* > screen_height) {
            target_y.* = screen_height - get_client_height(client);
        }
        if (target_x.* + target_width.* + 2 * client.border_width < 0) {
            target_x.* = 0;
        }
        if (target_y.* + target_height.* + 2 * client.border_width < 0) {
            target_y.* = 0;
        }
    } else {
        if (target_x.* >= monitor.win_x + monitor.win_w) {
            target_x.* = monitor.win_x + monitor.win_w - get_client_width(client);
        }
        if (target_y.* >= monitor.win_y + monitor.win_h) {
            target_y.* = monitor.win_y + monitor.win_h - get_client_height(client);
        }
        if (target_x.* + target_width.* + 2 * client.border_width <= monitor.win_x) {
            target_x.* = monitor.win_x;
        }
        if (target_y.* + target_height.* + 2 * client.border_width <= monitor.win_y) {
            target_y.* = monitor.win_y;
        }
    }

    if (target_height.* < bar_height) {
        target_height.* = bar_height;
    }
    if (target_width.* < bar_height) {
        target_width.* = bar_height;
    }

    if (client.is_floating or monitor.lt[monitor.sel_lt] == null) {
        const base_is_min = client.base_width == client.min_width and client.base_height == client.min_height;

        var adjusted_width = target_width.*;
        var adjusted_height = target_height.*;

        if (!base_is_min) {
            adjusted_width -= client.base_width;
            adjusted_height -= client.base_height;
        }

        if (client.min_aspect > 0 and client.max_aspect > 0) {
            const width_float: f32 = @floatFromInt(adjusted_width);
            const height_float: f32 = @floatFromInt(adjusted_height);
            if (client.max_aspect < width_float / height_float) {
                adjusted_width = @intFromFloat(height_float * client.max_aspect + 0.5);
            } else if (client.min_aspect < height_float / width_float) {
                adjusted_height = @intFromFloat(width_float * client.min_aspect + 0.5);
            }
        }

        if (base_is_min) {
            adjusted_width -= client.base_width;
            adjusted_height -= client.base_height;
        }

        if (client.increment_width > 0) {
            adjusted_width -= @mod(adjusted_width, client.increment_width);
        }
        if (client.increment_height > 0) {
            adjusted_height -= @mod(adjusted_height, client.increment_height);
        }

        target_width.* = @max(adjusted_width + client.base_width, client.min_width);
        target_height.* = @max(adjusted_height + client.base_height, client.min_height);

        if (client.max_width > 0) {
            target_width.* = @min(target_width.*, client.max_width);
        }
        if (client.max_height > 0) {
            target_height.* = @min(target_height.*, client.max_height);
        }
    }

    return target_x.* != client.x or target_y.* != client.y or target_width.* != client.width or target_height.* != client.height;
}

pub fn resize(client: *Client, target_x: i32, target_y: i32, target_width: i32, target_height: i32, interact: bool) void {
    var final_x = target_x;
    var final_y = target_y;
    var final_width = target_width;
    var final_height = target_height;

    if (apply_size_hints(client, &final_x, &final_y, &final_width, &final_height, interact)) {
        resize_client(client, final_x, final_y, final_width, final_height);
    }
}

pub fn resize_client(client: *Client, target_x: i32, target_y: i32, target_width: i32, target_height: i32) void {
    client.old_x = client.x;
    client.old_y = client.y;
    client.old_width = client.width;
    client.old_height = client.height;
    client.x = target_x;
    client.y = target_y;
    client.width = target_width;
    client.height = target_height;

    const display = display_handle orelse return;

    var window_changes: xlib.c.XWindowChanges = undefined;
    window_changes.x = target_x;
    window_changes.y = target_y;
    window_changes.width = @intCast(@max(1, target_width));
    window_changes.height = @intCast(@max(1, target_height));
    window_changes.border_width = client.border_width;

    _ = xlib.c.XConfigureWindow(
        display,
        client.window,
        xlib.c.CWX | xlib.c.CWY | xlib.c.CWWidth | xlib.c.CWHeight | xlib.c.CWBorderWidth,
        &window_changes,
    );

    send_configure(client);
    _ = xlib.XSync(display, xlib.False);
}

pub fn send_configure(client: *Client) void {
    const display = display_handle orelse return;

    var configure_event: xlib.c.XConfigureEvent = undefined;
    configure_event.type = xlib.c.ConfigureNotify;
    configure_event.display = display;
    configure_event.event = client.window;
    configure_event.window = client.window;
    configure_event.x = client.x;
    configure_event.y = client.y;
    configure_event.width = client.width;
    configure_event.height = client.height;
    configure_event.border_width = client.border_width;
    configure_event.above = xlib.None;
    configure_event.override_redirect = xlib.False;

    _ = xlib.c.XSendEvent(display, client.window, xlib.False, xlib.StructureNotifyMask, @ptrCast(&configure_event));
}