#include "BoundingBoxData.h"
#include "DisplayData.h"


DRAGONBONES_NAMESPACE_BEGIN

void BoundingBoxData::_onClear()
{
    color = 0x000000;
    width = 0.0f;
    height = 0.0f;
}

int RectangleBoundingBoxData::_computeOutCode(float x, float y, float xMin, float yMin, float xMax, float yMax)
{
    int code = OutCode::InSide;     // initialised as being inside of [[clip window]]

    if (x < xMin)                   // to the left of clip window
    {
        code |= OutCode::Left;
    }
    else if (x > xMax)              // to the right of clip window
    {
        code |= OutCode::Right;
    }

    if (y < yMin)                   // below the clip window
    {
        code |= OutCode::Top;
    }
    else if (y > yMax)              // above the clip window
    {
        code |= OutCode::Bottom;
    }

    return code;
}

int RectangleBoundingBoxData::rectangleIntersectsSegment(
    float xA, float yA, float xB, float yB,
    float xMin, float yMin, float xMax, float yMax,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians
)
{
    const auto inSideA = xA > xMin && xA < xMax && yA > yMin && yA < yMax;
    const auto inSideB = xB > xMin && xB < xMax && yB > yMin && yB < yMax;

    if (inSideA && inSideB) 
    {
        return -1;
    }

    auto intersectionCount = 0;
    auto outcode0 = RectangleBoundingBoxData::_computeOutCode(xA, yA, xMin, yMin, xMax, yMax);
    auto outcode1 = RectangleBoundingBoxData::_computeOutCode(xB, yB, xMin, yMin, xMax, yMax);

    while (true)
    {
        if ((outcode0 | outcode1) == 0) // Bitwise OR is 0. Trivially accept and get out of loop
        {
            intersectionCount = 2;
            break;
        }
        else if ((outcode0 & outcode1) != 0) // Bitwise AND is not 0. Trivially reject and get out of loop
        {
            break;
        }

        // failed both tests, so calculate the line segment to clip
        // from an outside point to an intersection with clip edge
        auto x = 0.0f;
        auto y = 0.0f;
        auto normalRadian = 0.0f;

        // At least one endpoint is outside the clip rectangle; pick it.
        const auto outcodeOut = outcode0 != 0 ? outcode0 : outcode1;

        // Now find the intersection point;
        if ((outcodeOut & OutCode::Top) != 0)               // point is above the clip rectangle
        {
            x = xA + (xB - xA) * (yMin - yA) / (yB - yA);
            y = yMin;

            if (normalRadians != nullptr) 
            {
                normalRadian = -Transform::PI * 0.5f;
            }
        }
        else if ((outcodeOut & OutCode::Bottom) != 0)      // point is below the clip rectangle
        {
            x = xA + (xB - xA) * (yMax - yA) / (yB - yA);
            y = yMax;

            if (normalRadians != nullptr) 
            {
                normalRadian = Transform::PI * 0.5;
            }
        }
        else if ((outcodeOut & OutCode::Right) != 0)       // point is to the right of clip rectangle
        {
            y = yA + (yB - yA) * (xMax - xA) / (xB - xA);
            x = xMax;

            if (normalRadians != nullptr) 
            {
                normalRadian = 0;
            }
        }
        else if ((outcodeOut & OutCode::Left) != 0)        // point is to the left of clip rectangle
        {
            y = yA + (yB - yA) * (xMin - xA) / (xB - xA);
            x = xMin;

            if (normalRadians != nullptr) 
            {
                normalRadian = Transform::PI;
            }
        }

        // Now we move outside point to intersection point to clip
        // and get ready for next pass.
        if (outcodeOut == outcode0) 
        {
            xA = x;
            yA = y;
            outcode0 = RectangleBoundingBoxData::_computeOutCode(xA, yA, xMin, yMin, xMax, yMax);

            if (normalRadians != nullptr) 
            {
                normalRadians->x = normalRadian;
            }
        }
        else 
        {
            xB = x;
            yB = y;
            outcode1 = RectangleBoundingBoxData::_computeOutCode(xB, yB, xMin, yMin, xMax, yMax);

            if (normalRadians != nullptr) 
            {
                normalRadians->y = normalRadian;
            }
        }
    }

    if (intersectionCount) 
    {
        if (inSideA) 
        {
            intersectionCount = 2; // 10

            if (intersectionPointA != nullptr) 
            {
                intersectionPointA->x = xB;
                intersectionPointA->y = yB;
            }

            if (intersectionPointB != nullptr)
            {
                intersectionPointB->x = xB;
                intersectionPointB->y = xB;
            }

            if (normalRadians != nullptr) 
            {
                normalRadians->x = normalRadians->y + Transform::PI;
            }
        }
        else if (inSideB) 
        {
            intersectionCount = 1; // 01

            if (intersectionPointA != nullptr) 
            {
                intersectionPointA->x = xA;
                intersectionPointA->y = yA;
            }

            if (intersectionPointB != nullptr) 
            {
                intersectionPointB->x = xA;
                intersectionPointB->y = yA;
            }

            if (normalRadians != nullptr) 
            {
                normalRadians->y = normalRadians->x + Transform::PI;
            }
        }
        else 
        {
            intersectionCount = 3; // 11
            if (intersectionPointA != nullptr) 
            {
                intersectionPointA->x = xA;
                intersectionPointA->y = yA;
            }

            if (intersectionPointB != nullptr) 
            {
                intersectionPointB->x = xB;
                intersectionPointB->y = yB;
            }
        }
    }

    return intersectionCount;
}

