#include "CTransform.h"
#include "U_Scripting.h"

CRotationEulerRepresentation::CRotationEulerRepresentation(CTransformBase& transform) : m_transform(transform) {}
CQuatEulerRepresentation::CQuatEulerRepresentation(glm::quat& quat) : m_quat(quat) {}

void CEulerRepresentationBase::m_wrapEulerToQuat(const CAngles& euler)
{
	glm::quat q = glm::quat(glm::vec3(euler.x.asRadians(), euler.y.asRadians(), euler.z.asRadians()));
    m_setQuat(q);
}

CAngles CEulerRepresentationBase::m_wrapQuatToEuler() const
{
	glm::vec3 euler_glm = glm::eulerAngles(m_getQuat());
	return euler_glm;
}

CAngles CEulerRepresentationBase::GetRotation() const
{
	return m_wrapQuatToEuler();
}

CAngle CEulerRepresentationBase::GetRotationX() const
{
	return m_wrapQuatToEuler().x;
}

CAngle CEulerRepresentationBase::GetRotationY() const
{
	return m_wrapQuatToEuler().y;
}

CAngle CEulerRepresentationBase::GetRotationZ() const
{
	return m_wrapQuatToEuler().z;
}

void CEulerRepresentationBase::SetRotation(const CAngles& rot)
{
	m_wrapEulerToQuat(rot);
}

void CEulerRepresentationBase::SetRotationX(CAngle x)
{
	CAngles rot = m_wrapQuatToEuler();
	m_wrapEulerToQuat(CAngles(x, rot.y, rot.z));
}

void CEulerRepresentationBase::SetRotationY(CAngle y)
{
	CAngles rot = m_wrapQuatToEuler();
	m_wrapEulerToQuat(CAngles(rot.x, y, rot.z));
}

void CEulerRepresentationBase::SetRotationZ(CAngle z)
{
	CAngles rot = m_wrapQuatToEuler();
	m_wrapEulerToQuat(CAngles(rot.x, rot.y, z));
}

void CEulerRepresentationBase::ResetRotation()
{
	m_wrapEulerToQuat(CAngles(0.0f, 0.0f, 0.0f));
}

CQuatEulerRepresentation CTransformBase::CMeasurePack::GetEulerRotation() { return CQuatEulerRepresentation(Rotation); }

CEulerRepresentationBase::operator CAngles() const
{
    return m_wrapQuatToEuler();
}

CTransformBase& CRotationEulerRepresentation::GetTransform()
{
	return m_transform;
}

void CRotationEulerRepresentation::m_setQuat(const glm::quat& q)
{
    return m_transform.SetRotation(q);
}

glm::quat CRotationEulerRepresentation::m_getQuat() const
{
    return m_transform.GetRotation();
}

void CQuatEulerRepresentation::m_setQuat(const glm::quat& q)
{
    m_quat = q;
}

glm::quat CQuatEulerRepresentation::m_getQuat() const
{
    return m_quat;
}

glm::quat& CQuatEulerRepresentation::GetQuaternion()
{
    return m_quat;
}

CTransformBase::CTransformBase(const CMeasurePack& pack) : CTransformBase()
{
    SetPRS(pack);
}

glm::vec3 CTransformBase::GetPosition() const
{
    return m_getPosition();
}

glm::quat CTransformBase::GetRotation() const
{
    return m_getRotation();
}

glm::vec3 CTransformBase::GetScale() const
{
    return m_getScale();
}

void CTransformBase::SetPosition(const glm::vec3& pos)
{
    if(GetPosition() == pos) { return; }

    CMeasurePack old = GetPRS();
    m_setPosition(pos);

    OnTransformChanged(old, this);
}

void CTransformBase::SetRotation(const glm::quat& rot)
{
    if(GetRotation() == rot) { return; }

    CMeasurePack old = GetPRS();
    m_setRotation(rot);

    OnTransformChanged(old, this);
}

void CTransformBase::SetScale(const glm::vec3& scl)
{
    if(GetScale() == scl) { return; }

    CMeasurePack old = GetPRS();
    m_setScale(scl);

    OnTransformChanged(old, this);
}

glm::vec3 CTransformBase::GetForwardVector() const
{
    static const glm::vec3 forw = glm::vec3(0, 0, -1);
    return glm::mat3_cast(GetRotation()) * forw;
}

glm::vec3 CTransformBase::GetRightVector() const
{
    static const glm::vec3 right = glm::vec3(1, 0, 0);
    return glm::mat3_cast(GetRotation()) * right;
}

