#pragma once
#include "CPhysicsEngine.h"

#include "btBulletDynamicsCommon.h"
#include "btBulletCollisionCommon.h"
#include "BulletCollision/CollisionDispatch/btGhostObject.h" //TODO hack

//shapes

namespace BulletShapes
{
    class CBasic : public virtual PhysicsShapes::CBasic
    {
    public:
        std::unique_ptr<btCollisionShape> InternalShape;
    };

    class CTriMesh : public virtual CBasic, public PhysicsShapes::CTriMesh
    {
    public:
        void V_Build() override;
        std::unique_ptr<btTriangleMesh> Mesh;
    };

    class CConvex : public virtual CBasic, public PhysicsShapes::CConvex
    {
    public:
        void V_Build() override;
    };

    class CCompound : public virtual CBasic, public PhysicsShapes::CCompound
    {
    public:
        void V_Build() override;
    };

    class CCapsule : public virtual CBasic, public PhysicsShapes::CCapsule
    {
    public:
        void V_Build() override;
    };

    class CSphere : public virtual CBasic, public PhysicsShapes::CSphere
    {
    public:
        void V_Build() override;
    };

    class CBox : public virtual CBasic, public PhysicsShapes::CBox
    {
    public:
        void V_Build() override;
    };
}

//base for rigid, kinematic, ghost

class CBulletWorld;
class CBulletUnit : public virtual CWorldUnit
{
public:
    static btCollisionShape* GetBulletCollision(std::shared_ptr<CCollision> _col);

    virtual btCollisionObject* GetBulletObject() const = 0;
    CBulletWorld* m_addedToWorld = nullptr;
};

//bodies

class CBulletBody : public virtual CBulletUnit
{
public:
    ~CBulletBody();
    btCollisionObject* GetBulletObject() const override;

    std::unique_ptr<btRigidBody> RigidBody;
    std::unique_ptr<btDefaultMotionState> MotionState;
};

class CBulletRigidBody : public virtual CBulletUnit, public CRigidBody, public CBulletBody
{
public:
    CBulletRigidBody(std::shared_ptr<CCollision> _col, const CTransform& _start_transform, float mass);
    btVector3 LocalInertia = btVector3(0, 0, 0);

    void V_SetMass(float mass) override;
    void V_SetCollision(std::shared_ptr<CCollision> _col) override;

    void SetLinearVelocity(const glm::vec3& vel) override;
    void SetAngularVelocity(const glm::vec3& ang_vel) override;

    glm::vec3 GetLinearVelocity() const override;
    glm::vec3 GetAngularVelocity() const override;

    void Activate() override;

    void SetTransform(const CTransform& trans) override;
    CTransform GetInternalTransform() override;
};

class CBulletKinematicBody : public virtual CBulletUnit, public CKinematicBody, public CBulletBody
{
public:
    CBulletKinematicBody(std::shared_ptr<CCollision> _col, const CTransform& _start_transform);
    void V_SetCollision(std::shared_ptr<CCollision> _col) override;

    void SetTransform(const CTransform& trans) override;
    CTransform GetInternalTransform() override;
};

class CBulletGhostBody : public virtual CBulletUnit, public CGhostBody
{
public:
    CBulletGhostBody(std::shared_ptr<CCollision> _col, const CTransform& _start_transform);
    ~CBulletGhostBody();

    std::unique_ptr<btGhostObject> GhostObject;

    btCollisionObject* GetBulletObject() const override;
    void V_SetCollision(std::shared_ptr<CCollision> _col) override;

    void SetTransform(const CTransform& trans) override;
    CTransform GetInternalTransform() override;
};

//sweep test

class BulletConvexSweepCallback : public btCollisionWorld::ClosestConvexResultCallback
{
public:
    std::vector<CWorldUnit*> ExcludeList;

    BulletConvexSweepCallback
    (
        const btVector3& from,
        const btVector3& to,
        IConvexSweepCallback* userCb
    );

    btScalar addSingleResult(btCollisionWorld::LocalConvexResult& r, bool normalInWorldSpace) override;
    bool needsCollision(btBroadphaseProxy* proxy0) const override;
private:
    IConvexSweepCallback* m_UserCallback = nullptr;
};

