const Platform = @import("platform");
const Gfx = Platform.Gfx;
const Color = Platform.Color;

const Vec2 = Platform.Math.Vec2;

const Canvas = @This();

size: Vec2,

fn getScale(self: Canvas) f32 {
    const window_size = Gfx.getWindowSize();
    const canvas_size = self.size;

    const scale_x = window_size.x / canvas_size.x;
    const scale_y = window_size.y / canvas_size.y;
    return @min(scale_x, scale_y);
}

fn getScaledCanvas(self: Canvas) Vec2 {
    return self.size.multiplyScalar(self.getScale());
}

pub fn push(self: Canvas) void {
    Gfx.transformPush();

    const scale = self.getScale();
    const window_size = Gfx.getWindowSize();
    const scaled_canvas = self.size.multiplyScalar(scale);

    Gfx.transformTranslate(.init(
        (window_size.x - scaled_canvas.x) / 2,
        (window_size.y - scaled_canvas.y) / 2,
    ));

    Gfx.transformScale(.init(scale, scale));
}

pub fn pop(self: Canvas, maybe_color: ?Color) void {
    Gfx.transformPop();

    if (maybe_color) |color| {
        const scale = self.getScale();
        const window_size = Gfx.getWindowSize();
        const scaled_canvas = self.size.multiplyScalar(scale);
        if (window_size.x > scaled_canvas.x) {
            const margin_x = (window_size.x - scaled_canvas.x) / 2;
            Gfx.drawRectangle(
                .init(0, 0),
                .init(margin_x, window_size.y),
                color
            );
            Gfx.drawRectangle(
                .init(window_size.x-margin_x, 0),
                .init(margin_x, window_size.y),
                color
            );
        } else {
            const margin_y = (window_size.y - scaled_canvas.y) / 2;
            Gfx.drawRectangle(
                .init(0, 0),
                .init(window_size.x, margin_y),
                color
            );
            Gfx.drawRectangle(
                .init(0, window_size.y-margin_y),
                .init(window_size.x, margin_y),
                color
            );
        }
    }
}