#ifndef SHAPE_HPP
#define SHAPE_HPP 1

#include "vex.hpp"
#include <iostream>
#include <variant>

namespace shapes {

template<vex::arithmetic T>
struct shape
{
    vex::vec2<T> position;

    constexpr shape(const vex::vec2<T> p) : position(p) {}
    constexpr shape(T x, T y) : position(x, y) {}

    virtual void scale(T by) = 0;
    virtual void translate(vex::vec2<T> by) { position += by; }
};

template<vex::arithmetic T>
struct point : public shape<T>
{
    constexpr point(T x, T y) : shape<T>(vex::vec2<T>(x, y)) {}
    constexpr point(const vex::vec2<T> &pos) : shape<T>(pos) {}

    void scale(T by) override { (void)by; }
};

template<vex::arithmetic T>
struct line : public shape<T>
{
    vex::vec2<T> end;
    constexpr line(T x, T y, T z, T w) : shape<T>(vex::vec2<T>(x, y)), end(z, w){}
    constexpr line(const vex::vec2<T> &pos, const vex::vec2<T> End) : shape<T>(pos), end(End) {}

    void translate(vex::vec2<T> by)
    {
        this->position += by;
        end += by;
    }
    void scale(T by) override {
        end = vex::vec2<T>(
        (T)std::floor((double)end[0] / (double)by),
        (T)std::floor((double)end[1] / (double)by));
    }
};

template<vex::arithmetic T>
struct circle : public shape<T>
{
    T radius;
    constexpr circle(T x, T y, T r) : shape<T>(vex::vec2<T>(x, y)), radius(r) {}
    constexpr circle(const vex::vec2<T> &pos, T r) : shape<T>(pos), radius(r) {}

    void scale(T by) override { radius /= by; }
};

template<vex::arithmetic T>
struct ellipse : public shape<T>
{
    T a, b;
    constexpr ellipse(T x, T y, T A, T B) : shape<T>(x, y), a(A), b(B) {}
    constexpr ellipse(const vex::vec2<T> &pos, T A, T B) : shape<T>(pos), a(A), b(B) {}

    void scale(T by) override {a /= by; b /= by; }
};

template<vex::arithmetic T>
struct rectangle : public shape<T>
{
    vex::vec2<T> bounds;
    constexpr rectangle(T x, T y, T w, T h) : shape<T>(vex::vec2<T>(x, y)), bounds(w, h) {}
    constexpr rectangle(const vex::vec2<T> &pos, const vex::vec2<T> &wh) : shape<T>(pos), bounds(wh) {}

    void scale(T by) override { bounds /= by; }
};

template<vex::arithmetic T>
using shapes_variant = std::variant<
    point<T>, line<T>, circle<T>, ellipse<T>, rectangle<T>
>;

template<vex::arithmetic L, vex::arithmetic R>
static bool 
intersects(const circle<L> &lhs, const point<R> &rhs)
{
    vex::vec2<L> dist = rhs.position - lhs.position;
    //std::cout << dist.magnitude() << ' ' << lhs.radius << ' ' << dist.magnitude() - lhs.radius << std::endl;
    return dist.magnitude() < lhs.radius;
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const point<L> &lhs, const circle<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool 
intersects(const ellipse<L> &lhs, const point<R> &rhs)
{
    auto ds = lhs.position - rhs.position;
    auto d2 = ds * ds;
    L a2 = lhs.a * lhs.a;
    L b2 = lhs.b * lhs.b;

    return (((double)d2[0] / a2) + ((double)d2[1] / b2)) <= 1;
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const point<L> &lhs, const ellipse<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool 
intersects(const rectangle<L> &lhs, const point<R> &rhs)
{
    vex::vec2<L> corner = lhs.position + lhs.bounds;
    return (rhs.position[0] > lhs.position[0] && rhs.position[0] < corner[0] &&
            rhs.position[1] > lhs.position[1] && rhs.position[1] < corner[1]);
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const point<L> &lhs, const rectangle<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool 
intersects(const line<L> &lhs, const line<R> &rhs)
{
    double x1 = lhs.position[0], x2 = lhs.end[0], x3 = rhs.position[0], x4 = rhs.end[0];
    double y1 = lhs.position[1], y2 = lhs.end[1], y3 = rhs.position[1], y4 = rhs.end[1];
    double uA = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3)) / ((y4-y3)*(x2-x1) - (x4-x3)*(y2-y1));
    double uB = ((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3)) / ((y4-y3)*(x2-x1) - (x4-x3)*(y2-y1));

    if(uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1) return true;
    return false;
}

template<vex::arithmetic L, vex::arithmetic R>
static bool 
intersects(const rectangle<L> &lhs, const line<R> &rhs)
{
    vex::vec2<L> corner = lhs.position + lhs.bounds;
    line<R> l(lhs.position, lhs.position + vex::vec2<R>(0, lhs.bounds[1]));
    line<R> r(lhs.position + vex::vec2<R>(lhs.bounds[0], 0), corner);
    line<R> d(lhs.position, lhs.position + vex::vec2<R>(lhs.bounds[0], 0));
    line<R> u(lhs.position + vex::vec2<R>(0, lhs.bounds[1]), corner);

    if(intersects(rhs, l) || intersects(rhs, r) || intersects(rhs, d) || intersects(rhs, u)) return true;
    return (rhs.position[0] > lhs.position[0] && rhs.position[0] < corner[0] &&
            rhs.position[1] > lhs.position[1] && rhs.position[1] < corner[1]) &&
           (rhs.end[0] > lhs.position[0] && rhs.end[0] < corner[0] &&
            rhs.end[1] > lhs.position[1] && rhs.end[1] < corner[1]);
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const line<L> &lhs, const rectangle<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool
intersects(const rectangle<L> &lhs, const circle<R> &rhs)
{
    vex::vec2<L> dist{
        rhs.position[0] - std::max(lhs.position[0], std::min(rhs.position[0], lhs.position[0] + lhs.bounds[0])),
        rhs.position[1] - std::max(lhs.position[1], std::min(rhs.position[1], lhs.position[1] + lhs.bounds[1])),
    };
    return (dist[0] * dist[0]) + (dist[1] * dist[1]) < (rhs.radius * rhs.radius);
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const circle<L> &lhs, const rectangle<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool
intersects(const rectangle<L> &lhs, const ellipse<R> &rhs)
{
    vex::vec2<L> dist{
        rhs.position[0] - std::max(lhs.position[0], std::min(rhs.position[0], lhs.position[0] + lhs.bounds[0])),
        rhs.position[1] - std::max(lhs.position[1], std::min(rhs.position[1], lhs.position[1] + lhs.bounds[1])),
    };
    vex::vec2<R> ab2 {
        std::max<R>(1, rhs.a * rhs.a),
        std::max<R>(1, rhs.b * rhs.b)
    };
    return ((dist[0] * dist[0]) / ab2[0]) + ((dist[1] * dist[1]) / ab2[1]) <= 1.0;
}
template<vex::arithmetic L, vex::arithmetic R>
static bool intersects(const ellipse<L> &lhs, const rectangle<R> &rhs) { return intersects(rhs, lhs); }

template<vex::arithmetic L, vex::arithmetic R>
static bool
intersects(const rectangle<L> &lhs, const rectangle<R> &rhs)
{
    return (
        (lhs.position[0] < rhs.position[0] + rhs.bounds[0]) &&
        (lhs.position[0] + lhs.bounds[0] > rhs.position[0]) &&
        (lhs.position[1] + lhs.bounds[1] < rhs.position[1]) &&
        (lhs.position[1] > rhs.position[1] + rhs.position[1])
            );
}

}

#endif