void RectangleBoundingBoxData::_onClear()
{
    BoundingBoxData::_onClear();

    type = BoundingBoxType::Rectangle;
}

bool RectangleBoundingBoxData::containsPoint(float pX, float pY)
{
    const auto widthH = width * 0.5f;
    if (pX >= -widthH && pX <= widthH)
    {
        const auto heightH = height * 0.5f;
        if (pY >= -heightH && pY <= heightH)
        {
            return true;
        }
    }

    return false;
}

int RectangleBoundingBoxData::intersectsSegment(
    float xA, float yA, float xB, float yB,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians
)
{
    const auto widthH = width * 0.5f;
    const auto heightH = height * 0.5f;
    const auto intersectionCount = RectangleBoundingBoxData::rectangleIntersectsSegment(
        xA, yA, xB, yB,
        -widthH, -heightH, widthH, heightH,
        intersectionPointA, intersectionPointB, normalRadians
    );

    return intersectionCount;
}

int EllipseBoundingBoxData::ellipseIntersectsSegment(
    float xA, float yA, float xB, float yB,
    float xC, float yC, float widthH, float heightH,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians
)
{
    const auto d = widthH / heightH;
    const auto dd = d * d;

    yA *= d;
    yB *= d;

    const auto dX = xB - xA;
    const auto dY = yB - yA;
    const auto lAB = sqrt(dX * dX + dY * dY);
    const auto xD = dX / lAB;
    const auto yD = dY / lAB;
    const auto a = (xC - xA) * xD + (yC - yA) * yD;
    const auto aa = a * a;
    const auto ee = xA * xA + yA * yA;
    const auto rr = widthH * widthH;
    const auto dR = rr - ee + aa;
    auto intersectionCount = 0;

    if (dR >= 0.0f) 
    {
        const auto dT = sqrt(dR);
        const auto sA = a - dT;
        const auto sB = a + dT;
        const auto inSideA = sA < 0.0f ? -1 : (sA <= lAB ? 0 : 1);
        const auto inSideB = sB < 0.0f ? -1 : (sB <= lAB ? 0 : 1);
        const auto sideAB = inSideA * inSideB;

        if (sideAB < 0) 
        {
            return -1;
        }
        else if (sideAB == 0) 
        {
            if (inSideA == -1) 
            {
                intersectionCount = 2; // 10
                xB = xA + sB * xD;
                yB = (yA + sB * yD) / d;

                if (intersectionPointA != nullptr) 
                {
                    intersectionPointA->x = xB;
                    intersectionPointA->y = yB;
                }

                if (intersectionPointB != nullptr) 
                {
                    intersectionPointB->x = xB;
                    intersectionPointB->y = yB;
                }

                if (normalRadians != nullptr) 
                {
                    normalRadians->x = atan2(yB / rr * dd, xB / rr);
                    normalRadians->y = normalRadians->x + Transform::PI;
                }
            }
            else if (inSideB == 1) 
            {
                intersectionCount = 1; // 01
                xA = xA + sA * xD;
                yA = (yA + sA * yD) / d;

                if (intersectionPointA != nullptr) 
                {
                    intersectionPointA->x = xA;
                    intersectionPointA->y = yA;
                }

                if (intersectionPointB != nullptr) 
                {
                    intersectionPointB->x = xA;
                    intersectionPointB->y = yA;
                }

                if (normalRadians != nullptr) 
                {
                    normalRadians->x = atan2(yA / rr * dd, xA / rr);
                    normalRadians->y = normalRadians->x + Transform::PI;
                }
            }
            else 
            {
                intersectionCount = 3; // 11

                if (intersectionPointA != nullptr) 
                {
                    intersectionPointA->x = xA + sA * xD;
                    intersectionPointA->y = (yA + sA * yD) / d;

                    if (normalRadians != nullptr) 
                    {
                        normalRadians->x = atan2(intersectionPointA->y / rr * dd, intersectionPointA->x / rr);
                    }
                }

                if (intersectionPointB != nullptr) 
                {
                    intersectionPointB->x = xA + sB * xD;
                    intersectionPointB->y = (yA + sB * yD) / d;

                    if (normalRadians != nullptr) 
                    {
                        normalRadians->y = atan2(intersectionPointB->y / rr * dd, intersectionPointB->x / rr);
                    }
                }
            }
        }
    }

    return intersectionCount;
}

