Types.h

#pragma once

#include <chrono>
#include <exception>
#include <memory>
#include <sstream>
#include <functional>
#include <map>
#include <tuple>
#include <variant>
#include <cstdint>
#include <uuid/uuid.h>
#include <SDL2/SDL.h>
#include "Constants.h"
#include "Math.h"

namespace rose {
#ifdef DISPLAY800X480
    static constexpr int DISPLAY_WIDTH = 800;
    static constexpr int DISPLAY_HEIGHT = 480;
    static constexpr int EARTH_BIG_W = 660;
    static constexpr int EARTH_BIG_H = 330;
    static constexpr std::string_view EARTH_BIG_S = "660x330";
#define EARTH_BIG_S 660x330
#else
    static constexpr int DISPLAY_WIDTH = 800;
    static constexpr int DISPLAY_HEIGHT = 480;
    static constexpr int EARTH_BIG_W = 660;
    static constexpr int EARTH_BIG_H = 330;
#define EARTH_BIG_S 660x330                         
#endif

    using FontSize = int;

    using ImageId = uint32_t;

    using SignalToken = uint32_t;

    using LinearScaleSignalType = std::pair<float, SignalToken>;

    struct StartOffset {
        int mStartOffset;       
    };

    struct FillToEnd {
        bool mFillToEnd;        
    };

    struct InternalSpace {
        int mInternalSpace;     
    };

    struct MinimumOrthogonal {
        int mMinimumOrthogonal; 
    };

    class GeoPosition : public std::array<double, 2> {
    public:
        constexpr GeoPosition() noexcept: std::array<double,2>({0., 0.}) {}

        constexpr GeoPosition(double lat, double lon) noexcept
            : std::array<double,2>({std::clamp(lat,-90.,90.),
                                    std::clamp(lon,-180.,180.)}) {}

        constexpr explicit GeoPosition(std::tuple<double,double> geo) : GeoPosition(std::get<0>(geo), std::get<1>(geo)) {}

        GeoPosition& operator=(const std::tuple<double,double>& geo) {
            at(0) = std::get<0>(geo);
            at(1) = std::get<1>(geo);
            return *this;
        }

        [[nodiscard]] GeoPosition radians() const {
            GeoPosition r{util::deg2rad(at(0)), util::deg2rad(at(1))};
            return r;
        }

        constexpr double& lat() noexcept {
            return at(0);
        }

        constexpr double& lon() noexcept {
            return at(1);
        }

        [[nodiscard]] constexpr double lat() const noexcept {
            return at(0);
        }

        [[nodiscard]] constexpr double lon() const noexcept {
            return at(1);
        }
    };

    class Elastic {
    protected:
        Orientation mElastic{Orientation::Unset};   

    public:

        Elastic() = default;

        explicit Elastic(Orientation orientation) : mElastic(orientation) {}

        bool horizontal() { return mElastic == Orientation::Horizontal || mElastic == Orientation::Both; }

        bool vertical() { return mElastic == Orientation::Vertical || mElastic == Orientation::Both; }

        bool primary(Orientation orientation) { return mElastic == Orientation::Both || mElastic == orientation; }

        bool secondary(Orientation orientation) {
            if (mElastic == Orientation::Both)
                return true;
            if (orientation == Orientation::Horizontal && mElastic == Orientation::Vertical)
                return true;
            if (orientation == Orientation::Vertical && mElastic == Orientation::Horizontal)
                return true;
            return false;
        }
    };

    struct FontName {
        std::string fontName{};
        FontName() : fontName() {}
        explicit FontName(const char *string) : fontName(string) {}
        explicit FontName(const std::string_view stringView) : fontName(stringView) {}
        explicit FontName(std::string string) : fontName(std::move(string)) {}
    };

    class RoseLogicError : public std::logic_error {
    public:
        explicit RoseLogicError(const std::string &what) : std::logic_error(what) {}

        explicit RoseLogicError(std::string_view what) : std::logic_error(std::string(what)) {}

        explicit RoseLogicError(const char *what) : std::logic_error(std::string(what)) {}
    };

    class RoseRuntimeError : public std::runtime_error {
    public:
        explicit RoseRuntimeError(const std::string &what) : std::runtime_error(what) {}

        explicit RoseRuntimeError(std::string_view what) : std::runtime_error(std::string(what)) {}

        explicit RoseRuntimeError(const char *what) : std::runtime_error(std::string(what)) {}
    };
}