// This file is part of ZiRC
//
// Copyright (C) 2021, tslil clingman
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

const std = @import("std");

pub const Layer = struct {
    pub const MAX_VERTS = 16;

    height : f32 = 0,
    vertical_texture : u8 = 0,
    vertical_texture_scale : f32 = 4,
    horizontal_texture : u8 = 0,
    // What happened to this error? Is it comptime?
    vertices: std.BoundedArray([2]f32, MAX_VERTS),
};

pub const Cell = struct {
    pub const MAX_LAYERS = 16;
    // floor_height: f32 = 0,
    // ceiling_height: f32 = DEFAULT_HEIGHT,
    // draw_down: bool = false,
    // lower_texture: u8 = 0,
    // upper_texture: u8 = 0,
    // floor_texture: u8 = 0,
    // ceiling_texture: u8 = 2,

    lower_layers : std.BoundedArray(Layer, MAX_LAYERS),

    // I'm not sure how i feel about reaching into the implementation of
    // BoundedArray like this. Surely there should be an ``.empty'' or something
    // default?
    fn empty() !Cell {
        const lower_layers = try std.BoundedArray(Layer, MAX_LAYERS).init(0);
        return Cell{ . lower_layers = lower_layers };
    }

    pub const DEFAULT_HEIGHT: f32 = 4;
};

pub const Object = struct {
    height: f32,
    width: f32,
    texture: u8,
    pos_x: f32,
    pos_y: f32,
    pos_z: f32 = 0,
};

pub const Map = struct {
    width: u32,
    height: u32,
    size: f32 = 64,
    cells: std.ArrayList(Cell),
    objects: std.ArrayList(Object),

    pub fn deinit(self: Map) void {
        self.cells.deinit();
        self.objects.deinit();
    }

    pub fn new(width: u32, height: u32, alloc: *std.mem.Allocator) !Map {
        var cells = std.ArrayList(Cell).init(alloc);
        try cells.ensureTotalCapacity(width * height);
        try cells.appendNTimes(try Cell.empty(), width * height);

        var objects = std.ArrayList(Object).init(alloc);

        return Map{ .width = width, .height = height, .cells = cells, .objects = objects };
    }

    pub fn inBounds(self: Map, x: i32, y: i32) bool {
        return (x < self.width and x >= 0 and y < self.height and y >= 0);
    }

    pub fn lookup(self: Map, x: i32, y: i32) Cell {
        // std.debug.assert(x >= 0 and y >= 0); // would this work as a compiler hint?
        return self.cells.items[@intCast(u32, y) * self.width + @intCast(u32, x)];
    }
};