#include "CTypesPhysics.h"

#include "CScriptingEngine.h"
#include "CTypesRegistering.h"
#include "CPhysicsEngine.h"

void CScriptingEngine::RegisterPhysicsTypes()
{
    State->new_enum<EUnitType>
    (
        "EUnitType",
        {
            { "Rigid", EUnitType::Rigid },
            { "Kinematic", EUnitType::Kinematic },
            { "Ghost", EUnitType::Ghost }
        }
    );

    State->new_usertype<PhysicsShapes::CBasic>
    (
        "PhysicsShapes_CBasic",
        sol::no_constructor,
        "GetType", &PhysicsShapes::CBasic::GetType,
        "Load", &PhysicsShapes::CBasic::Load,
        "Build", &PhysicsShapes::CBasic::Build,
        "GetMargin", &PhysicsShapes::CBasic::GetMargin,
        "SetMargin", &PhysicsShapes::CBasic::SetMargin
    );

    State->new_usertype<CCollision>
    (
        "CCollision",
        sol::no_constructor,
        SOL_RESOURCE_BASE,
        "Shape", sol::property([](CCollision& col) -> PhysicsShapes::CBasic* { return col.Shape.get(); })
    );

    State->new_usertype<CWorldUnit>
    (
        "CWorldUnit",
        sol::no_constructor,
        "SetCollision", &CWorldUnit::SetCollision,
        "GetCollision", &CWorldUnit::GetCollision,
        "SetTransform", &CWorldUnit::SetTransform,
        "UpdateInternalTransform", &CWorldUnit::UpdateInternalTransform,
        "GetInternalTransform", &CWorldUnit::GetInternalTransform,
        "GetTransform", &CWorldUnit::GetTransform,
        "GetTransformCallback", [](CWorldUnit& unit, sol::this_state ts) { return unit.GetTransformCallback().GetScriptTable(ts); },
        "GetWorld", &CWorldUnit::GetWorld,
        "World", sol::property([](CWorldUnit& world) { return world.GetWorld(); }),
        "IsUpdatingInternalTransform", &CWorldUnit::IsUpdatingInternalTransform,
        "GetType", &CWorldUnit::GetType
    );

    State->new_usertype<CRigidBody>
    (
        "CRigidBody",
        sol::no_constructor,
        sol::base_classes, sol::bases<CWorldUnit>(),
        "SetMass", &CRigidBody::SetMass,
        "GetMass", &CRigidBody::GetMass,
        "SetLinearVelocity", &CRigidBody::SetLinearVelocity,
        "SetAngularVelocity", &CRigidBody::SetAngularVelocity,
        "GetLinearVelocity", &CRigidBody::GetLinearVelocity,
        "GetAngularVelocity", &CRigidBody::GetAngularVelocity,
        "Activate", &CRigidBody::Activate
    );

    State->new_usertype<CKinematicBody>
    (
        "CKinematicBody",
        sol::no_constructor,
        sol::base_classes, sol::bases<CWorldUnit>()
    );

    State->new_usertype<CGhostBody>
    (
        "CGhostBody",
        sol::no_constructor,
        sol::base_classes, sol::bases<CWorldUnit>()
    );

    State->new_usertype<CSweepHit>
    (
        "CSweepHit",
        sol::no_constructor,
        "HitUnit", &CSweepHit::HitUnit,
        "HitPointWorld", &CSweepHit::HitPointWorld,
        "HitNormalWorld", &CSweepHit::HitNormalWorld,
        "HitFraction", &CSweepHit::HitFraction
    );

    State->new_usertype<IConvexSweepResult>
    (
        "IConvexSweepResult",
        sol::no_constructor,
        "HasHit", &IConvexSweepResult::HasHit,
        "GetHit", &IConvexSweepResult::GetHit
    );

    State->new_usertype<IConvexSweepCallback>
    (
        "IConvexSweepCallback",
        sol::no_constructor,
        "OnHit", &IConvexSweepCallback::OnHit
    );

    State->new_usertype<IContactPoint>
    (
        "IContactPoint",
        sol::no_constructor,
        "GetPositionWorldOnA", &IContactPoint::GetPositionWorldOnA,
        "GetPositionWorldOnB", &IContactPoint::GetPositionWorldOnB,
        "GetNormalWorldOnB", &IContactPoint::GetNormalWorldOnB,
        "GetDistance", &IContactPoint::GetDistance
    );

    State->new_usertype<IContactManifold>
    (
        "IContactManifold",
        sol::no_constructor,
        "GetNumContacts", &IContactManifold::GetNumContacts,
        "GetUnitA", &IContactManifold::GetUnitA,
        "GetUnitB", &IContactManifold::GetUnitB,
        "UnitA", sol::property([](IContactManifold& mnf) -> CWorldUnit* { return mnf.GetUnitA(); }),
        "UnitB", sol::property([](IContactManifold& mnf) -> CWorldUnit* { return mnf.GetUnitB(); }),
        "GetContact", [](const IContactManifold& mnf, int index) -> IContactPoint*
        {
            return mnf.GetContact(index).get();
        }
    );

    //std::vector<std::unique_ptr<IContactManifold>> GetContactManifolds(CWorldUnit* other)

    State->new_usertype<IGhostOverlapResult>
    (
        "IGhostOverlapResult",
        sol::no_constructor,
        "GetNumOverlappingUnits", &IGhostOverlapResult::GetNumOverlappingUnits,
        "GetOverlappingUnit", &IGhostOverlapResult::GetOverlappingUnit,
        //TODO might just reinterpret_cast since unique_ptr is just a single ptr in memory?
        "GetContactManifolds", [](const IGhostOverlapResult& overlap, CWorldUnit* other) -> std::vector<IContactManifold*> 
        {
            auto _ret = overlap.GetContactManifolds(other);

            std::vector<IContactManifold*> ret;
            ret.reserve(_ret.size());

            for(const auto& c : _ret)
            {
                ret.push_back(c.get());
            }
            return ret;
        }
    );

    State->new_usertype<CPhysicsEngine>
    (
        "CPhysicsEngine",
        sol::no_constructor,
        "GetType", &CPhysicsEngine::GetType,
        "CreateWorld", &CPhysicsEngine::CreateWorld,
        "GetWorld", [](CPhysicsEngine& eng, sol::object _id) -> CPhysicsWorld*
        {
            int id = 0;
            if(_id.valid() && _id.is<int>()) { id = _id.as<int>(); }

            return eng.GetWorld(id);
        },
        "Trace", [](CPhysicsEngine& eng, sol::function func)
        {
            eng.Trace([&func](CPhysicsWorld* world) { func(world); });
        }
    );

    State->new_usertype<CPhysicsWorld>
    (
        "CPhysicsWorld",
        sol::no_constructor,
        "Step", &CPhysicsWorld::Step,
        "SetGravity", &CPhysicsWorld::SetGravity,
        "GetGravity", &CPhysicsWorld::GetGravity,
        "CreateRigidBody", &CPhysicsWorld::CreateRigidBody,
        "CreateKinematicBody", &CPhysicsWorld::CreateKinematicBody,
        "CreateGhostBody", &CPhysicsWorld::CreateGhostBody,
        "GetGhostOverlaps",
        sol::overload
        (
            [](CPhysicsWorld& world, const CGhostBody* ghost) -> IGhostOverlapResult*
            {
                return world.V_GetGhostOverlaps(ghost).get();
            },
            [](CPhysicsWorld& world, const CWorldUnit* _ghost) -> IGhostOverlapResult*
            {
                auto* ghost = dynamic_cast<const CGhostBody*>(_ghost);

                if(!ghost) { return nullptr; }
                return world.V_GetGhostOverlaps(ghost).get();
            }
        ),
        "ConvexSweep",
        sol::overload
        (
            []
            (
                CPhysicsWorld& world,
                std::shared_ptr<CCollision> shape,
                const CTransform& from,
                const CTransform& to
            )
            {
                return world.V_ConvexSweep(shape, from, to).get();
            },
            []
            (
                CPhysicsWorld& world,
                std::shared_ptr<CCollision> shape,
                const CTransform& from,
                const CTransform& to,
                std::vector<CWorldUnit*> excludeList
            )
            {
                return world.V_ConvexSweep(shape, from, to, nullptr, excludeList).get();
            },
            []
            (
                CPhysicsWorld& world,
                std::shared_ptr<CCollision> shape,
                const CTransform& from,
                const CTransform& to,
                std::vector<CWorldUnit*> excludeList,
                IConvexSweepCallback* callback
            )
            {
                return world.V_ConvexSweep(shape, from, to, callback, excludeList).get();
            }
        )
    );

    
}