Types.h

#pragma once

#include <iostream>
#include <tuple>
#include <utility>
#include "Color.h"
#include "Math.h"

namespace rose {

    template<typename I = int>
    constexpr I WINDOWPOS_UNDEFINED_DISPLAY(uint display=0) {
        return static_cast<I>(SDL_WINDOWPOS_UNDEFINED_MASK | display);
    }

    template<typename I = int>
    constexpr I WINDOWPOS_CENTERED_DISPLAY(uint display=0) {
        return static_cast<I>(SDL_WINDOWPOS_CENTERED_MASK | display);
    }

    static constexpr int WINDOWPOS_UNDEFINED = WINDOWPOS_UNDEFINED_DISPLAY();
    static constexpr int WINDOWPOS_CENTERED = WINDOWPOS_CENTERED_DISPLAY();

    enum RendererFlags : uint32_t {
        RENDERER_SOFTWARE = static_cast<uint32_t>(SDL_RENDERER_SOFTWARE),         
        RENDERER_ACCELERATED = static_cast<uint32_t>(SDL_RENDERER_ACCELERATED),   
        RENDERER_PRESENTVSYNC = static_cast<uint32_t>(SDL_RENDERER_PRESENTVSYNC), 
        RENDERER_TARGETTEXTURE = static_cast<uint32_t>(SDL_RENDERER_TARGETTEXTURE) 
    };

    enum class Orientation {
        Horizontal,
        Vertical,
    };

    enum class BorderStyle {
        Unset,      
        None,       
        BevelOut,   
        BevelIn,    
        NotchOut,   
        NotchIn,    
    };

    enum class CornerStyle {
        Unset,      
        Square,     
        Round,      
    };

    namespace set {
        static constexpr std::string_view SetAppSize{"SetAppSize"};
        static constexpr std::string_view SetAppPosition{"SetAppPosition"};
        static constexpr std::string_view SetAppState{"SetAppState"};
    }

    struct FrameSettings {
        std::pair<color::RGBA,color::RGBA>  backgroundPair;
        std::pair<BorderStyle,BorderStyle>  borderStylePair;

        color::RGBA background(bool invert) {
            return invert ? backgroundPair.second : backgroundPair.first;
        }

        BorderStyle borderStyle(bool invert) {
            return invert ? borderStylePair.second : borderStylePair.first;
        }
    };

    template <typename T>
    struct Position {
        T x{0}, y{0};

        constexpr Position() noexcept = default;

        template<typename O>
        constexpr Position(O X, O Y) noexcept {
            if constexpr (std::is_same_v<T,O>) {
                x = X;
                y = Y;
            } else if constexpr (std::is_integral_v<T> && std::is_floating_point_v<O>) {
                x = util::roundToInt(X);
                y = util::roundToInt(Y);
            } else {
                x = static_cast<T>(X);
                y = static_cast<T>(Y);
            }
        }

        constexpr Position(const Position &p) = default;
        constexpr Position(Position &&p)  noexcept = default;
        constexpr Position& operator=(const Position &p) = default;
        constexpr Position& operator=(Position &&p) = default;

        constexpr explicit Position(T p) noexcept : x(p), y(p) {}

        template <typename O>
        constexpr Position operator+(const Position<O> &p) const noexcept {
            if constexpr (std::is_same_v<T,O>) {
                return Position{x + p.x, y + p.y};
            } else if constexpr (std::is_integral_v<T> && std::is_floating_point_v<O>) {
                return Position{x + util::roundToInt(p.x), y + util::roundToInt(p.y)};
            } else {
                return Position{x + static_cast<T>(p.x), y + static_cast<T>(p.y)};
            }
        }

        template <typename O>
        constexpr Position operator-(const Position<O> &p) const noexcept {
            if constexpr (std::is_same_v<T,O>) {
                return Position{x - p.x, y - p.y};
            } else if constexpr (std::is_integral_v<T> && std::is_floating_point_v<O>) {
                return Position{x - util::roundToInt(p.x), y - util::roundToInt(p.y)};
            } else {
                return Position{x - static_cast<T>(p.x), y - static_cast<T>(p.y)};
            }
        }

        template<typename O>
        Position<O> as() const {
            if constexpr (std::is_same_v<T,O>) {
                return Position<O>{x, y};
            } else if constexpr (std::is_integral_v<O> && std::is_floating_point_v<T>) {
                return Position<O>{util::roundToInt(x), util::roundToInt(y)};
            } else {
                return Position<O>{static_cast<O>(x), static_cast<O>(y)};
            }
        }

        bool operator!=(const Position &other) const noexcept {
            return x != other.x || y != other.y;
        }

        bool operator==(const Position &other) const noexcept {
            return x == other.x && y == other.y;
        }

