server-configuration/src/main.zig

pub const main = seizer.main;

const APPNAME = "seizer-solitaire";

var prng: std.rand.DefaultPrng = undefined;
var window_global: seizer.Window = undefined;
var canvas: seizer.Canvas = undefined;
var card_tilemap: ?DeckSprites = null;

var draw_pile: std.ArrayListUnmanaged(Card) = .{};
var draw_pile_exhausted = false;
var drawn_cards: std.ArrayListUnmanaged(Card) = .{};
var stacks: [7]std.ArrayListUnmanaged(Card) = [_]std.ArrayListUnmanaged(Card){.{}} ** 7;
var foundations: [4]std.ArrayListUnmanaged(Card) = [_]std.ArrayListUnmanaged(Card){.{}} ** 4;

var history: std.ArrayListUnmanaged(Snapshot) = .{};

var last_hovered_stack: usize = 0;
var last_hovered_foundation: usize = 0;
var hovered_deck: ?*std.ArrayListUnmanaged(Card) = null;
var hovered_card: usize = 0;

var selected_deck: ?*std.ArrayListUnmanaged(Card) = null;
var selected_card: usize = 0;

var show_menu: bool = false;
var menu_item_selected: u32 = 0;
const MENU_ITEMS = [_][]const u8{
    "Continue",
    "New Game",
    "Quit",
};

var win_count: ?u32 = null;
var win_triggered: bool = false;
var frame_count: u64 = 0;

