#include "Chunk.hpp"
#include "BlockSide.hpp"

namespace MC::World {

void Chunk::set(uint32_t x, uint32_t y, uint32_t z, BlockData data) {
    m_blocks.at(pos(x, y, z)) = data;
}

Chunk::BlockData Chunk::get(uint32_t x, uint32_t y, uint32_t z) const {
    return m_blocks.at(pos(x, y, z));
}

GFX::Mesh Chunk::mesh() {
    std::vector<Vector<3>> positions{};
    std::vector<Vector<3>> normals{};
    std::vector<Vector<2>> tex_coords{};
    std::vector<uint32_t> indices{};

    for (int x = 0; x < Width; x++) {
        for (int y = 0; y < Height; y++) {
            for (int z = 0; z < Width; z++) {
                auto type = get(x, y, z).type;
                if (type == BlockType::Air) {
                    continue;
                }

                for (auto side: BlockSide::all()) {
                    if (!is_face_visible(x, y, z, side)) {
                        continue;
                    }

                    auto side_positions = side.face();
                    auto side_normals = face_normals(side);
                    auto side_tex_coords = face_tex_coords(type, side);

                    for (auto& position : side_positions) {
                        position = position + Vector<3>{static_cast<float>(x), static_cast<float>(y), static_cast<float>(z)};
                    }

                    uint32_t s = positions.size();

                    positions.insert(positions.end(), side_positions.begin(), side_positions.end());
                    normals.insert(normals.end(), side_normals.begin(), side_normals.end());
                    tex_coords.insert(tex_coords.end(), side_tex_coords.begin(), side_tex_coords.end());
                    indices.insert(indices.end(), {s, s + 1, s + 3, s + 1, s + 2, s + 3});
                }
            }
        }
    }

    return {
        {positions, normals, tex_coords},
        indices,
    };
}

Vector<3> Chunk::position() {
    return m_position;
}

bool Chunk::is_face_visible(uint32_t x, uint32_t y, uint32_t z, BlockSide side) {
    Vector<3, int32_t> offset{};
    switch (side) {
        case BlockSide::Front:
            offset[2] = 1;
            break;
        case BlockSide::Back:
            offset[2] = -1;
            break;
        case BlockSide::Top:
            offset[1] = 1;
            break;
        case BlockSide::Bottom:
            offset[1] = -1;
            break;
        case BlockSide::Left:
            offset[0] = -1;
            break;
        case BlockSide::Right:
            offset[0] = 1;
            break;
    }

    Vector<3, uint32_t> neighbor_pos{
        x + offset.x(), y + offset.y(), z + offset.z(),
    };

    if (
        neighbor_pos.x() >= Width || neighbor_pos.x() < 0 ||
        neighbor_pos.y() >= Height || neighbor_pos.y() < 0 ||
        neighbor_pos.z() >= Width || neighbor_pos.z() < 0
    ) {
        return true;
    }

    auto neighbor = get(neighbor_pos.x(), neighbor_pos.y(), neighbor_pos.z());
    if (neighbor.type == BlockType::Air) {
        return true;
    }

    return false;
}

std::array<Vector<2>, 4> Chunk::face_tex_coords(BlockType type, BlockSide side) {
    uint8_t atlas_width = 4;
    uint8_t atlas_height = 4;

    float width_step = 1.0f / atlas_width;
    float height_step = 1.0f / atlas_height;

    auto block_coords = [=](uint8_t x, uint8_t y) {
        auto t = y * height_step;
        auto l = x * width_step;
        auto b = t + height_step;
        auto r = l + width_step;

        return std::array<Vector<2>, 4>{{
            {l, b}, {r, b}, {r, t}, {l, t},
        }};
    };

    switch (type) {
        case BlockType::Dirt:
            return block_coords(1, 0);
        case BlockType::Grass:
            switch (side) {
            case BlockSide::Front:
            case BlockSide::Back:
            case BlockSide::Left:
            case BlockSide::Right:
                return block_coords(2, 0);
            case BlockSide::Bottom:
                return block_coords(1, 0);
            case BlockSide::Top:
                return block_coords(0, 0);
            }
        case BlockType::Stone:
            return block_coords(3, 0);
        case BlockType::Sand:
            return block_coords(0, 1);
        case BlockType::Water:
            return block_coords(1, 1);
        case BlockType::Snow:
            switch (side) {
            case BlockSide::Front:
            case BlockSide::Back:
            case BlockSide::Left:
            case BlockSide::Right:
                return block_coords(3, 1);
            case BlockSide::Bottom:
                return block_coords(1, 0);
            case BlockSide::Top:
                return block_coords(2, 1);
            }
        case BlockType::Air:
            return {};
    }
}

std::array<Vector<3>, 4> Chunk::face_normals(BlockSide side) {
    auto is_side = [=](BlockSide s) -> float { return s == side; };

    Vector<3> normal = {
        is_side(BlockSide::Right) - is_side(BlockSide::Left),
        is_side(BlockSide::Top) - is_side(BlockSide::Bottom),
        is_side(BlockSide::Front) - is_side(BlockSide::Back),
    };

    return {normal, normal, normal, normal};
}

uint64_t Chunk::pos(uint32_t x, uint32_t y, uint32_t z) {
    return x + Width * y + Width * Height * z;
}

}