#include "CCollisionPrimitive.hpp"
#include "CInternalRayCastStructure.hpp"
#include "CMaterialFilter.hpp"
#include "InternalColliders.hpp"
#include "CCollisionInfoList.hpp"

namespace urde {
s32 CCollisionPrimitive::sNumTypes = 0;
bool CCollisionPrimitive::sInitComplete = false;
bool CCollisionPrimitive::sTypesAdded = false;
bool CCollisionPrimitive::sTypesAdding = false;
bool CCollisionPrimitive::sCollidersAdded = false;
bool CCollisionPrimitive::sCollidersAdding = false;
std::unique_ptr<std::vector<CCollisionPrimitive::Type>> CCollisionPrimitive::sCollisionTypeList;
std::unique_ptr<std::vector<ComparisonFunc>> CCollisionPrimitive::sTableOfCollidables;
std::unique_ptr<std::vector<BooleanComparisonFunc>> CCollisionPrimitive::sTableOfBooleanCollidables;
std::unique_ptr<std::vector<MovingComparisonFunc>> CCollisionPrimitive::sTableOfMovingCollidables;
ComparisonFunc CCollisionPrimitive::sNullCollider = {};
BooleanComparisonFunc CCollisionPrimitive::sNullBooleanCollider = {};
MovingComparisonFunc CCollisionPrimitive::sNullMovingCollider = {};
CCollisionPrimitive::CCollisionPrimitive(const CMaterialList& list) : x8_material(list) {}

void CCollisionPrimitive::SetMaterial(const CMaterialList& material) { x8_material = material; }

const CMaterialList& CCollisionPrimitive::GetMaterial() const { return x8_material; }

CRayCastResult CCollisionPrimitive::CastRay(const zeus::CVector3f& start, const zeus::CVector3f& dir, float length,
                                            const CMaterialFilter& filter, const zeus::CTransform& xf) const {
  return CastRayInternal(CInternalRayCastStructure(start, dir, length, xf, filter));
}

bool CCollisionPrimitive::InternalCollide(const CInternalCollisionStructure& collision, CCollisionInfoList& list) {
  u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
  u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();

  ComparisonFunc func;
  if (idx0 == -1 || idx1 == -1) {
    sNullCollider = nullptr;
    func = sNullCollider;
  } else {
    func = (*sTableOfCollidables)[sNumTypes * idx1 + idx0];
  }

  if (func) {
    if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
        !collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
      return false;
    return func(collision, list);
  }

  if (idx0 == -1 || idx1 == -1) {
    sNullCollider = nullptr;
    func = sNullCollider;
  } else {
    func = (*sTableOfCollidables)[sNumTypes * idx0 + idx1];
  }

  if (func) {
    if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
        !collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
      return false;
    CInternalCollisionStructure swappedCollision(collision.GetRight(), collision.GetLeft());
    u32 startListCount = list.GetCount();
    if (func(swappedCollision, list)) {
      for (auto it = list.begin() + startListCount; it != list.end(); ++it)
        it->Swap();
      return true;
    }
  }

  return false;
}

bool CCollisionPrimitive::Collide(const CInternalCollisionStructure::CPrimDesc& prim0,
                                  const CInternalCollisionStructure::CPrimDesc& prim1, CCollisionInfoList& list) {
  return InternalCollide({prim0, prim1}, list);
}

bool CCollisionPrimitive::InternalCollideBoolean(const CInternalCollisionStructure& collision) {
  u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
  u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();

  BooleanComparisonFunc func;
  if (idx0 == -1 || idx1 == -1) {
    sNullBooleanCollider = nullptr;
    func = sNullBooleanCollider;
  } else {
    func = (*sTableOfBooleanCollidables)[sNumTypes * idx1 + idx0];
  }

  if (func) {
    if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
        !collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
      return false;
    return func(collision);
  }

  if (idx0 == -1 || idx1 == -1) {
    sNullBooleanCollider = nullptr;
    func = sNullBooleanCollider;
  } else {
    func = (*sTableOfBooleanCollidables)[sNumTypes * idx0 + idx1];
  }

  if (func) {
    if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
        !collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
      return false;
    CInternalCollisionStructure swappedCollision(collision.GetRight(), collision.GetLeft());
    return func(swappedCollision);
  }

  CCollisionInfoList list;
  return InternalCollide(collision, list);
}

bool CCollisionPrimitive::CollideBoolean(const CInternalCollisionStructure::CPrimDesc& prim0,
                                         const CInternalCollisionStructure::CPrimDesc& prim1) {
  return InternalCollideBoolean({prim0, prim1});
}

bool CCollisionPrimitive::InternalCollideMoving(const CInternalCollisionStructure& collision,
                                                const zeus::CVector3f& dir, double& dOut, CCollisionInfo& infoOut) {
  u32 idx0 = collision.GetLeft().GetPrim().GetTableIndex();
  u32 idx1 = collision.GetRight().GetPrim().GetTableIndex();

  MovingComparisonFunc func;
  if (idx0 == -1 || idx1 == -1) {
    sNullMovingCollider = nullptr;
    func = sNullMovingCollider;
  } else {
    func = (*sTableOfMovingCollidables)[sNumTypes * idx1 + idx0];
  }

  if (func) {
    if (!collision.GetLeft().GetFilter().Passes(collision.GetRight().GetPrim().GetMaterial()) ||
        !collision.GetRight().GetFilter().Passes(collision.GetLeft().GetPrim().GetMaterial()))
      return false;
    return func(collision, dir, dOut, infoOut);
  }

  return false;
}

bool CCollisionPrimitive::CollideMoving(const CInternalCollisionStructure::CPrimDesc& prim0,
                                        const CInternalCollisionStructure::CPrimDesc& prim1, const zeus::CVector3f& dir,
                                        double& dOut, CCollisionInfo& infoOut) {
  return InternalCollideMoving({prim0, prim1}, dir, dOut, infoOut);
}

void CCollisionPrimitive::InitBeginTypes() {
  sCollisionTypeList.reset(new std::vector<CCollisionPrimitive::Type>());
  sCollisionTypeList->reserve(3);
  sTypesAdding = true;
  InternalColliders::AddTypes();
}

void CCollisionPrimitive::InitAddType(const CCollisionPrimitive::Type& tp) {
  tp.GetSetter()(sCollisionTypeList->size());
  sCollisionTypeList->push_back(tp);
}

void CCollisionPrimitive::InitEndTypes() {
  sCollisionTypeList->shrink_to_fit();
  sNumTypes = sCollisionTypeList->size();
  sTypesAdding = false;
  sTypesAdded = true;
}

void CCollisionPrimitive::InitBeginColliders() {
  sTableOfCollidables.reset(new std::vector<ComparisonFunc>());
  sTableOfBooleanCollidables.reset(new std::vector<BooleanComparisonFunc>());
  sTableOfMovingCollidables.reset(new std::vector<MovingComparisonFunc>());
  size_t tableSz = sCollisionTypeList->size() * sCollisionTypeList->size();
  sTableOfCollidables->resize(tableSz);
  sTableOfBooleanCollidables->resize(tableSz);
  sTableOfMovingCollidables->resize(tableSz);
  sCollidersAdding = true;
  InternalColliders::AddColliders();
}

void CCollisionPrimitive::InitAddBooleanCollider(const CCollisionPrimitive::BooleanComparison& cmp) {
  int idx0 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
      idx0 = i;
      break;
    }
  }

  int idx1 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
      idx1 = i;
      break;
    }
  }

  if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
    return;

  BooleanComparisonFunc& funcOut =
      (idx0 == -1 || idx1 == -1) ? sNullBooleanCollider : (*sTableOfBooleanCollidables)[idx1 * sNumTypes + idx0];
  funcOut = cmp.GetCollider();
}