        bool operator<=(const Position &other) const noexcept {
            return x <= other.x && y <= other.y;
        }

        T& primary(Orientation o) noexcept {
            return o == Orientation::Horizontal ? x : y;
        }

        T& secondary(Orientation o) noexcept {
            return o == Orientation::Horizontal ? y : x;
        }

        [[nodiscard]] constexpr T primary(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? x : y;
        }

        [[nodiscard]] constexpr T secondary(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? y : x;
        }

        [[nodiscard]] constexpr T rSqr(const Position &other) const noexcept {
            auto dX = other.x - x;
            auto dY = other.y - y;
            return dX*dX + dY*dY;
        }

        void swap() noexcept {
            std::swap(x,y);
        }

        [[nodiscard]] constexpr Position<T> mirrorX() const noexcept {
            return Position<T>{-x, y};
        }

        [[nodiscard]] constexpr Position<T> mirrorY() const noexcept {
            return Position<T>{x, -y};
        }
    };

    static constexpr Position<int> UndefinedPosition;

    struct Size {
        int w{0}, h{0};

        constexpr Size() noexcept = default;
        constexpr Size(int W, int H) noexcept : w(W), h(H) {}
        constexpr Size(const Size &p) = default;
        constexpr Size(Size &&p) = default;
        constexpr Size& operator=(const Size &p) = default;
        constexpr Size& operator=(Size &&p) = default;

        constexpr explicit Size(int size) noexcept : w(size), h(size) {}

        constexpr explicit Size(const std::tuple<int,int> &size) noexcept : Size(std::get<0>(size), std::get<1>(size)) {}

        constexpr Size& operator=(std::tuple<int,int> &size) noexcept {
            w = std::get<0>(size);
            h = std::get<0>(size);
            return *this;
        }

        explicit operator bool() const { return w > 0 && h > 0; }

        bool operator!=(const Size &other) const noexcept {
            return w != other.w || h != other.h;
        }

        bool operator==(const Size &other) const noexcept {
            return w == other.w && h == other.h;
        }

        bool operator<(const Size &other) const noexcept {
            return w < other.w && h < other.h;
        }

        bool operator<=(const Size &other) const noexcept {
            return w <= other.w && h <= other.h;
        }

        bool operator>=(const Size &other) const noexcept {
            return !(operator<(other));
        }

        Size operator+(const Size &other) const noexcept {
            return Size{w + other.w, h + other.h};
        }

        Size operator-(const Size &other) const noexcept {
            return Size{w - other.w, h - other.h};
        }

        Size operator/(const int divisor) const  {
            return Size{w / divisor, h / divisor};
        }

        int& primary(Orientation o) noexcept {
            return o == Orientation::Horizontal ? w : h;
        }

        int& secondary(Orientation o) noexcept {
            return o == Orientation::Horizontal ? h : w;
        }

        [[nodiscard]] constexpr int primary(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? w : h;
        }

        [[nodiscard]] constexpr int secondary(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? h : w;
        }

        static Size Zero;
    };

    struct Rectangle {
        int x{0}, y{0}, w{0}, h{0};

        constexpr Rectangle() noexcept = default;
        constexpr Rectangle(int X, int Y, int W, int H) noexcept : x(X), y(Y), w(W), h(H) {}
        constexpr Rectangle(const Position<int> &p, const Size &s) noexcept : x(p.x), y(p.y), w(s.w), h(s.h) {}
        constexpr Rectangle(const Rectangle &p) = default;
        constexpr Rectangle(Rectangle &&p) = default;
        constexpr Rectangle& operator=(const Rectangle &p) = default;
        constexpr Rectangle& operator=(Rectangle &&p) = default;

        constexpr Rectangle& operator=(const Size &s) {
            w = s.w;
            h = s.h;
            return *this;
        }

        constexpr Rectangle& operator=(const Position<int> &p) {
            x = p.x;
            y = p.y;
            return *this;
        }

        constexpr Rectangle operator + (const Position<int> &p) const noexcept {
            return Rectangle{x+p.x, y+p.y, w, h};
        }

        constexpr Rectangle operator + (const Size &s) const noexcept {
            return Rectangle{ x, y, w + s.w, h + s.h};
        }

        constexpr Rectangle operator - (const Size &s) const noexcept {
            return Rectangle{ x, y, w - s.w, h - s.h};
        }

        [[nodiscard]] Position<int> position() const noexcept {
            return Position<int>{x,y};
        }

        [[nodiscard]] Size size() const noexcept {
            return Size{w,h};
        }

        [[nodiscard]] std::pair<Position<int>,Position<int>> primeCorners() const noexcept {
            return std::make_pair(Position<int>{x,y}, Position<int>{x+w,y+h});
        }