glm::vec3 CTransformBase::GetUpVector() const
{
    static const glm::vec3 up = glm::vec3(0, 1, 0);
    return glm::mat3_cast(GetRotation()) * up;
}

CRotationEulerRepresentation CTransformBase::GetEulerRotation() { return CRotationEulerRepresentation(*this); }

void CTransformBase::SetFromMatrix(const glm::mat4x4 matrix)
{
    auto pos = glm::vec3(matrix[3]);

    glm::vec3 scale;
    scale.x = glm::length(glm::vec3(matrix[0]));
    scale.y = glm::length(glm::vec3(matrix[1]));
    scale.z = glm::length(glm::vec3(matrix[2]));

    glm::mat4 rotationMatrix = matrix;

    rotationMatrix[0] /= scale.x;
    rotationMatrix[1] /= scale.y;
    rotationMatrix[2] /= scale.z;

    glm::quat rotation = glm::quat_cast(rotationMatrix);
    SetPRS({ pos, rotation, scale });
}

glm::mat4 CTransformBase::GetModelMatrix() const
{
	glm::mat4 translate_matrix = glm::translate(glm::mat4(1.0f), GetPosition());
    glm::mat4 rotation_matrix = glm::mat4_cast(GetRotation());
    glm::mat4 scale_matrix = glm::scale(glm::mat4(1.0f), GetScale());
    return translate_matrix * rotation_matrix * scale_matrix;
}

void CTransformBase::ResetTransform()
{
	SetPRS(glm::vec3(0.0f, 0.0f, 0.0f), glm::identity<glm::quat>(), glm::vec3(1.0f, 1.0f, 1.0f));
}

CTransformBase::CMeasurePack CTransformBase::GetPRS() const
{
	return { GetPosition(), GetRotation(), GetScale() };
}

CTransformBase& CTransformBase::operator=(const CTransformBase& rhs)
{
    SetPRS(rhs.GetPRS());
    return *this;
}

CTransform& CTransform::operator=(const CTransform& rhs)
{
    SetPRS(rhs.GetPRS());
    return *this;
}

glm::mat4 CTransformBase::operator*(const CTransformBase& rhs) const
{
	return GetModelMatrix() * rhs.GetModelMatrix();
}

void CTransformBase::SetPRS(const glm::vec3& pos, const glm::quat& rot, const glm::vec3& scl)
{
    CMeasurePack old = GetPRS();
    
    m_setPosition(pos);
    m_setRotation(rot);
    m_setScale(scl);

    OnTransformChanged(old, this);
}

void CTransformBase::SetPRS(const CMeasurePack& pack)
{
    CMeasurePack old = GetPRS();
    
    m_setPosition(pack.Position);
    m_setRotation(pack.Rotation);
    m_setScale(pack.Scale);

    OnTransformChanged(old, this);
}

void CTransformBase::SetPR(const glm::vec3& pos, const glm::quat& rot)
{
    CMeasurePack old = GetPRS();
    
    m_setPosition(pos);
    m_setRotation(rot);

    OnTransformChanged(old, this);
}

void CTransformBase::SetPS(const glm::vec3& pos, const glm::vec3& scl)
{
    CMeasurePack old = GetPRS();
    
    m_setPosition(pos);
    m_setScale(scl);

    OnTransformChanged(old, this);
}

void CTransformBase::SetRS(const glm::quat& rot, const glm::vec3& scl)
{
    CMeasurePack old = GetPRS();
    
    m_setRotation(rot);
    m_setScale(scl);

    OnTransformChanged(old, this);
}

CTransformBase::CTransformBase()
{
    auto scForward = std::make_unique<CFunctionalScriptField>(
    [this](sol::state_view st) -> sol::object
    {
        return sol::make_object_userdata<glm::vec3>(st, GetForwardVector());
        //return ScriptUtils::CreateSharedObject<glm::vec3>(st, GetForwardVector()).second;
    });

    auto scRight = std::make_unique<CFunctionalScriptField>(
    [this](sol::state_view st) -> sol::object
    {
        return sol::make_object_userdata<glm::vec3>(st, GetRightVector());
        //return ScriptUtils::CreateSharedObject<glm::vec3>(st, GetRightVector()).second;
    });

    auto scUp = std::make_unique<CFunctionalScriptField>(
    [this](sol::state_view st) -> sol::object
    {
        return sol::make_object_userdata<glm::vec3>(st, GetUpVector());
        //return ScriptUtils::CreateSharedObject<glm::vec3>(st, GetUpVector()).second;
    });
    
    auto scModelMatrix = std::make_unique<CFunctionalScriptField>(
    [this](sol::state_view st) -> sol::object
    {
        return ScriptUtils::ToObject<glm::mat4>(GetModelMatrix(), st); //TODO shared_ptr of matrix
    });

    ScriptFields.AddField("forward", std::move(scForward));
    ScriptFields.AddField("right", std::move(scRight));
    ScriptFields.AddField("up", std::move(scUp));

    ScriptFields.AddField("modelMatrix", std::move(scModelMatrix));

    OnTransformChanged += [this](CMeasurePack old, CTransformBase* _this) { m_Changed = true; };
}

