#include "Player.hpp"

namespace MC::Entities {

void Player::update(const Time& time, GFX::Window& window, GFX::Camera& camera, World::World& world) {
    auto origin = m_transform.position();
    auto r = window.mouse_delta();

    auto key = [&](Int k) -> Real { return window.key(k, GLFW_PRESS); };

    Real x = key(GLFW_KEY_D) - key(GLFW_KEY_A);
    Real y = key(GLFW_KEY_SPACE) - key(GLFW_KEY_LEFT_SHIFT);
    Real z = key(GLFW_KEY_S) - key(GLFW_KEY_W);
    Real boost = key(GLFW_KEY_LEFT_CONTROL) * 75.0f;

    auto move_speed = (10.0f + boost) * time.delta();
    auto rotation_speed = 0.1f;

    auto direction = m_transform.right() * x + Vec3(0, y, 0) + m_transform.forward() * z;
    auto destination = origin + direction * move_speed;

    destination = process_collisions(world, origin, destination);

    move_to(destination);
    rotate({r.y() * rotation_speed, r.x() * rotation_speed, 0.0f});

    update_camera_position(camera);
}

void Player::move(Position::WorldOffset by) {
    m_transform.position() += by;
}

void Player::rotate(Rotation by) {
    m_transform.rotation() += by;
    m_transform.rotation().pitch() = std::clamp(m_transform.rotation().pitch(), -89.0, 89.0);
}

void Player::move_to(Position::World to) {
    m_transform.position() = to;
}

void Player::rotate_to(Rotation to) {
    m_transform.rotation() = to;
}

AABB Player::bounds() const {
    return bounding_box_for_position(m_transform.position());
}

#define STUCK_THRESHOLD 100

Position::World Player::process_collisions(World::World& world, Position::World from, Position::World to) {
    auto current_box = bounding_box_for_position(from);

    // All the blocks we could theoretically collide with.
    auto collision_domain = terrain_collision_domain(from, to, world);

    // Sort the pushouts by magnitude, and apply the biggest one.
    // If we apply a pushout, we need to check again for collisions,
    // since we might have slid into another block. (up to STUCK_THRESHOLD times)
    // If there are no pushouts, we have no collisions,
    // and the player can move freely to the proposed position.

    std::vector<Vec3> pushouts;
    for (UInt stuck = 0; stuck < STUCK_THRESHOLD; stuck++) {
        // Find the pushout vector for each block we're colliding with.
        for (auto possible_collision : collision_domain) {
            auto pushout = current_box.pushout(to - from, possible_collision);
            if (!pushout.is_zero()) pushouts.push_back(pushout);
        }

        if (pushouts.empty()) return to;

        std::sort(pushouts.begin(), pushouts.end(), [=](const Vec3& a, const Vec3& b) -> bool {
            return a.magnitude_squared() > b.magnitude_squared();
        });

        to += pushouts[0];
        pushouts.clear();
    }

    // We got stuck, don't move.
    return from;
}

std::vector<AABB> Player::terrain_collision_domain(
    Position::World from, Position::World to,
    World::World& world
) {
    // Make the box a bit bigger so we don't clip through blocks.
    auto domain_box = bounding_box_for_position(from)
        .unite(bounding_box_for_position(to))
        .unite(AABB{{1, 1, 1}});

    std::vector<AABB> colliding_blocks;

    // TODO: Unbind from chunks and loop through all the
    // blocks individually inside domain.
    // This will be more efficient and actually accurate,
    // since right now if you're fast enough you can clip
    // through whole chunks.
    auto add_colliding = [&](Position::World chunk_pos, Position::BlockLocal pos, World::Chunk::BlockData& b) {
        if (!b.type.is_solid()) return;
        auto block_bounds = World::Chunk::block_bounds(pos).offset(chunk_pos);
        if (domain_box.collides(block_bounds)) colliding_blocks.push_back(block_bounds);
    };

    auto chunk_from = world.chunks().find(to);
    if (chunk_from.chunk.has_value()) {
        auto position = chunk_from.chunk.value().position();
        chunk_from.chunk->for_each([&](auto p, auto b) { add_colliding(position, p, b); });
    }

    if (World::ChunkIndex::from_position(to) == World::ChunkIndex::from_position(from))
        return colliding_blocks;

    auto chunk_to = world.chunks().find(to);
    if (chunk_to.chunk.has_value()) {
        auto position = chunk_to.chunk.value().position();
        chunk_to.chunk->for_each([&](auto p, auto b) { add_colliding(position, p, b); });
    }

    return colliding_blocks;
}

void Player::update_camera_position(GFX::Camera& camera) {
    auto camera_position = m_transform.position();
    camera_position.y() += 1.5;

    camera.set_position(camera_position);
    camera.set_angles(m_transform.rotation());
}

AABB Player::bounding_box_for_position(Position::World position) {
    Vec3 box_start = {
        position.x() - s_bounds.max.x() / 2,
        position.y(),
        position.z() - s_bounds.max.z() / 2,
    };

    return s_bounds.offset(box_start);
}

Position::World Player::position_for_bounding_box(AABB box) {
    auto center = box.center();
    return {center.x(), box.min.y(), center.z()};
}

}