        [[nodiscard]] std::pair<Position<int>,Position<int>> crossCorners() const noexcept {
            return std::make_pair(Position<int>{x+w,y}, Position<int>{x,y+h});
        }

        [[nodiscard]] std::tuple<Position<int>,Position<int>,Position<int>,Position<int>> corners() const noexcept {
            auto [tl,br] = primeCorners();
            auto [bl,tr] = crossCorners();
            return std::make_tuple(tl,tr,bl,br);
        }

        [[nodiscard]] constexpr bool contains(Position<int> pos) const noexcept {
            return pos.x >= x && pos.x < x + w && pos.y >= y && pos.y < y + h;
        }

        [[nodiscard]] constexpr bool noOverlap(const Rectangle& o) const noexcept {
            return x > o.x + o.w || o.x > x + w || y > o.y + o.h || o.y > y + h;
        }

        [[nodiscard]] constexpr bool overlap(const Rectangle& o) const noexcept {
            return !noOverlap(o);
        }

        [[nodiscard]] Rectangle intersection(const Rectangle &o) const {
            // gives bottom-left point
            // of intersection rectangle

            auto x5 = std::max(x, o.x);
            auto y5 = std::max(y, o.y);

            // gives top-right point
            // of intersection rectangle
            auto x6 = std::min(x+w, o.x+o.w);
            auto y6 = std::min(y+h, o.y+o.h);

            // no intersection
            if (x5 > x6 || y5 > y6) {
                return Rectangle{0,0,0,0};
            }

            return Rectangle{x5, y5, x6 - x5, y6 - y5};
        }

        int& sizePri(Orientation o) noexcept {
            return o == Orientation::Horizontal ? w : h;
        }

        int& sizeSec(Orientation o) noexcept {
            return o == Orientation::Horizontal ? h : w;
        }

        int& posPri(Orientation o) noexcept {
            return o == Orientation::Horizontal ? x : y;
        }

        int& posSec(Orientation o) noexcept {
            return o == Orientation::Horizontal ? y : x;
        }

        [[nodiscard]] constexpr int sizePri(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? w : h;
        }

        [[nodiscard]] constexpr int sizeSec(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? h : w;
        }

        [[nodiscard]] constexpr int posPri(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? x : y;
        }

        [[nodiscard]] constexpr int posSec(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? y : x;
        }

        static Rectangle Zero;
    };

    struct Padding {
        int t{0}, b{0}, l{0}, r{0};

        constexpr Padding() noexcept = default;

        constexpr explicit Padding(int p) noexcept : t(p), b(p), l(p), r(p) {}

        constexpr Padding(int h, int v) noexcept : t(v), b(v), l(h), r(h) {}

        constexpr Padding(int top, int bot, int left, int right) noexcept : t(top), b(bot), l(left), r(right) {}

        [[nodiscard]] constexpr int vertical() const noexcept { return t + b; }

        [[nodiscard]] constexpr int horizontal() const noexcept { return l + r; }

        [[nodiscard]] constexpr Position<int> position() const noexcept { return Position<int>{l, t}; }

        [[nodiscard]] constexpr Size size() const noexcept { return Size{horizontal(), vertical()}; }

        int& priLead(Orientation o) noexcept {
            return o == Orientation::Horizontal ? l : t;
        }

        int& priLag(Orientation o) noexcept {
            return o == Orientation::Horizontal ? r : b;
        }

        int& secLead(Orientation o) noexcept {
            return o == Orientation::Horizontal ? t : l;
        }

        int& secLag(Orientation o) noexcept {
            return o == Orientation::Horizontal ? b : r;
        }

        [[nodiscard]] constexpr int priLead(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? l : t;
        }

        [[nodiscard]] constexpr int priLag(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? r : b;
        }

        [[nodiscard]] constexpr int secLead(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? t : l;
        }

        [[nodiscard]] constexpr int secLag(Orientation o) const noexcept {
            return o == Orientation::Horizontal ? b : r;
        }
    };

    std::array<char, 8> utf8(int c);
}

inline std::ostream& operator<<(std::ostream& strm, const rose::Size &size) {
    strm << '(' << size.w << ',' << size.h << ')';
    return strm;
}

template<typename T>
inline std::ostream& operator<<(std::ostream& strm, const rose::Position<T> &pos) {
    strm << '(' << pos.x << ',' << pos.y << ')';
    return strm;
}

inline std::ostream& operator<<(std::ostream& strm, const rose::Rectangle &rec) {
    strm << '(' << rec.x << ',' << rec.y << ',' << rec.w << ',' << rec.h << ')';
    return strm;
}

inline std::ostream& operator<<(std::ostream& strm, const rose::Padding &pad) {
    strm << '[' << pad.t << ',' << pad.l << ',' << pad.b << ',' << pad.r << ']';
    return strm;
}