#include "camera.hpp"
#include <algorithm>

using namespace TSR;

void Camera::UpdateVectors() {
    auto yaw_rad = glm::radians(yaw);
    auto pitch_rad = glm::radians(pitch);
    front_vector = glm::normalize(glm::vec3(cos(yaw_rad) * glm::cos(pitch_rad), glm::sin(pitch_rad), glm::sin(yaw_rad) * glm::cos(pitch_rad)));
    forward_backward_vector = glm::normalize(glm::vec3(front_vector.x, 0.0f, front_vector.z));
    right_vector = glm::normalize(glm::cross(front_vector, world_up));
    up_vector = glm::normalize(glm::cross(right_vector, front_vector));
}

Camera::Camera(glm::vec3 i_position, float i_movement_speed, float i_mouse_sensitivity, float i_third_person_distance, float i_yaw, float i_pitch) :
    position(i_position),
    movement_speed(i_movement_speed),
    mouse_sensitivity(i_mouse_sensitivity),
    third_person_distance(i_third_person_distance),
    yaw(i_yaw),
    pitch(i_pitch),
    world_up(glm::vec3(0.0f, 1.0f, 0.0f))
{
    UpdateVectors();
}

glm::mat4 Camera::GetViewMatrix(bool firstperson) {
    float space = 0.3f;
    auto dist = firstperson ? 0.0f : third_person_distance;

    //if (world) {
    //    auto to_glm = position - front_vector * (third_person_distance + space);
    //    auto position_bt = btVector3(position.x, position.y, position.z);
    //    
    //    auto to_bt = btVector3(to_glm.x, to_glm.y, to_glm.z);
    //    btCollisionWorld::ClosestRayResultCallback ray_callback(position_bt, to_bt);
    //    world->rayTest(position_bt, to_bt, ray_callback);

    //    if (ray_callback.hasHit()) {
    //        to_glm.x = ray_callback.m_hitPointWorld.x();
    //        to_glm.y = ray_callback.m_hitPointWorld.y();
    //        to_glm.z = ray_callback.m_hitPointWorld.z();

    //        dist = glm::distance(position, to_glm) - space;
    //    }
    //}

    return glm::lookAt(position - front_vector * dist, position + front_vector, up_vector);
}

void Camera::ProcessMovement(Movement direction, float time) {
    float diff = movement_speed * time;
    switch (direction) {
    case Movement::FORWARD:
        position += forward_backward_vector * diff;
        break;
    case Movement::BACKWARD:
        position -= forward_backward_vector * diff;
        break;
    case Movement::RIGHT:
        position += right_vector * diff;
        break;
    case Movement::LEFT:
        position -= right_vector * diff;
        break;
    case Movement::UP:
        position += world_up * diff;
        break;
    case Movement::DOWN:
        position -= world_up * diff;
        break;
    }
}

void Camera::ProcessMouse(float x_offset, float y_offset) {
    yaw += x_offset * mouse_sensitivity;
    //pitch = std::min(89.0f, std::max(-89.0f, pitch + y_offset * mouse_sensitivity));
    pitch = std::min(89.9f, std::max(-89.9f, pitch + y_offset * mouse_sensitivity));

    UpdateVectors();
}