#include "precompile.h"

#include <a8/collision.h>

#include "entity.h"
#include "collider.h"

bool ColliderComponent::IntersectSegment(a8::Vec2& p0, a8::Vec2& p1)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            return a8::IntersectSegmentAabb(p0,
                                             p1,
                                             a_aabb->owner->pos + a_aabb->_min,
                                             a_aabb->owner->pos + a_aabb->_max);
        }
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            return a8::IntersectSegmentCircle(p0,
                                               p1,
                                               a_circle->owner->pos + a_circle->pos,
                                               a_circle->rad);
        }
        break;
    }
    return false;
}

bool ColliderComponent::Intersect(ColliderComponent* b)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            switch (b->type) {
            case CT_None:
                break;
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::IntersectAabbAabb(a_aabb->owner->pos + a_aabb->_min,
                                                  a_aabb->owner->pos + a_aabb->_max,
                                                  b_aabb->owner->pos + b_aabb->_min,
                                                  b_aabb->owner->pos + b_aabb->_max
                                                  );
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::IntersectAabbCircle(a_aabb->owner->pos + a_aabb->_min,
                                                    a_aabb->owner->pos + a_aabb->_max,
                                                    b_circle->owner->pos + b_circle->pos,
                                                    b_circle->rad);
                }
                break;
            }
        };
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            switch (b->type) {
            case CT_None:
                break;
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::IntersectAabbCircle(b_aabb->owner->pos + b_aabb->_min,
                                                    b_aabb->owner->pos + b_aabb->_max,
                                                    a_circle->owner->pos + a_circle->pos,
                                                    a_circle->rad);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::IntersectCircleCircle(
                                                      a_circle->owner->pos + a_circle->pos,
                                                      a_circle->rad,
                                                      b_circle->owner->pos + b_circle->pos,
                                                      b_circle->rad);
                }
                break;
            }
        }
        break;
    }
    return false;
}

bool ColliderComponent::CalcSafePoint(ColliderComponent* b, a8::Vec2& new_pos)
{
    switch (type) {
    case CT_None:
        break;
    case CT_Aabb:
        {
            AabbCollider* a_aabb = (AabbCollider*)this;
            switch (b->type) {
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::CalcAabbAabbSafePoint(a_aabb->owner->pos + a_aabb->_min,
                                                      a_aabb->owner->pos + a_aabb->_max,
                                                      b_aabb->owner->pos + b_aabb->_min,
                                                      b_aabb->owner->pos + b_aabb->_max,
                                                      new_pos);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::CalcAabbAabbSafePoint(a_aabb->owner->pos + a_aabb->_min,
                                                      a_aabb->owner->pos + a_aabb->_max,
                                                      b_circle->owner->pos + b_circle->pos,
                                                      b_circle->rad,
                                                      new_pos);
                }
                break;
            }
        }
        break;
    case CT_Circle:
        {
            CircleCollider* a_circle = (CircleCollider*)this;
            switch (b->type) {
            case CT_Aabb:
                {
                    AabbCollider* b_aabb = (AabbCollider*)b;
                    return a8::CalcCircleAabbSafePoint(
                                                        a_circle->owner->pos + a_circle->pos,
                                                        a_circle->rad,
                                                        b_aabb->owner->pos + b_aabb->_min,
                                                        b_aabb->owner->pos + b_aabb->_max,
                                                        new_pos);
                }
                break;
            case CT_Circle:
                {
                    CircleCollider* b_circle = (CircleCollider*)b;
                    return a8::CalcCircleCircleSafePoint(
                                                          a_circle->owner->pos + a_circle->pos,
                                                          a_circle->rad,
                                                          b_circle->owner->pos + b_circle->pos,
                                                          b_circle->rad,
                                                          new_pos);
                }
                break;
            }
        }
        break;
    default:
        break;
    }
    return false;
}

void DestoryCollider(ColliderComponent* collider)
{
    switch (collider->type) {
    case CT_Aabb:
        {
            delete (AabbCollider*)collider;
        }
        break;
    case CT_Circle:
        {
            delete (CircleCollider*)collider;
        }
        break;
    default:
        {
            delete collider;
        }
        break;
    }
}