class BulletConvexSweepResult : public IConvexSweepResult
{
public:
    BulletConvexSweepResult(const btCollisionWorld::ClosestConvexResultCallback& cb);

    bool HasHit() const override;
    const CSweepHit& GetHit() const override;
private:
    bool m_HasHit = false;
    CSweepHit m_Hit;
};

//manifolds

class BulletContactPoint : public IContactPoint
{
public:
    BulletContactPoint(const btManifoldPoint& pt);

    glm::vec3 GetPositionWorldOnA() const override;
    glm::vec3 GetPositionWorldOnB() const override;
    glm::vec3 GetNormalWorldOnB() const override;
    float GetDistance() const override;
private:
    const btManifoldPoint& m_Pt;
};

class BulletContactManifold : public IContactManifold
{
public:
    BulletContactManifold(btPersistentManifold* m);

    int GetNumContacts() const override;
    std::unique_ptr<IContactPoint> GetContact(int index) const override;

    CWorldUnit* GetUnitA() const override;
    CWorldUnit* GetUnitB() const override;
private:
    btPersistentManifold* m_Manifold;
};

class CBulletWorld;
class BulletGhostOverlapResult : public IGhostOverlapResult
{
public:
    BulletGhostOverlapResult
    (
        const btGhostObject* ghost,
        btBroadphaseInterface* broadphase,
        btDispatcher* dispatcher,
        const CBulletWorld* world
    );

    int GetNumOverlappingUnits() const override;
    CWorldUnit* GetOverlappingUnit(int index) const override;
    std::vector<std::unique_ptr<IContactManifold>> GetContactManifolds(CWorldUnit* other) const override;
private:
    const btGhostObject* m_Ghost;
    btBroadphaseInterface* m_Broadphase;
    btDispatcher* m_Dispatcher;
    const CBulletWorld* m_World = nullptr;
};

//world

class CBulletWorld : public CPhysicsWorld
{
public:
    CBulletWorld();
    ~CBulletWorld();

    std::unique_ptr<btGhostPairCallback> GhostPairCallback;
    std::unique_ptr<btBroadphaseInterface> Broadphase;
    std::unique_ptr<btDefaultCollisionConfiguration> Config;
    std::unique_ptr<btCollisionDispatcher> Dispatcher;
    std::unique_ptr<btSequentialImpulseConstraintSolver> Solver;
    std::unique_ptr<btDiscreteDynamicsWorld> BulletWorld;

    std::unique_ptr<CRigidBody> V_CreateRigidBody(std::shared_ptr<CCollision> _collision, const CTransform& startTransform, float mass) override;
    std::unique_ptr<CKinematicBody> V_CreateKinematicBody(std::shared_ptr<CCollision> _collision, const CTransform& startTransform) override;
    std::unique_ptr<CGhostBody> V_CreateGhostBody(std::shared_ptr<CCollision> _collision, const CTransform& startTransform) override;

    void V_AddRigidBody(CRigidBody* rgBody);
    void V_AddKinematicBody(CKinematicBody* knBody);
    void V_AddGhostBody(CGhostBody* ghBody);

    void V_SetGravity(const glm::vec3& _gravity) override;
    glm::vec3 GetGravity() const override;
    void V_Step(float deltaTime) override;

    std::unique_ptr<IConvexSweepResult> V_ConvexSweep
    (
        std::shared_ptr<CCollision> shape,
        const CTransform& from,
        const CTransform& to,
        IConvexSweepCallback* callback,
        std::vector<CWorldUnit*> excludeList
    ) override;
    
    std::unique_ptr<IGhostOverlapResult> V_GetGhostOverlaps(const CGhostBody* ghost) const override;
};

//engine

class CBulletPhysics : public CPhysicsEngine
{
public:
    CBulletPhysics();

    static btVector3 GetVector(const glm::vec3& vec);
    static glm::vec3 GetVector(const btVector3& vec);
    
    static btQuaternion GetQuat(const glm::quat& qua);
    static glm::quat GetQuat(const btQuaternion& qua);

    static btTransform GetTransform(const CTransformBase& trans);
    static void GetTransform(CTransformBase& trans, const btTransform& btTrans);

    std::unique_ptr<CPhysicsWorld> V_CreateWorld() override;
    DEFINE_PHYSICS_ENGINE();
};