#include "ChunkMeshing.hpp"

namespace MC::World::Generation::ChunkMeshing {

ChunkMesh mesh_chunk(Chunk& chunk, const ChunkNeighbors& neighbors) {
    using namespace Detail;

    return {
        create_mesh<DefaultMeshDecisions>(chunk, neighbors),
        create_mesh<WaterMeshDecisions>(chunk, neighbors)
    };
}

namespace Detail {

Face<Vertex> DefaultMeshDecisions::face_positions(BlockSide side, U32 x, U32 y, U32 z) {
    // Winding order: (0, 1, 2) (2, 3, 0)
    // Note: OpenGL Coordinate system has a flipped z axis.
    Face<Vertex> face{};
    switch (side) {
    case BlockSide::Front:
        face = {{{0, 1, 1}, {0, 0, 1}, {1, 0, 1}, {1, 1, 1}}};
        break;
    case BlockSide::Back:
        face = {{{0, 1, 0}, {1, 1, 0}, {1, 0, 0}, {0, 0, 0}}};
        break;
    case BlockSide::Top:
        face = {{{0, 1, 1}, {1, 1, 1}, {1, 1, 0}, {0, 1, 0}}};
        break;
    case BlockSide::Bottom:
        face = {{{0, 0, 1}, {0, 0, 0}, {1, 0, 0}, {1, 0, 1}}};
        break;
    case BlockSide::Right:
        face = {{{1, 1, 0}, {1, 1, 1}, {1, 0, 1}, {1, 0, 0}}};
        break;
    case BlockSide::Left:
        face = {{{0, 1, 0}, {0, 0, 0}, {0, 0, 1}, {0, 1, 1}}};
        break;
    }

    for (auto& p : face) {
        p += {x, y, z};
    }
    return face;
}

Face<TexCoord> DefaultMeshDecisions::face_tex_coords(BlockType type, BlockSide side) {
    U8 atlas_width = 4;
    U8 atlas_height = 4;

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

    auto block_coords = [=](U8 x, U8 y) -> Face<TexCoord> {
        auto t = y * height_step;
        auto l = x * width_step;
        auto b = t + height_step;
        auto r = l + width_step;

        // This is horrible and it was better before I restructured the vertex order...
        // In the last version the front and back side pairs had the same structure in different winding,
        // so a back_side check wasn't needed...
        // Note: BlockSide::Front counts as a back side, because OpenGL has an inverted Z-axis compared to us.
        Bool back_side = side == BlockSide::Front || side == BlockSide::Bottom || side == BlockSide::Left;
        if (back_side) {
            return {{{l, t}, {l, b}, {r, b}, {r, t}}};
        }
        return {{{r, t}, {l, t}, {l, b}, {r, b}}};
    };

    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(1, 1);
    case BlockType::Water:
        return block_coords(0, 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::Wood:
        switch (side) {
        case BlockSide::Front:
        case BlockSide::Back:
        case BlockSide::Right:
        case BlockSide::Left:
            return block_coords(0, 2);
        case BlockSide::Bottom:
        case BlockSide::Top:
            return block_coords(1, 2);
        }
    case BlockType::Leaves:
        return block_coords(2, 2);
    case BlockType::Air:
        return {};
    }
}

Face<Normal> DefaultMeshDecisions::face_normals(BlockSide side) {
    Vector<3, F32> normal{get_face_normal(side)};
    return {normal, normal, normal, normal};
}

Face<Light> DefaultMeshDecisions::face_light(Chunk& chunk, const ChunkNeighbors& neighbors, U32 x, U32 y, U32 z, BlockSide side) {
    auto neighbor = get_opposing_neighbor(chunk, neighbors, x, y, z, side);
    if (!neighbor.type.is_translucent()) return {};

    auto light = (F32)neighbor.light / (F32)255;
    return {light, light, light, light};
}

Face<AO> DefaultMeshDecisions::face_ao_values(Chunk& chunk, const ChunkNeighbors& neighbors, U32 x, U32 y, U32 z, BlockSide side) {
    std::array<Vector<3, I32>, 8> offsets{};
    // Given a block position, these offsets can be added to it to get the 8 blocks necessary to calculate AO.
    // There are 4 corners and 4 sides, corners are visually distinguished by the lack of spaces and
    // but you can recognize them by the fact that they have no 0 offsets.
    // Note: Is there a way to compute these? I tried but I couldn't... If the vertex windings ever change again I don't want to hardcode these...
    switch (side) {
    case BlockSide::Front:
        offsets = {{{0, 1, 1}, {-1,1,1}, {-1, 0, 1}, {-1,-1,1}, {0, -1, 1}, {1,-1,1}, {1, 0, 1}, {1,1,1}}};
        break;
    case BlockSide::Back:
        offsets = {{{-1, 0, -1}, {-1,1,-1}, {0, 1, -1}, {1,1,-1}, {1, 0, -1}, {1,-1,-1}, {0, -1, -1}, {-1,-1,-1}}};
        break;
    case BlockSide::Top:
        offsets = {{{-1, 1, 0}, {-1,1,1}, {0, 1, 1}, {1,1,1}, {1, 1, 0}, {1,1,-1}, {0, 1, -1}, {-1,1,-1}}};
        break;
    case BlockSide::Bottom:
        offsets = {{{0, -1, 1}, {-1,-1,1}, {-1, -1, 0}, {-1,-1,-1}, {0, -1, -1}, {1,-1,-1},  {1, -1, 0}, {1,-1,1}}};
        break;
    case BlockSide::Right:
        offsets = {{{1, 0, -1}, {1,1,-1}, {1, 1, 0}, {1,1,1}, {1, 0, 1}, {1,-1,1},  {1, -1, 0}, {1,-1,-1}}};
        break;
    case BlockSide::Left:
        offsets = {{{-1, 1, 0}, {-1,1,-1}, {-1, 0, -1}, {-1,-1,-1}, {-1, -1, 0}, {-1,-1,1},  {-1, 0, 1}, {-1,1,1}}};
        break;
    }

    Face<AO> vertex_ao{};

    UInt offset_index = 0;
    for (UInt vertex = 0; vertex < 4; vertex++) {
        auto a = offsets[offset_index];
        auto b = offsets[++offset_index]; // corner
        auto c = offsets[++offset_index % 8];

        auto block_a = get_block_wrapping(chunk, neighbors, {x + a.x(), y + a.y(), z + a.z()});
        auto block_b = get_block_wrapping(chunk, neighbors, {x + b.x(), y + b.y(), z + b.z()});
        auto block_c = get_block_wrapping(chunk, neighbors, {x + c.x(), y + c.y(), z + c.z()});

        F32 occlusion_a = block_a.empty() ? 0 : 1;
        F32 occlusion_b = block_b.empty() ? 0 : 1;
        F32 occlusion_c = block_c.empty() ? 0 : 1;

        if (occlusion_a + occlusion_c == 2.0f) {
            vertex_ao[vertex] = 1.0f;
        } else {
            vertex_ao[vertex] = (occlusion_a + occlusion_b + occlusion_c) / 3;
        }
    }

    return vertex_ao;
}

Vector<3, I32> DefaultMeshDecisions::get_face_normal(BlockSide side) {
    auto is_side = [=](BlockSide s) -> I8 { return s == side; };

    return {
        is_side(BlockSide::Right) - is_side(BlockSide::Left),
        is_side(BlockSide::Top) - is_side(BlockSide::Bottom),
        is_side(BlockSide::Front) - is_side(BlockSide::Back),
    };
}

Chunk::BlockData DefaultMeshDecisions::get_opposing_neighbor(const Chunk& chunk, const ChunkNeighbors& neighbors, U32 x, U32 y, U32 z, BlockSide side) {
    Vector<3, I32> offset = get_face_normal(side);
    auto neighbor_position = offset + Vector<3, I32>{x, y, z};

    return get_block_wrapping(chunk, neighbors, neighbor_position);
}

Bool DefaultMeshDecisions::is_face_visible(Chunk& chunk, const ChunkNeighbors& neighbors, U32 x, U32 y, U32 z, BlockSide side) {
    auto block = get_opposing_neighbor(chunk, neighbors, x, y, z, side);
    return block.type.is_translucent();
}

Bool DefaultMeshDecisions::should_ignore_block(Chunk::BlockData block) {
    return block.empty() || block.type == BlockType::Water;
}

Bool WaterMeshDecisions::is_face_visible(Chunk& chunk, const ChunkNeighbors& neighbors, U32 x, U32 y, U32 z, BlockSide side) {
    auto block = get_opposing_neighbor(chunk, neighbors, x, y, z, side);
    return block.type.is_translucent() && block.type != BlockType::Water;
}

Bool WaterMeshDecisions::should_ignore_block(Chunk::BlockData block) {
    return block.type != BlockType::Water;
}

}

}