pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    raylib.SetConfigFlags(raylib.FLAG_VSYNC_HINT | raylib.FLAG_WINDOW_RESIZABLE);
    raylib.InitWindow(@intFromFloat(screen_width), @intFromFloat(screen_height), "ReX");
    defer raylib.CloseWindow();

    raylib.SetWindowMinSize(480, 272);
    raylib.SetWindowMaxSize(1920, 1080);
    scales.recalculate();

    global_font = raylib.LoadFontEx("font/SCE-PS3-RD-R-LATIN.TTF", 32, 0, 250);
    raylib.SetTextureFilter(global_font.texture, raylib.TEXTURE_FILTER_TRILINEAR);

    // const camera = createCamera();

    var background = Background.init();
    var column = Column.init(
        allocator,
        raylib.LoadTextureFromImage(raylib.GenImageChecked(64, 64, 8, 8, raylib.BLACK, raylib.WHITE)),
        "Game",
    );
    defer column.deinit();

    var item = Item.init(
        raylib.LoadTexture("menu/game/CometCrash/ICON0.PNG"),
        "Comet Crash",
        "",
    );
    try column.appendItem(&item);

    raylib.SetTargetFPS(120);
    while (!raylib.WindowShouldClose()) {
        if (raylib.IsWindowResized()) {
            screen_width = @floatFromInt(raylib.GetScreenWidth());
            screen_height = @floatFromInt(raylib.GetScreenHeight());
            scales.recalculate();
        }
        if (raylib.IsKeyPressed('Z')) item.setBig(!item.big);

        raylib.BeginDrawing();
        defer raylib.EndDrawing();

        background.draw();
        column.draw();

        // {
        //     raylib.BeginMode3D(camera);
        //     defer raylib.EndMode3D();
        // }

        raylib.DrawFPS(1, 1);

        const debug_text = try std.fmt.allocPrint(allocator, "screen size = {d}x{d}", .{ screen_width, screen_height });
        defer allocator.free(debug_text);
        raylib.DrawText(@ptrCast(debug_text), 80, 2, 8, raylib.GREEN);
    }
}

var global_font: raylib.Font = undefined;

var screen_width: f32 = 480;
var screen_height: f32 = 272;

var scales: Scales = undefined;

pub const Scales = struct {
    item_icon_scale: f32,
    item_title_font_size: f32,
    item_subtitle_font_size: f32,

    column_icon_scale: f32,
    column_title_font_size: f32,
    column_position_center: raylib.Vector2,
    column_position_spacing: f32,

    pub fn recalculate(self: *Scales) void {
        self.item_icon_scale = screen_height * 0.72 / screen_height;

        self.column_icon_scale = screen_height * 0.75 / screen_height;
        self.column_title_font_size = screen_height * 13 / screen_height;
        self.column_position_center = .{
            .x = std.math.lerp(0.0, screen_width, 0.18),
            .y = std.math.lerp(0.0, screen_height, 0.15),
        };
        self.column_position_spacing = 64;
    }
};

pub const Column = struct {
    icon: raylib.Texture2D,
    title: []const u8,

    items: std.ArrayList(*Item),

    pub fn init(allocator: Allocator, icon: raylib.Texture2D, title: []const u8) Column {
        raylib.SetTextureFilter(icon, raylib.TEXTURE_FILTER_BILINEAR);
        return .{
            .icon = icon,
            .title = title,
            .items = .init(allocator),
        };
    }

    pub fn deinit(self: *Column) void {
        self.items.deinit();
    }

    pub fn draw(self: *Column) void {
        const icon_position = scales.column_position_center;
        const icon_scale = scales.column_icon_scale;
        const icon_width = @as(f32, @floatFromInt(self.icon.width)) * icon_scale;
        const icon_height = @as(f32, @floatFromInt(self.icon.height)) * icon_scale;

        const title_font_size = scales.column_title_font_size;
        const title_font_spacing = 1.0;
        const title_size = raylib.MeasureTextEx(global_font, @ptrCast(self.title), title_font_size, title_font_spacing);
        const title_position = raylib.Vector2{
            .x = icon_position.x + icon_width / 2.0 - title_size.x / 2.0,
            .y = icon_position.y + icon_height + 6,
        };

        var y: f32 = scales.column_position_center.y + icon_height + title_size.y + 32;
        for (self.items.items) |item| {
            item.position = .{ .x = scales.column_position_center.x, .y = y };
            // item.draw();
            y += 64;
        }

        raylib.DrawTextureEx(self.icon, icon_position, 0, icon_scale, raylib.WHITE);
        raylib.DrawTextEx(global_font, @ptrCast(self.title), title_position, title_font_size, title_font_spacing, raylib.WHITE);
    }

    pub fn appendItem(self: *Column, item: *Item) !void {
        try self.items.append(item);
    }

    pub fn insertItem(self: *Column, idx: usize, item: *Item) !void {
        try self.items.insert(idx, item);
    }

    pub fn removeItem(self: *Column, idx: usize) void {
        _ = try self.items.orderedRemove(idx);
    }
};