pub fn init() !void {
    prng = std.rand.DefaultPrng.init(@bitCast(std.time.timestamp()));

    window_global = try seizer.platform.createWindow(.{
        .title = "Seizer Solitaire",
        .on_render = render,
        .on_destroy = destroy,
    });

    canvas = try seizer.Canvas.init(seizer.platform.allocator(), .{});
    errdefer canvas.deinit();

    card_tilemap = try assets.loadSolitaireCards(seizer.platform.allocator());

    try resetGame();

    try seizer.platform.addButtonInput(.{
        .title = "move_up",
        .on_event = moveUp,
        .default_bindings = &.{
            .{ .gamepad = .dpup },
            .{ .keyboard = .up },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "move_down",
        .on_event = moveDown,
        .default_bindings = &.{
            .{ .gamepad = .dpdown },
            .{ .keyboard = .down },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "move_left",
        .on_event = moveLeft,
        .default_bindings = &.{
            .{ .gamepad = .dpleft },
            .{ .keyboard = .left },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "move_right",
        .on_event = moveRight,
        .default_bindings = &.{
            .{ .gamepad = .dpright },
            .{ .keyboard = .right },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "select_or_place",
        .on_event = doSelectOrPlace,
        .default_bindings = &.{
            .{ .gamepad = .a },
            .{ .keyboard = .z },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "deselect",
        .on_event = deselect,
        .default_bindings = &.{
            .{ .gamepad = .b },
            .{ .keyboard = .x },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "toggle_menu",
        .on_event = toggleMenu,
        .default_bindings = &.{
            .{ .gamepad = .start },
            .{ .keyboard = .esc },
        },
    });
    try seizer.platform.addButtonInput(.{
        .title = "undo",
        .on_event = undo,
        .default_bindings = &.{
            .{ .gamepad = .x },
            .{ .keyboard = .a },
        },
    });

    const read_buffer = try seizer.platform.allocator().alloc(u8, @sizeOf(u32));
    seizer.platform.readFile(.{
        .appname = APPNAME,
        .path = "win_count.bin",
        .buffer = read_buffer,
        .callback = onWinCountRead,
        .userdata = read_buffer.ptr,
    });
}

fn onWinCountRead(userdata: ?*anyopaque, result: seizer.Platform.FileError![]const u8) void {
    const buffer: *[4]u8 = @ptrCast(userdata);
    defer seizer.platform.allocator().free(buffer);

    if (result) |bytes| {
        if (bytes.len >= @sizeOf(u32)) {
            win_count = std.mem.readInt(u32, bytes[0..4], .little);
        }
    } else |_| {}
}

fn onWinCountWritten(userdata: ?*anyopaque, result: seizer.Platform.FileError!void) void {
    const buffer: *u32 = @ptrCast(@alignCast(userdata));
    defer seizer.platform.allocator().destroy(buffer);
    _ = result catch {};
}

fn resetGame() !void {
    resetHistory();
    draw_pile.deinit(seizer.platform.allocator());
    draw_pile_exhausted = false;
    drawn_cards.shrinkRetainingCapacity(0);
    for (&stacks) |*stack| {
        stack.shrinkRetainingCapacity(0);
    }
    for (&foundations) |*foundation| {
        foundation.shrinkRetainingCapacity(0);
    }

    last_hovered_stack = 0;
    last_hovered_foundation = 0;
    hovered_deck = null;
    hovered_card = 0;

    selected_deck = null;
    selected_card = 0;

    draw_pile = std.ArrayListUnmanaged(Card).fromOwnedSlice(try makeStandardDeck(seizer.platform.allocator()));
    prng.random().shuffle(Card, draw_pile.items);

    for (&stacks, 0..) |*stack, i| {
        for (0..i + 1) |_| {
            const drawn_card = draw_pile.pop();
            try stack.append(seizer.platform.allocator(), drawn_card);
        }
    }

    win_triggered = false;
}

fn resetHistory() void {
    for (history.items) |*snapshot| {
        snapshot.deinit();
    }
    history.shrinkRetainingCapacity(0);
}

fn destroy(window: seizer.Window) void {
    _ = window;
    for (history.items) |*snapshot| {
        snapshot.deinit();
    }
    history.deinit(seizer.platform.allocator());

    draw_pile.deinit(seizer.platform.allocator());
    drawn_cards.deinit(seizer.platform.allocator());
    for (&stacks) |*stack| {
        stack.deinit(seizer.platform.allocator());
    }
    for (&foundations) |*foundation| {
        foundation.deinit(seizer.platform.allocator());
    }

    if (card_tilemap) |*ct| {
        ct.deinit(seizer.platform.allocator());
        card_tilemap = null;
    }
    canvas.deinit();
}

fn render(window: seizer.Window) !void {
    if (haveWon() and !win_triggered and win_count != null) {
        win_count.? += 1;

        const win_count_write_buffer = try seizer.platform.allocator().create(u32);
        std.mem.writeInt(u32, std.mem.asBytes(win_count_write_buffer), win_count.?, .little);
        seizer.platform.writeFile(.{
            .appname = APPNAME,
            .path = "win_count.bin",
            .data = std.mem.asBytes(win_count_write_buffer),
            .callback = onWinCountWritten,
            .userdata = win_count_write_buffer,
        });

        resetHistory();
        win_triggered = true;
    }

    gl.clearColor(0.2, 0.4, 0.2, 1.0);
    gl.clear(gl.COLOR_BUFFER_BIT);

    canvas.begin(.{
        .window_size = window.getSize(),
        .framebuffer_size = window.getFramebufferSize(),
    });

    const scale: u32 = if (canvas.window_size[1] <= 400) 1 else 2;
    const scalef: f32 = @floatFromInt(scale);
    const tile_size = [2]u32{
        card_tilemap.?.tilesheet.tile_size[0] * scale,
        card_tilemap.?.tilesheet.tile_size[1] * scale,
    };
    const margin = card_tilemap.?.margin * scale;
    const marginf: f32 = @floatFromInt(card_tilemap.?.margin * scale);
    const hand_offset = [2]u32{
        card_tilemap.?.hand_offset[0] * scale,
        card_tilemap.?.hand_offset[1] * scale,
    };
    const hand_offsetf = [2]f32{
        @floatFromInt(hand_offset[0]),
        @floatFromInt(hand_offset[1]),
    };
    const tile_sizef = [2]f32{ @floatFromInt(tile_size[0]), @floatFromInt(tile_size[1]) };

    const space_taken_by_board = [2]f32{
        @floatFromInt(2 * margin + 8 * (margin + tile_size[0])),
        @floatFromInt(2 * margin + 5 * (margin + tile_size[1])),
    };
    const board_offset = [2]f32{
        @floor((canvas.window_size[0] - space_taken_by_board[0]) / 2),
        @floor((canvas.window_size[1] - space_taken_by_board[1]) / 2),
    };

    if (win_count) |w| {
        _ = canvas.printText(
            .{
                canvas.window_size[0] - board_offset[0] - marginf - hand_offsetf[0],
                board_offset[1] + marginf + hand_offsetf[1],
            },
            "Win Count: {}",
            .{w},
            .{ .@"align" = .right, .scale = scalef },
        );
    } else {
        const throbber_character: u8 = switch ((frame_count / 5) % 8) {
            0 => '-',
            1 => '\\',
            2 => '|',
            3 => '/',
            4 => '-',
            5 => '\\',
            6 => '|',
            7 => '/',
            else => unreachable,
        };
        _ = canvas.printText(
            .{
                canvas.window_size[0] - board_offset[0] - marginf - hand_offsetf[0],
                board_offset[1] + marginf + hand_offsetf[1],
            },
            "Win Count: [{c}]",
            .{throbber_character},
            .{ .@"align" = .right, .scale = scalef },
        );
    }

    for (&stacks, 0..) |*stack, i| {
        const deck_is_selected = selected_deck != null and selected_deck.? == stack;
        const deck_is_hovered = hovered_deck != null and hovered_deck.? == stack;
        const deck_color = if (deck_is_selected)
            [4]u8{ 0xFF, 0xA0, 0xA0, 0xFF }
        else if (deck_is_hovered)
            [4]u8{ 0xA0, 0xFF, 0xA0, 0xFF }
        else
            [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };

        var pos = [2]f32{
            @floor(@as(f32, @floatFromInt(margin + ((tile_size[0] + margin) * (i + 1))))),
            @floor(@as(f32, @floatFromInt(margin + margin + tile_size[1]))),
        };
        pos[0] += board_offset[0];
        pos[1] += board_offset[1];
        canvas.rect(pos, tile_sizef, .{ .color = deck_color });

        for (stack.items, 0..) |card, j| {
            const is_selected = deck_is_selected and j >= selected_card;
            const is_hovered = deck_is_hovered and j >= hovered_card;
            const color = if (is_selected)
                [4]u8{ 0xFF, 0xA0, 0xA0, 0xFF }
            else if (is_hovered)
                [4]u8{ 0xA0, 0xFF, 0xA0, 0xFF }
            else
                [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };

            const tile_id = card_tilemap.?.getTileForCard(card);
            card_tilemap.?.tilesheet.renderTile(&canvas, tile_id, pos, .{
                .size = tile_sizef,
                .color = color,
            });
            pos[1] += @floatFromInt(hand_offset[1]);
        }
    }

    if (haveWon()) {
        const offset =
            [2]f32{
            2 * marginf + tile_sizef[0],
            2 * marginf + tile_sizef[1],
        };
        _ = canvas.writeText(
            .{
                board_offset[0] + offset[0] + (space_taken_by_board[0] - offset[0]) / 2,
                board_offset[1] + offset[1] + (space_taken_by_board[1] - offset[0]) / 2,
            },
            "You Win!",
            .{
                .baseline = .middle,
                .@"align" = .center,
                .scale = 2 * scalef,
            },
        );
    }

    for (&foundations, 0..) |*foundation, i| {
        const is_hovered = hovered_deck != null and hovered_deck.? == foundation;
        const color = if (is_hovered) [4]u8{ 0xA0, 0xFF, 0xA0, 0xFF } else [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };

        var pos = [2]f32{
            @floatFromInt(margin),
            @floatFromInt(margin + ((margin + tile_size[1]) * (i + 1))),
        };
        pos[0] += board_offset[0];
        pos[1] += board_offset[1];
        canvas.rect(pos, tile_sizef, .{ .color = color });

        for (foundation.items) |card| {
            const tile_id = card_tilemap.?.getTileForCard(card);
            card_tilemap.?.tilesheet.renderTile(&canvas, tile_id, pos, .{
                .size = tile_sizef,
                .color = color,
            });
            pos[1] -= 0.25 * scalef;
        }
    }

    {
        const deck_is_selected = selected_deck != null and selected_deck.? == &drawn_cards;
        const deck_is_hovered = hovered_deck != null and hovered_deck.? == &drawn_cards;

        var pos = [2]f32{
            @floatFromInt(margin + margin + tile_size[0]),
            @floatFromInt(margin),
        };
        pos[0] += board_offset[0];
        pos[1] += board_offset[1];
        for (drawn_cards.items, 0..) |card, j| {
            const is_selected = deck_is_selected and j >= selected_card;
            const is_hovered = deck_is_hovered and j >= hovered_card;
            const color = if (is_selected)
                [4]u8{ 0xFF, 0xA0, 0xA0, 0xFF }
            else if (is_hovered)
                [4]u8{ 0xA0, 0xFF, 0xA0, 0xFF }
            else
                [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };

            const tile_id = card_tilemap.?.getTileForCard(card);
            card_tilemap.?.tilesheet.renderTile(&canvas, tile_id, pos, .{
                .size = tile_sizef,
                .color = color,
            });
            pos[0] += @floatFromInt(hand_offset[0]);
        }
    }

    {
        const is_selected = selected_deck != null and selected_deck.? == &draw_pile;
        const is_hovered = hovered_deck != null and hovered_deck.? == &draw_pile;
        const color = if (is_selected)
            [4]u8{ 0xFF, 0xA0, 0xA0, 0xFF }
        else if (is_hovered)
            [4]u8{ 0xA0, 0xFF, 0xA0, 0xFF }
        else
            [4]u8{ 0xFF, 0xFF, 0xFF, 0xFF };

        var pos = [2]f32{ @floatFromInt(margin), @floatFromInt(margin) };
        pos[0] += board_offset[0];
        pos[1] += board_offset[1];
        canvas.rect(pos, tile_sizef, .{ .color = color });

        for (draw_pile.items) |card| {
            const tile_id = if (!draw_pile_exhausted) card_tilemap.?.back else card_tilemap.?.getTileForCard(card);
            card_tilemap.?.tilesheet.renderTile(&canvas, tile_id, pos, .{
                .size = tile_sizef,
                .color = color,
            });
            pos[1] -= 0.25 * scalef;
        }
    }

    if (show_menu) {
        canvas.rect(
            .{ canvas.window_size[0] / 3, canvas.window_size[1] / 3 },
            .{ canvas.window_size[0] / 3, canvas.window_size[1] / 3 },
            .{ .color = .{ 0, 0, 0, 0xFF } },
        );
        const x: f32 = canvas.window_size[0] / 2;
        var y: f32 = canvas.window_size[1] / 3 + (canvas.font.lineHeight * scalef);
        for (MENU_ITEMS, 0..) |menu_item, i| {
            if (i == menu_item_selected) {
                const size = canvas.printText(.{ x, y }, "> {s} <", .{menu_item}, .{ .@"align" = .center, .scale = scalef });
                y += size[1];
            } else {
                const size = canvas.writeText(.{ x, y }, menu_item, .{ .@"align" = .center, .scale = scalef });
                y += size[1];
            }
        }
    }

    canvas.end();

    frame_count +%= 1;
}

pub fn haveWon() bool {
    if (draw_pile.items.len > 0) return false;
    if (drawn_cards.items.len > 0) return false;
    for (stacks) |stack| {
        if (stack.items.len > 0) return false;
    }
    return true;
}

pub fn makeStandardDeck(allocator: std.mem.Allocator) ![]Card {
    var deck = try allocator.alloc(Card, 52);
    errdefer allocator.free(deck);

    var next_index: usize = 0;
    for (0..4) |suit| {
        for (1..14) |rank| {
            deck[next_index] = Card{
                .suit = @enumFromInt(suit),
                .rank = @intCast(rank),
            };
            next_index += 1;
        }
    }

    return deck;
}

pub fn deselect(pressed: bool) !void {
    if (!pressed) return;
    if (show_menu) return;
    selected_deck = null;
    selected_card = 0;
}

pub fn doSelectOrPlace(pressed: bool) !void {
    if (!pressed) return;
    if (show_menu) {
        const menu_item = MENU_ITEMS[menu_item_selected];
        if (std.mem.eql(u8, menu_item, "Continue")) {
            show_menu = false;
        } else if (std.mem.eql(u8, menu_item, "New Game")) {
            try resetGame();
            show_menu = false;
        } else if (std.mem.eql(u8, menu_item, "Quit")) {
            window_global.setShouldClose(true);
        }
        return;
    }
    if (selected_deck == null) {
        if (hovered_deck == &draw_pile and !draw_pile_exhausted) {
            resetHistory();
            drawn_cards.ensureUnusedCapacity(seizer.platform.allocator(), 3) catch return;
            for (0..3) |_| {
                if (draw_pile.popOrNull()) |card| drawn_cards.appendAssumeCapacity(card);
            }
            if (draw_pile.items.len == 0) {
                draw_pile_exhausted = true;
            }
        } else if (hovered_deck == &draw_pile and draw_pile_exhausted) {
            selected_deck = hovered_deck;
            selected_card = hovered_card;
        } else if (hovered_deck == &drawn_cards) {
            selected_deck = hovered_deck;
            selected_card = hovered_card;
        } else {
            for (stacks[0..]) |*stack| {
                if (hovered_deck != stack) continue;
                selected_deck = hovered_deck;
                selected_card = hovered_card;
                break;
            }
        }
    } else if (hovered_deck == selected_deck) {
        var snapshot = try Snapshot.initFromCurrentGlobalState();
        const selected_substack = selected_deck.?.items[selected_card..];

        // try to move all selected cards into the foundations
        var cards_moved = false;
        move_cards_to_foundations: for (0..selected_substack.len) |_| {
            for (foundations[0..]) |*foundation| {
                if (hovered_deck == foundation) break :move_cards_to_foundations;
            }

            for (foundations[0..]) |*foundation| {
                const empty = foundation.items.len == 0;
                const ace = selected_deck.?.items[selected_card].rank == 1;
                const suit_matches = !empty and foundation.items[foundation.items.len - 1].suit == selected_deck.?.items[selected_deck.?.items.len - 1].suit;
                const is_next_rank = !empty and foundation.items[foundation.items.len - 1].rank + 1 == selected_deck.?.items[selected_deck.?.items.len - 1].rank;
                if ((empty and ace) or (suit_matches and is_next_rank)) {
                    foundation.ensureUnusedCapacity(seizer.platform.allocator(), 1) catch continue;
                    foundation.appendAssumeCapacity(selected_deck.?.pop());

                    hovered_card = if (hovered_deck.? == &drawn_cards)
                        hovered_deck.?.items.len -| 1
                    else
                        indexOfTopOfStack(hovered_deck.?.items);

                    cards_moved = true;
                    break;
                }
            } else {
                break :move_cards_to_foundations;
            }
        }

        if (cards_moved) {
            try history.append(seizer.platform.allocator(), snapshot);
        } else {
            snapshot.deinit();
        }

        selected_deck = null;
    } else {
        var cards_moved = false;
        var snapshot = try Snapshot.initFromCurrentGlobalState();
        if (selected_deck) |selected| move_from_selected_to_hovered: {
            const selected_substack = selected.items[selected_card..];
            if (selected_substack.len == 0) break :move_from_selected_to_hovered;

            const hovered = hovered_deck orelse break :move_from_selected_to_hovered;

            if (hovered.items.len == 0) {
                for (stacks[0..]) |*stack| {
                    if (hovered != stack) continue;
                    hovered.ensureUnusedCapacity(seizer.platform.allocator(), selected_substack.len) catch break :move_from_selected_to_hovered;
                    hovered.appendSliceAssumeCapacity(selected_substack);
                    selected.shrinkRetainingCapacity(selected.items.len - selected_substack.len);
                    hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                    cards_moved = true;
                    break :move_from_selected_to_hovered;
                }

                if (selected_substack.len == 1) {
                    if (draw_pile_exhausted and hovered == &draw_pile and draw_pile.items.len == 0) {
                        hovered.ensureUnusedCapacity(seizer.platform.allocator(), 1) catch break :move_from_selected_to_hovered;
                        hovered.appendAssumeCapacity(selected_deck.?.pop());
                        hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                        cards_moved = true;
                        break :move_from_selected_to_hovered;
                    } else for (foundations[0..]) |*foundation| {
                        if (foundation != selected) continue;
                        const empty = foundation.items.len == 0;
                        const ace = selected_deck.?.items[selected_card].rank == 1;
                        const suit_matches = !empty and foundation.items[foundation.items.len - 1].suit == selected_deck.?.items[selected_deck.?.items.len - 1].suit;
                        const is_next_rank = !empty and foundation.items[foundation.items.len - 1].rank + 1 == selected_deck.?.items[selected_deck.?.items.len - 1].rank;
                        if ((empty and ace) or (suit_matches and is_next_rank)) {
                            foundation.ensureUnusedCapacity(seizer.platform.allocator(), 1) catch continue;
                            foundation.appendAssumeCapacity(selected_deck.?.pop());
                            hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                            cards_moved = true;
                            break :move_from_selected_to_hovered;
                        }
                    }
                }

                break :move_from_selected_to_hovered;
            }

            if (hovered.items[hovered.items.len - 1].rank - 1 != selected_substack[0].rank or
                hovered.items[hovered.items.len - 1].suit.color() == selected_substack[0].suit.color())
            {
                break :move_from_selected_to_hovered;
            }
            hovered.ensureUnusedCapacity(seizer.platform.allocator(), selected_substack.len) catch break :move_from_selected_to_hovered;
            hovered.appendSliceAssumeCapacity(selected_substack);
            selected.shrinkRetainingCapacity(selected.items.len - selected_substack.len);
            hovered_card = indexOfTopOfStack(hovered_deck.?.items);
            cards_moved = true;
        }
        if (cards_moved) {
            try history.append(seizer.platform.allocator(), snapshot);
        } else {
            snapshot.deinit();
        }
        selected_deck = null;
    }
}

pub fn moveLeft(pressed: bool) !void {
    if (!pressed) return;
    if (show_menu) return;
    if (hovered_deck == null) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &draw_pile) {
        hovered_deck = &drawn_cards;
        hovered_card = drawn_cards.items.len -| 1;
    } else if (hovered_deck == &drawn_cards) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &stacks[0]) {
        hovered_deck = &foundations[last_hovered_foundation];
    } else {
        for (stacks[1..], 1..) |*stack, i| {
            if (hovered_deck == stack) {
                hovered_deck = &stacks[i - 1];
                hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                last_hovered_stack = i - 1;
                return;
            }
        }
        for (&foundations) |*foundation| {
            if (hovered_deck == foundation) {
                hovered_deck = &stacks[stacks.len - 1];
                hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                return;
            }
        }
    }
}

pub fn moveRight(pressed: bool) !void {
    if (!pressed) return;
    if (show_menu) return;
    if (hovered_deck == null) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &draw_pile) {
        hovered_deck = &drawn_cards;
        hovered_card = drawn_cards.items.len -| 1;
    } else if (hovered_deck == &drawn_cards) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &stacks[stacks.len - 1]) {
        hovered_deck = &foundations[last_hovered_foundation];
    } else {
        for (stacks[0 .. stacks.len - 1], 0..) |*stack, i| {
            if (hovered_deck == stack) {
                hovered_deck = &stacks[i + 1];
                hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                last_hovered_stack = i + 1;
                return;
            }
        }
        for (&foundations) |*foundation| {
            if (hovered_deck == foundation) {
                hovered_deck = &stacks[0];
                hovered_card = indexOfTopOfStack(hovered_deck.?.items);
                return;
            }
        }
    }
}

pub fn moveUp(pressed: bool) !void {
    if (!pressed) return;

    if (show_menu) {
        if (menu_item_selected == 0) menu_item_selected = MENU_ITEMS.len;
        menu_item_selected -= 1;
    } else if (hovered_deck == null) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &draw_pile) {
        hovered_deck = &foundations[foundations.len - 1];
        last_hovered_foundation = foundations.len - 1;
    } else if (hovered_deck == &drawn_cards) {
        hovered_deck = &stacks[last_hovered_stack];
        hovered_card = indexOfTopOfStack(hovered_deck.?.items);
    } else if (hovered_deck == &foundations[0]) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else {
        for (stacks[0..]) |*stack| {
            if (hovered_deck != stack) continue;
            const top_of_stack = indexOfTopOfStack(stack.items);
            if (hovered_card > top_of_stack) {
                hovered_card -= 1;
                return;
            }
            if (drawn_cards.items.len > 0) {
                hovered_deck = &drawn_cards;
                hovered_card = drawn_cards.items.len -| 1;
            } else {
                hovered_deck = &draw_pile;
                hovered_card = 0;
            }
            return;
        }
        for (foundations[1..], 1..) |*foundation, i| {
            if (hovered_deck == foundation) {
                hovered_deck = &foundations[i - 1];
                last_hovered_foundation = i - 1;
                return;
            }
        }
    }
}

pub fn moveDown(pressed: bool) !void {
    if (!pressed) return;
    if (show_menu) {
        menu_item_selected += 1;
        menu_item_selected %= @intCast(MENU_ITEMS.len);
    } else if (hovered_deck == null) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else if (hovered_deck == &draw_pile) {
        hovered_deck = &foundations[0];
        last_hovered_foundation = 0;
    } else if (hovered_deck == &drawn_cards) {
        hovered_deck = &stacks[last_hovered_stack];
        hovered_card = indexOfTopOfStack(hovered_deck.?.items);
    } else if (hovered_deck == &foundations[foundations.len - 1]) {
        hovered_deck = &draw_pile;
        hovered_card = 0;
    } else {
        for (stacks[0..]) |*stack| {
            if (hovered_deck != stack) continue;
            if (hovered_card < stack.items.len -| 1) {
                hovered_card += 1;
                return;
            }

            if (drawn_cards.items.len > 0) {
                hovered_deck = &drawn_cards;
                hovered_card = drawn_cards.items.len -| 1;
            } else {
                hovered_deck = &draw_pile;
                hovered_card = 0;
            }
            return;
        }
        for (foundations[0 .. foundations.len - 1], 0..) |*foundation, i| {
            if (hovered_deck == foundation) {
                hovered_deck = &foundations[i + 1];
                last_hovered_foundation = i + 1;
                return;
            }
        }
    }
}

pub fn undo(pressed: bool) !void {
    if (!pressed) return;
    if (history.popOrNull()) |snapshot_const| {
        var snapshot = snapshot_const;
        defer snapshot.deinit();
        try snapshot.restore();
    }
}

pub fn toggleMenu(pressed: bool) !void {
    if (!pressed) return;
    show_menu = !show_menu;
}

pub fn indexOfTopOfStack(cards: []Card) usize {
    if (cards.len < 2) return 0;

    var index = cards.len - 1;
    while (index > 0) : (index -= 1) {
        const prev_card = cards[index];
        const card = cards[index - 1];
        if (card.suit.color() == prev_card.suit.color()) break;
        if (card.rank != prev_card.rank + 1) break;
    }
    return index;
}

const Snapshot = struct {
    draw_pile: []Card,
    draw_pile_exhausted: bool,
    drawn_cards: []Card,
    stacks: [7][]Card,
    foundations: [4][]Card,
    selected_deck: *std.ArrayListUnmanaged(Card),
    selected_card: usize,

    pub fn initFromCurrentGlobalState() !Snapshot {
        const snapshot_selected_deck = selected_deck orelse return error.InvalidSelectionForSnapshot;

        const snapshot_draw_pile = try seizer.platform.allocator().dupe(Card, draw_pile.items);
        errdefer seizer.platform.allocator().free(snapshot_draw_pile);
        const snapshot_drawn_cards = try seizer.platform.allocator().dupe(Card, drawn_cards.items);
        errdefer seizer.platform.allocator().free(snapshot_drawn_cards);

        var snapshot_stacks: [7][]Card = undefined;
        for (&snapshot_stacks, &stacks) |*snapshot_stack, stack| {
            snapshot_stack.* = try seizer.platform.allocator().dupe(Card, stack.items);
        }

        var snapshot_foundations: [4][]Card = undefined;
        for (&snapshot_foundations, &foundations) |*snapshot_foundation, foundation| {
            snapshot_foundation.* = try seizer.platform.allocator().dupe(Card, foundation.items);
        }

        return Snapshot{
            .draw_pile = snapshot_draw_pile,
            .draw_pile_exhausted = draw_pile_exhausted,
            .drawn_cards = snapshot_drawn_cards,
            .stacks = snapshot_stacks,
            .foundations = snapshot_foundations,
            .selected_deck = snapshot_selected_deck,
            .selected_card = selected_card,
        };
    }

    pub fn deinit(snapshot: *@This()) void {
        seizer.platform.allocator().free(snapshot.draw_pile);
        seizer.platform.allocator().free(snapshot.drawn_cards);
        for (snapshot.stacks) |stack| {
            seizer.platform.allocator().free(stack);
        }
        for (snapshot.foundations) |foundation| {
            seizer.platform.allocator().free(foundation);
        }
    }

    pub fn restore(snapshot: @This()) !void {
        // ensure there is enough space for all the cards
        try draw_pile.ensureTotalCapacity(seizer.platform.allocator(), snapshot.draw_pile.len);
        try drawn_cards.ensureTotalCapacity(seizer.platform.allocator(), snapshot.drawn_cards.len);
        for (&snapshot.stacks, &stacks) |snapshot_stack, *stack| {
            try stack.ensureTotalCapacity(seizer.platform.allocator(), snapshot_stack.len);
        }
        for (&snapshot.foundations, &foundations) |snapshot_foundation, *foundation| {
            try foundation.ensureTotalCapacity(seizer.platform.allocator(), snapshot_foundation.len);
        }

        // reset the state
        draw_pile.shrinkRetainingCapacity(0);
        draw_pile.appendSliceAssumeCapacity(snapshot.draw_pile);

        draw_pile_exhausted = snapshot.draw_pile_exhausted;

        drawn_cards.shrinkRetainingCapacity(0);
        drawn_cards.appendSliceAssumeCapacity(snapshot.drawn_cards);

        for (&snapshot.stacks, &stacks) |snapshot_stack, *stack| {
            stack.shrinkRetainingCapacity(0);
            stack.appendSliceAssumeCapacity(snapshot_stack);
        }

        for (&snapshot.foundations, &foundations) |snapshot_foundation, *foundation| {
            foundation.shrinkRetainingCapacity(0);
            foundation.appendSliceAssumeCapacity(snapshot_foundation);
        }

        selected_deck = null;
        selected_card = 0;
        hovered_deck = snapshot.selected_deck;
        hovered_card = snapshot.selected_card;
    }
};

const DeckSprites = assets.DeckSprites;
const Card = assets.Card;

const assets = @import("./assets.zig");
const builtin = @import("builtin");
const seizer = @import("seizer");
const gl = seizer.gl;
const ecs = seizer.flecs;
const std = @import("std");