void CCollisionPrimitive::InitAddBooleanCollider(BooleanComparisonFunc cmp, const char* a, const char* b) {
  InitAddBooleanCollider({cmp, a, b});
}

void CCollisionPrimitive::InitAddMovingCollider(const CCollisionPrimitive::MovingComparison& cmp) {
  int idx0 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
      idx0 = i;
      break;
    }
  }

  int idx1 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
      idx1 = i;
      break;
    }
  }

  if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
    return;

  MovingComparisonFunc& funcOut =
      (idx0 == -1 || idx1 == -1) ? sNullMovingCollider : (*sTableOfMovingCollidables)[idx1 * sNumTypes + idx0];
  funcOut = cmp.GetCollider();
}

void CCollisionPrimitive::InitAddMovingCollider(MovingComparisonFunc cmp, const char* a, const char* b) {
  InitAddMovingCollider({cmp, a, b});
}

void CCollisionPrimitive::InitAddCollider(const CCollisionPrimitive::Comparison& cmp) {
  int idx0 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType1(), (*sCollisionTypeList)[i].GetInfo())) {
      idx0 = i;
      break;
    }
  }

  int idx1 = -1;
  for (int i = 0; i < sCollisionTypeList->size(); ++i) {
    if (!strcmp(cmp.GetType2(), (*sCollisionTypeList)[i].GetInfo())) {
      idx1 = i;
      break;
    }
  }

  if (idx0 < 0 || idx1 < 0 || idx0 >= sNumTypes || idx1 >= sNumTypes)
    return;

  ComparisonFunc& funcOut =
      (idx0 == -1 || idx1 == -1) ? sNullCollider : (*sTableOfCollidables)[idx1 * sNumTypes + idx0];
  funcOut = cmp.GetCollider();
}

void CCollisionPrimitive::InitAddCollider(ComparisonFunc cmp, const char* a, const char* b) {
  InitAddCollider({cmp, a, b});
}

void CCollisionPrimitive::InitEndColliders() {
  sCollidersAdding = false;
  sCollidersAdded = true;
  sInitComplete = true;
}

void CCollisionPrimitive::Uninitialize() {
  sInitComplete = false;
  sCollidersAdding = false;
  sCollidersAdded = false;
  sTypesAdding = false;
  sTypesAdded = false;
  sNumTypes = 0;
  sCollisionTypeList.reset();
  sTableOfCollidables.reset();
  sTableOfMovingCollidables.reset();
  sTableOfBooleanCollidables.reset();
}

} // namespace urde