#pragma once

#include <glm.hpp>
#include <gtc/matrix_transform.hpp>
#include <gtc/type_ptr.hpp>

#include "InputHandler.h"
#include "Vector2D.h"

class Camera
{
public:

    glm::vec3 m_position;

    glm::vec3 m_front;
    glm::vec3 m_up;
    glm::vec3 m_right;

    glm::vec3 m_worldup;

    float m_yaw;
    float m_pitch;

    float m_zoom;

    bool m_enableInput;

    // Mouse
    float m_mouseSensitivity;

    enum class direction { in, out, right, left };

    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f),
        float yaw = -90.0f,
        float pitch = 0.0,
        float zoom = 1.0f,
        float mouseSensitivity = 0.05f) :
        m_front(glm::vec3(0.0f, 0.0f, -1.0f)),
        m_enableInput(false)
    {
        m_position = position;

        m_yaw = yaw;
        m_pitch = pitch;

        m_worldup = up;

        m_zoom = zoom;
        m_mouseSensitivity = mouseSensitivity;

        updateCameraVectors();
    }

    void lookAt()
    {
    }

    void move(direction d)
    {
        if (d == direction::in)
            m_position -= m_front;

        if (d == direction::out)
            m_position += m_front;

        if(d == direction::right)
            m_position += glm::normalize(glm::cross(m_front, m_up)) * m_mouseSensitivity;

        if(d == direction::left)
            m_position -= glm::normalize(glm::cross(m_front, m_up)) * m_mouseSensitivity;
    }

    void rotate()
    {
    }

    void zoom()
    {
    }

    void scrollInput()
    {
    }

    void keyboardInput()
    {
        // todo: give the user ability to adjust input keys

        if (_inHandler->onKeyDown(SDL_SCANCODE_W)) {
            move(direction::in);
        }
        if (_inHandler->onKeyDown(SDL_SCANCODE_S)) {
            move(direction::out);
        }
        if (_inHandler->onKeyDown(SDL_SCANCODE_D)) {
            move(direction::right);
        }
        if (_inHandler->onKeyDown(SDL_SCANCODE_A)) {
            move(direction::left);
        }
    }

    void dragFPSInput(Vector2D* mouseMoveDiff, bool constrainPitch = true)
    {
        m_yaw += mouseMoveDiff->getX(); // offsetx
        m_pitch += -(mouseMoveDiff->getY()); // offsety

        // Make sure that when pitch is out of bounds, screen doesn't get flipped
        if (constrainPitch)
        {
            if (m_pitch > 89.0f)
                m_pitch = 89.0f;
            if (m_pitch < -89.0f)
                m_pitch = -89.0f;
        }

        // Update Front, Right and Up Vectors using the updated Eular angles
        updateCameraVectors();
    }

    float phi = 0;
    float theta = 0;

    void dragTPSInput(Vector2D* mouseMoveDiff)
    {
        // m_position = glm::rotate(m_position, -mouseMoveDiff->getY() * m_mouseSensitivity, glm::vec3(1, 0, 0));
        // m_position = glm::rotate(m_position, -mouseMoveDiff->getX() * m_mouseSensitivity, glm::vec3(0, 1, 0));

        /*
        glm::quat rot = glm::angleAxis(glm::radians(-mouseMoveDiff->getY()), glm::vec3(1, 0, 0));
        rot = rot * glm::angleAxis(glm::radians(-mouseMoveDiff->getX()), glm::vec3(0, 1, 0));

        glm::mat4 rotMatrix = glm::mat4_cast(rot);

        glm::vec4 pos = glm::vec4(m_position.x, m_position.y, m_position.z, 1.0f);

        pos = rotMatrix * pos;
        */

        if (phi >= 3.10) {
            phi = 3.14;
        }

        if (phi <= 0) {
            phi = 0;
        }

        phi += mouseMoveDiff->getY() * 0.05f;
        theta += mouseMoveDiff->getX() *  0.05f;

        float DistanceToOrigin = 10.0f;

        float x = DistanceToOrigin * sin(phi) * cos(theta);
        float y = DistanceToOrigin * cos(phi);
        float z = DistanceToOrigin * sin(phi) * sin(theta);

        m_position.x = x;
        m_position.y = y;
        m_position.z = z;

        updateCameraVectors();
    }

    void onInput(bool drag = true, bool scroll = true, bool keyboard = false)
    {
        if (drag)
            if (_inHandler->getMouseButtonState(_inHandler->mouse_buttons::LEFT))
                if(_inHandler->isMouseMovig())
                    dragTPSInput(_inHandler->getMouseMoveDiff());

        if (scroll)
            scrollInput();

        if (keyboard)
            keyboardInput();
    }

    // Returns the view matrix calculated using Eular Angles and the LookAt Matrix
    glm::mat4 getViewMatrix()
    {
        glm::vec3 pos = glm::vec3(m_position.x, m_position.y, m_position.z);
        return glm::lookAt(pos, m_front, m_up);
    }

private:
    void updateCameraVectors()
    {
        // Calculate the new Front vector
        glm::vec3 front;
        front.x = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
        front.y = sin(glm::radians(m_pitch));
        front.z = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));

        m_front = glm::normalize(front);

        // Also re-calculate the Right and Up vector
        // Normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
        m_right = glm::normalize(glm::cross(m_front, m_worldup));

        m_up = glm::normalize(glm::cross(m_right, m_front));
    }

    InputHandler* _inHandler = TheInputHandler::Instance();
};