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

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

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

pub fn scroll(monitor: *Monitor) void {
    var client_count: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |_| : (current = client_mod.next_tiled(current.?.next)) {
        client_count += 1;
    }

    if (client_count == 0) return;

    const gap_outer_h = monitor.gap_outer_h;
    const gap_outer_v = monitor.gap_outer_v;
    const gap_inner_v = monitor.gap_inner_v;

    const visible_count: u32 = @intCast(@max(1, monitor.nmaster));
    const available_width = monitor.win_w - 2 * gap_outer_v;
    const available_height = monitor.win_h - 2 * gap_outer_h;

    const total_gaps = gap_inner_v * @as(i32, @intCast(if (visible_count > 1) visible_count - 1 else 0));
    const window_width = @divTrunc(available_width - total_gaps, @as(i32, @intCast(visible_count)));

    var x_pos: i32 = monitor.win_x + gap_outer_v - monitor.scroll_offset;
    const y_pos: i32 = monitor.win_y + gap_outer_h;
    const height = available_height;

    var index: u32 = 0;
    current = client_mod.next_tiled(monitor.clients);
    while (current) |client| : (current = client_mod.next_tiled(client.next)) {
        const window_right = x_pos + window_width;
        const screen_left = monitor.win_x;
        const screen_right = monitor.win_x + monitor.win_w;
        const is_visible = window_right > screen_left and x_pos < screen_right;

        if (is_visible) {
            tiling.resize(
                client,
                x_pos,
                y_pos,
                window_width - 2 * client.border_width,
                height - 2 * client.border_width,
                false,
            );
        } else {
            tiling.resize_client(
                client,
                -2 * window_width,
                y_pos,
                window_width - 2 * client.border_width,
                height - 2 * client.border_width,
            );
        }
        x_pos += window_width + gap_inner_v;
        index += 1;
    }
}

pub fn get_scroll_step(monitor: *Monitor) i32 {
    const gap_outer_v = monitor.gap_outer_v;
    const gap_inner_v = monitor.gap_inner_v;
    const visible_count: u32 = @intCast(@max(1, monitor.nmaster));
    const available_width = monitor.win_w - 2 * gap_outer_v;
    const total_gaps = gap_inner_v * @as(i32, @intCast(if (visible_count > 1) visible_count - 1 else 0));
    const window_width = @divTrunc(available_width - total_gaps, @as(i32, @intCast(visible_count)));
    return window_width + gap_inner_v;
}

pub fn get_max_scroll(monitor: *Monitor) i32 {
    var client_count: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |_| : (current = client_mod.next_tiled(current.?.next)) {
        client_count += 1;
    }

    const visible_count: u32 = @intCast(@max(1, monitor.nmaster));
    if (client_count <= visible_count) return 0;

    const scroll_step = get_scroll_step(monitor);
    const scrollable = client_count - visible_count;
    return scroll_step * @as(i32, @intCast(scrollable));
}

pub fn get_window_index(monitor: *Monitor, target: *Client) ?u32 {
    var index: u32 = 0;
    var current = client_mod.next_tiled(monitor.clients);
    while (current) |client| : (current = client_mod.next_tiled(client.next)) {
        if (client == target) return index;
        index += 1;
    }
    return null;
}

pub fn get_target_scroll_for_window(monitor: *Monitor, target: *Client) i32 {
    const index = get_window_index(monitor, target) orelse return 0;
    if (index == 0) return 0;

    const scroll_step = get_scroll_step(monitor);
    const max_scroll = get_max_scroll(monitor);

    const target_scroll = scroll_step * @as(i32, @intCast(index));
    return @min(target_scroll, max_scroll);
}