void EllipseBoundingBoxData::_onClear()

{
    BoundingBoxData::_onClear();

    type = BoundingBoxType::Ellipse;
}

bool EllipseBoundingBoxData::containsPoint(float pX, float pY)
{
    const auto widthH = width * 0.5f;
    if (pX >= -widthH && pX <= widthH) 
    {
        const auto heightH = height * 0.5f;
        if (pY >= -heightH && pY <= heightH) 
        {
            pY *= widthH / heightH;
            return sqrt(pX * pX + pY * pY) <= widthH;
        }
    }

    return false;
}

int EllipseBoundingBoxData::intersectsSegment(
    float xA, float yA, float xB, float yB,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians
)
{
    const auto intersectionCount = EllipseBoundingBoxData::ellipseIntersectsSegment(
        xA, yA, xB, yB,
        0.0f, 0.0f, width * 0.5f, height * 0.5f,
        intersectionPointA, intersectionPointB, normalRadians
    );

    return intersectionCount;
}

int PolygonBoundingBoxData::polygonIntersectsSegment(
    float xA, float yA, float xB, float yB,
    const std::vector<float>& vertices,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians)
{
    if (xA == xB) 
    {
        xA = xB + 0.000001f;
    }

    if (yA == yB) 
    {
        yA = yB + 0.000001f;
    }

    const auto count = vertices.size();
    const auto dXAB = xA - xB;
    const auto dYAB = yA - yB;
    const auto llAB = xA * yB - yA * xB;
    auto intersectionCount = 0;
    auto xC = vertices[count - 2];
    auto yC = vertices[count - 1];
    auto dMin = 0.0f;
    auto dMax = 0.0f;
    auto xMin = 0.0f;
    auto yMin = 0.0f;
    auto xMax = 0.0f;
    auto yMax = 0.0f;

    for (std::size_t i = 0; i < count; i += 2) 
    {
        const auto xD = vertices[i];
        const auto yD = vertices[i + 1];

        if (xC == xD) 
        {
            xC = xD + 0.000001f;
        }

        if (yC == yD) 
        {
            yC = yD + 0.000001f;
        }

        const auto dXCD = xC - xD;
        const auto dYCD = yC - yD;
        const auto llCD = xC * yD - yC * xD;
        const auto ll = dXAB * dYCD - dYAB * dXCD;
        const auto x = (llAB * dXCD - dXAB * llCD) / ll;

        if (((x >= xC && x <= xD) || (x >= xD && x <= xC)) && (dXAB == 0.0f || (x >= xA && x <= xB) || (x >= xB && x <= xA))) 
        {
            const auto y = (llAB * dYCD - dYAB * llCD) / ll;
            if (((y >= yC && y <= yD) || (y >= yD && y <= yC)) && (dYAB == 0.0f || (y >= yA && y <= yB) || (y >= yB && y <= yA))) 
            {
                if (intersectionPointB != nullptr) 
                {
                    float d = x - xA;
                    if (d < 0.0f) 
                    {
                        d = -d;
                    }

                    if (intersectionCount == 0) 
                    {
                        dMin = d;
                        dMax = d;
                        xMin = x;
                        yMin = y;
                        xMax = x;
                        yMax = y;

                        if (normalRadians != nullptr) 
                        {
                            normalRadians->x = atan2(yD - yC, xD - xC) - Transform::PI * 0.5f;
                            normalRadians->y = normalRadians->x;
                        }
                    }
                    else 
                    {
                        if (d < dMin) 
                        {
                            dMin = d;
                            xMin = x;
                            yMin = y;

                            if (normalRadians != nullptr) 
                            {
                                normalRadians->x = atan2(yD - yC, xD - xC) - Transform::PI * 0.5f;
                            }
                        }

                        if (d > dMax) 
                        {
                            dMax = d;
                            xMax = x;
                            yMax = y;

                            if (normalRadians != nullptr) {
                                normalRadians->y = atan2(yD - yC, xD - xC) - Transform::PI * 0.5f;
                            }
                        }
                    }

                    intersectionCount++;
                }
                else 
                {
                    xMin = x;
                    yMin = y;
                    xMax = x;
                    yMax = y;
                    intersectionCount++;

                    if (normalRadians != nullptr) 
                    {
                        normalRadians->x = atan2(yD - yC, xD - xC) - Transform::PI * 0.5f;
                        normalRadians->y = normalRadians->x;
                    }
                    break;
                }
            }
        }

        xC = xD;
        yC = yD;
    }

    if (intersectionCount == 1) 
    {
        if (intersectionPointA != nullptr) 
        {
            intersectionPointA->x = xMin;
            intersectionPointA->y = yMin;
        }

        if (intersectionPointB != nullptr) 
        {
            intersectionPointB->x = xMin;
            intersectionPointB->y = yMin;
        }

        if (normalRadians != nullptr) 
        {
            normalRadians->y = normalRadians->x + Transform::PI;
        }
    }
    else if (intersectionCount > 1) 
    {
        intersectionCount++;

        if (intersectionPointA != nullptr) 
        {
            intersectionPointA->x = xMin;
            intersectionPointA->y = yMin;
        }

        if (intersectionPointB != nullptr) 
        {
            intersectionPointB->x = xMax;
            intersectionPointB->y = yMax;
        }
    }

    return intersectionCount;
}