bool CTransformBase::AcknowledgeChange() const
{
    bool ret = m_Changed;
    m_Changed = false;
    return ret;
}

std::unique_ptr<CScriptFieldBase> CTransform::V_SetupPositionProp()
{
    return std::make_unique<CFunctionalScriptField>
    (
        [this](sol::state_view st) -> sol::object
        {
            return ScriptUtils::ToObject(this->m_position, st);
        },
        [this](sol::object obj) -> void
        {
            SetPosition(ScriptUtils::FromObject<glm::vec3>(obj));
        }
    );
}

std::unique_ptr<CScriptFieldBase> CTransform::V_SetupRotationProp()
{
    return std::make_unique<CFunctionalScriptField>
    (
        [this](sol::state_view st) -> sol::object
        {
            return ScriptUtils::ToObject(this->m_rotation, st);
        },
        [this](sol::object obj) -> void
        {
            SetRotation(ScriptUtils::FromObject<glm::quat>(obj));
        }
    );
}

std::unique_ptr<CScriptFieldBase> CTransform::V_SetupScaleProp()
{
    return std::make_unique<CFunctionalScriptField>
    (
        [this](sol::state_view st) -> sol::object
        {
            return ScriptUtils::ToObject(this->m_scale, st);
        },
        [this](sol::object obj) -> void
        {
            SetScale(ScriptUtils::FromObject<glm::vec3>(obj));
        }
    );
}

bool CTransformBase::V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table)
{
    if(!ScriptFields.IsFieldExist<std::string>("position"))
    {
        auto scPosition = V_SetupPositionProp(); 
        auto scRotation = V_SetupRotationProp();
        auto scScale = V_SetupScaleProp();

        ScriptFields.AddField("position", std::move(scPosition));
        ScriptFields.AddField("rotation", std::move(scRotation));
        ScriptFields.AddField("scale", std::move(scScale));
    }

    table.set_function("resetTransform", [this]() { ResetTransform(); });

    sol::table onTransformChanged = OnTransformChanged.GetScriptTable(state);
    table["onTransformChanged"] = onTransformChanged;

    ScriptFields.CreateMetaTable(table);
    return true;
}

glm::vec3 CTransform::m_getPosition() const
{
    return m_position;
}

glm::quat CTransform::m_getRotation() const
{
    return m_rotation;
}

glm::vec3 CTransform::m_getScale() const
{
    return m_scale;
}

void CTransform::m_setPosition(const glm::vec3& pos)
{
    for(size_t i = 0; i < pos.length(); i++) { if(std::isnan(pos[i])) { return; } }
    m_position = pos;
}

void CTransform::m_setRotation(const glm::quat& qua)
{
    for(size_t i = 0; i < qua.length(); i++) { if(std::isnan(qua[i])) { return; } }
    m_rotation = qua;
}

void CTransform::m_setScale(const glm::vec3& scl)
{
    for(size_t i = 0; i < scl.length(); i++) { if(std::isnan(scl[i])) { return; } }
    m_scale = scl;
}

CTransform::CTransform(const CTransform& other) : m_position(other.m_position), m_rotation(other.m_rotation), m_scale(other.m_scale) {}

CTransformBoolDelta GetTransformBoolDelta(const CTransformBase::CMeasurePack& oldprs, CTransformBase* _this)
{
    return
    {
        oldprs.Position != _this->GetPosition(),
        oldprs.Rotation != _this->GetRotation(),
        oldprs.Scale != _this->GetScale()
    };
}

CTransformBase::CMeasurePack GetTransformDelta(const CTransformBase::CMeasurePack& oldprs, CTransformBase* _this)
{
    return
    {
        _this->GetPosition() - oldprs.Position,
        _this->GetRotation() - oldprs.Rotation,
        _this->GetScale() - oldprs.Scale
    };
}