pub const Item = struct {
    time: f32 = 0.0,
    start_scale: f32,
    position: raylib.Vector2 = .{ .x = 0, .y = 0 },
    scale: f32,

    icon: raylib.Texture2D,
    title: []const u8,
    subtitle: []const u8,
    big: bool = true,

    pub fn init(texture: raylib.Texture2D, title: []const u8, subtitle: []const u8) Item {
        raylib.SetTextureFilter(texture, raylib.TEXTURE_FILTER_BILINEAR);
        return .{
            .icon = texture,
            .title = title,
            .subtitle = subtitle,
            .scale = scales.item_icon_scale,
            .start_scale = scales.item_icon_scale,
        };
    }

    pub fn draw(self: *Item) void {
        self.time += raylib.GetFrameTime();
        self.scale = std.math.lerp(
            self.start_scale,
            if (self.big) scales.item_icon_scale else scales.item_icon_scale * 0.5,
            easeOutExpo(self.time / 0.333),
        );

        const title_pos = raylib.Vector2{
            .x = self.position.x + 16 + @as(f32, @floatFromInt(self.icon.width)) * self.scale,
            .y = (self.position.y + @as(f32, @floatFromInt(self.icon.height)) * self.scale) / 2.0,
        };

        raylib.DrawTextureEx(self.icon, self.position, 0, self.scale, raylib.WHITE);
        raylib.DrawTextEx(global_font, @ptrCast(self.title), title_pos, 18.0, 1, raylib.WHITE);
    }

    pub fn setBig(self: *Item, big: bool) void {
        self.big = big;
        self.time = 0;
        self.start_scale = self.scale;
    }

    fn easeOutExpo(x: f32) f32 {
        return 1.0 - std.math.pow(f32, 2, -10 * std.math.clamp(x, 0.0, 1.0));
    }
};

/// Draws the dynamic gradient background.
// TODO shift based on time of day
// TODO image wallpaper
// TODO slideshow wallpaper
// TODO animated image wallpaper
pub const Background = struct {
    top_left: Color,
    top_right: Color,
    bottom_right: Color,
    bottom_left: Color,

    pub fn init() Background {
        var self: Background = undefined;
        self.setColors(NIGHT_08);
        return self;
    }

    pub fn setColors(self: *Background, colors: [4]Color) void {
        self.top_left = colors[0];
        self.bottom_right = colors[1];
        self.top_right = colors[2];
        self.bottom_left = colors[3];
    }

    pub fn draw(self: *Background) void {
        raylib.DrawRectangleGradientEx(
            .{
                .x = 0,
                .y = 0,
                .width = screen_width,
                .height = screen_height,
            },
            self.top_left.toRaylib(),
            self.bottom_left.toRaylib(),
            self.top_right.toRaylib(),
            self.bottom_right.toRaylib(),
        );
    }

    pub const Color = struct {
        r: f32,
        g: f32,
        b: f32,

        fn toRaylib(self: Color) raylib.Color {
            return .{
                .r = @intFromFloat(self.r * 255.0),
                .g = @intFromFloat(self.g * 255.0),
                .b = @intFromFloat(self.b * 255.0),
                .a = 255,
            };
        }
    };

    pub const DAY_06 = [4]Color{
        .{ .r = 0.408, .g = 0.333, .b = 0.643 },
        .{ .r = 0.518, .g = 0.365, .b = 0.855 },
        .{ .r = 0.761, .g = 0.510, .b = 0.851 },
        .{ .r = 0.569, .g = 0.325, .b = 0.620 },
    };

    pub const DAY_08 = [4]Color{
        .{ .r = 0.243, .g = 0.608, .b = 0.831 },
        .{ .r = 0.039, .g = 0.690, .b = 0.878 },
        .{ .r = 0.016, .g = 0.306, .b = 0.694 },
        .{ .r = 0.000, .g = 0.027, .b = 0.310 },
    };

    pub const NIGHT_08 = [4]Color{
        .{ .r = 0.000, .g = 0.145, .b = 0.349 },
        .{ .r = 0.000, .g = 0.008, .b = 0.106 },
        .{ .r = 0.251, .g = 0.494, .b = 0.576 },
        .{ .r = 0.008, .g = 0.537, .b = 0.612 },
    };
};

fn createCamera() raylib.Camera3D {
    var camera = raylib.Camera3D{};

    camera.position.x = 0;
    camera.position.y = 10;
    camera.position.z = 0;

    // camera pointing down, oriented correctly
    // TODO this works but looks weird. do better.
    camera.target.x = 0;
    camera.target.y = 0;
    camera.target.z = -0.000000000000001;

    camera.up.x = 0;
    camera.up.y = 1;
    camera.up.z = 0;

    camera.fovy = 1;
    camera.projection = raylib.CAMERA_ORTHOGRAPHIC;

    return camera;
}

const std = @import("std");
const Allocator = std.mem.Allocator;

const c = @import("c.zig");
const raylib = c.raylib;