void PolygonBoundingBoxData::_onClear()
{
    BoundingBoxData::_onClear();

    if (weight != nullptr) 
    {
        weight->returnToPool();
    }

    type = BoundingBoxType::Polygon;
    x = 0.0f;
    y = 0.0f;
    vertices.clear();
    weight = nullptr;
}

bool PolygonBoundingBoxData::containsPoint(float pX, float pY)
{
    auto isInSide = false;
    if (pX >= x && pX <= width && pY >= y && pY <= height) 
    {
        for (std::size_t i = 0, l = vertices.size(), iP = l - 2; i < l; i += 2)
        {
            const auto yA = vertices[iP + 1];
            const auto yB = vertices[i + 1];
            if ((yB < pY && yA >= pY) || (yA < pY && yB >= pY)) 
            {
                const auto xA = vertices[iP];
                const auto xB = vertices[i];
                if ((pY - yB) * (xA - xB) / (yA - yB) + xB < pX) 
                {
                    isInSide = !isInSide;
                }
            }

            iP = i;
        }
    }

    return isInSide;
}

int PolygonBoundingBoxData::intersectsSegment(
    float xA, float yA, float xB, float yB,
    Point* intersectionPointA,
    Point* intersectionPointB,
    Point* normalRadians
)
{
    auto intersectionCount = 0;
    if (RectangleBoundingBoxData::rectangleIntersectsSegment(xA, yA, xB, yB, x, y, x + width, y + height, nullptr, nullptr, nullptr) != 0) {
        intersectionCount = PolygonBoundingBoxData::polygonIntersectsSegment(
            xA, yA, xB, yB,
            vertices,
            intersectionPointA, intersectionPointB, normalRadians
        );
    }

    return intersectionCount;
}

DRAGONBONES_NAMESPACE_END