Color.h

#pragma once

#include <algorithm>
#include <array>
#include <SDL.h>
#include <iostream>
#include "Configuration.h"

namespace rose::color {

    struct Value : public std::array<float, 4> {
        constexpr Value() noexcept: std::array<float, 4>() {
            for (auto &v : *this) {
                v = 0.f;
            }
        }

        constexpr explicit Value(std::array<float, 4> v) noexcept: std::array<float, 4>(v) {}
    };

    struct HSVA;
    struct RGBA : public Value {

        static const RGBA TransparentBlack;

        static const RGBA OpaqueBlack;

        static const RGBA OpaqueWhite;

        constexpr RGBA() noexcept = default;

        constexpr explicit RGBA(std::array<float, 4> v) noexcept: Value(v) {}

        constexpr RGBA(uint r, uint g, uint b, uint a) noexcept {
            operator[](0) = (float) (r & 0xffu) / 255.f;
            operator[](1) = (float) (g & 0xffu) / 255.f;
            operator[](2) = (float) (b & 0xffu) / 255.f;
            operator[](3) = (float) (a & 0xffu) / 255.f;
        }

        constexpr RGBA(float r, float g, float b, float a) noexcept {
            operator[](0) = r;
            operator[](1) = g;
            operator[](2) = b;
            operator[](3) = a;
        }

        constexpr explicit RGBA(const HSVA &hsva) noexcept;

        [[nodiscard]] constexpr SDL_Color toSdlColor() const noexcept {
            SDL_Color color{};
            color.r = (uint8_t)(r() * 255.f);
            color.g = (uint8_t)(g() * 255.f);
            color.b = (uint8_t)(b() * 255.f);
            color.a = (uint8_t)(a() * 255.f);
            return color;
        }

        constexpr float &r() noexcept { return operator[](0); }

        [[nodiscard]] constexpr float r() const noexcept { return operator[](0); }

        constexpr float &g() noexcept { return operator[](1); }

        [[nodiscard]] constexpr float g() const noexcept { return operator[](1); }

        constexpr float &b() noexcept { return operator[](2); }

        [[nodiscard]] constexpr float b() const noexcept { return operator[](2); }

        constexpr float &a() noexcept { return operator[](3); }

        [[nodiscard]] constexpr float a() const noexcept { return operator[](3); }

        constexpr RGBA operator*(float m) const noexcept {
            return RGBA{r() * m, g() * m, b() * m, a() * m};
        }

        [[nodiscard]] constexpr RGBA brightness(float m) const noexcept {
            return RGBA{r() * m, g() * m, b() * m, a() * m};
        }

        constexpr RGBA operator+(const RGBA color) const noexcept {
            return RGBA{r() + color.r(), g() + color.g(), b() + color.b(), a() + color.a()};
        }

        [[nodiscard]] constexpr RGBA interpolate(const RGBA& to, float v) const noexcept {
            auto inter = [](float from, float to, float value) -> float {
                return from + (to - from) * value;
            };

            RGBA result{};
            result[0] = inter(operator[](0), to[0], v);
            result[1] = inter(operator[](1), to[1], v);
            result[2] = inter(operator[](2), to[2], v);
            result[3] = inter(operator[](3), to[3], v);

            return result;
        }

        [[nodiscard]] constexpr RGBA withAlpha(float alpha) const noexcept {
            auto r = *this;
            r[3] = alpha;
            return r;
        }

        [[nodiscard]] HSVA toHSVA() const;
    };

    template<typename T>
    static constexpr T mod(T x, T y) noexcept {
        if (y == 0)
            return 0;
        if constexpr (std::is_integral_v<T>) {
            return x % y;
        } else {
            auto trunc = (float) ((int) (x / y));
            auto r = x - trunc * y;
            return r;
        }
    }

    struct HSVA : public Value {
        constexpr HSVA() noexcept = default;

        constexpr explicit HSVA(std::array<float, 4> v) noexcept: Value(v) {
            operator[](0) /= 360.f;
        }

        constexpr HSVA(float h, float s, float v, float a) noexcept: Value() {
            operator[](0) = h / 360.f;
            operator[](1) = s;
            operator[](2) = v;
            operator[](3) = a;
        }

        [[nodiscard]] constexpr HSVA modValue(float dValue) const noexcept {
            HSVA result{*this};
            result[2] += dValue;
            return result;
        }

        [[nodiscard]] constexpr HSVA withHue(uint32_t hue) const {
            return HSVA{{(float) (hue % 360) / 360.f, saturation(), value(), alpha()}};
        }

        [[nodiscard]] constexpr HSVA withSaturation(float sat) const {
            HSVA result{*this};
            result[1] = std::clamp(sat, 0.f, 1.f);
            return result;
        }

        [[nodiscard]] constexpr HSVA withValue(float val) const {
            HSVA result{*this};
            result[2] = std::clamp(val, 0.f, 1.f);
            return result;
        }

        [[nodiscard]] constexpr HSVA withMinSaturation(float sat) const {
            return HSVA{{hue(), std::max(saturation(),sat), value(), alpha()}};
        }

        [[nodiscard]] constexpr HSVA contrasting() const {
            float value = 0;
            if (operator[](2) < 0.5f)
                value = operator[](2) + 0.4f;
            else
                value = operator[](2) - 0.4f;
            return HSVA{{operator[](0), operator[](1), value, operator[](3)}};
        }

        [[nodiscard]] constexpr RGBA toRGBA() const noexcept {
            auto H = mod(operator[](0) * 360.0f, 360.f);
            float S = operator[](1);
            float V = operator[](2);
            float C = S * V;
            float X = C * (1 - abs(mod(H / 60.0f, 2.f) - 1));
            float m = V - C;
            float r = 0.f, g = 0.f, b = 0.f;
            if (H >= 0 && H < 60) {
                r = C, g = X, b = 0;
            } else if (H >= 60 && H < 120) {
                r = X, g = C, b = 0;
            } else if (H >= 120 && H < 180) {
                r = 0, g = C, b = X;
            } else if (H >= 180 && H < 240) {
                r = 0, g = X, b = C;
            } else if (H >= 240 && H < 300) {
                r = X, g = 0, b = C;
            } else {
                r = C, g = 0, b = X;
            }

            return RGBA{std::array<float, 4>{r + m, g + m, b + m, operator[](3)}};
        }

        constexpr float &hue() noexcept { return operator[](0); }

        [[nodiscard]] constexpr float hue() const noexcept { return operator[](0); }

        constexpr float &saturation() noexcept { return operator[](1); }

        [[nodiscard]] constexpr float saturation() const noexcept { return operator[](1); }

        constexpr float &value() noexcept { return operator[](2); }

        [[nodiscard]] constexpr float value() const noexcept { return operator[](2); }

        constexpr float &alpha() noexcept { return operator[](3); }

        [[nodiscard]] constexpr float alpha() const noexcept { return operator[](3); }

        [[nodiscard]] constexpr HSVA interpolate(const HSVA& to, float v) const noexcept {
            auto inter = [](float from, float to, float value) -> float {
                return from + (to - from) * value;
            };

            HSVA result{};
            result[0] = inter(operator[](0), to[0], v);
            result[1] = inter(operator[](1), to[1], v);
            result[2] = inter(operator[](2), to[2], v);
            result[3] = inter(operator[](3), to[3], v);

            return result;
        }
    };

    constexpr RGBA::RGBA(const HSVA &hsva) noexcept : RGBA(hsva.toRGBA()) {
    }

    static constexpr uint32_t set_a_value(uint32_t pixel, uint32_t a) { return (pixel & cmask) | a << ashift; }


    template<class Representation>
    class Interpolator {
    public:
        using color_type = Representation;
        using index_type = ssize_t;

    protected:
        color_type mStart;      
        color_type mFinish;     
        index_type mSteps;      
        Value mIncrement;       

        class Iterator {
        public:
            using iterator_category = std::random_access_iterator_tag;
            using difference_type = index_type;
            using value_type = color_type;
            using pointer = color_type *;
            using reference = color_type &;

        protected:
            const Interpolator<color_type> *mInterpolator{nullptr};    
            color_type mValue{};                                       
            index_type mIndex{0};                                      

        public:
            Iterator() = default;

            explicit Iterator(const Interpolator *interpolator) : mInterpolator(interpolator) {
                mValue = interpolator->mStart;
            }

            Iterator(const Interpolator *interpolator, difference_type index) : Iterator(interpolator) {
                if (index >= 0 && index < interpolator->mSteps)
                    mIndex = index;
                else
                    mIndex = interpolator->mSteps;
                mValue = (*mInterpolator)(mIndex);
            }

            Iterator(const Iterator &iterator) : Iterator(iterator.mInterpolator) {
                mIndex = iterator.mIndex;
                mValue = iterator.mValue;
            }

            Iterator(Iterator &&iterator) noexcept: Iterator(iterator.mInterpolator) {
                mIndex = iterator.mIndex;
                mValue = iterator.mValue;
                iterator.mInterpolator = nullptr;
            }

            Iterator &operator=(const Iterator &iterator) {
                mInterpolator = iterator.mInterpolator;
                mIndex = iterator.mIndex;
                mValue = iterator.mValue;
                return *this;
            }

            Iterator &operator=(Iterator &&iterator) noexcept {
                mInterpolator = iterator.mInterpolator;
                mIndex = iterator.mIndex;
                mValue = iterator.mValue;
                iterator.mInterpolator = nullptr;
                return *this;
            }

            reference operator*() const { return mValue; }

            pointer operator->() const { return &mValue; }

            Iterator &operator++() {
                if (mIndex < mInterpolator->mSteps) {
                    ++mIndex;
                    mValue = (*mInterpolator)(mIndex);
                }
                return *this;
            }

            Iterator operator++(int) {
                Iterator tmp{*this};
                operator++();
                return tmp;
            }

            bool operator==(const Iterator &other) const {
                return mInterpolator == other.mInterpolator && mIndex == other.mIndex;
            }

            bool operator!=(const Iterator &other) const {
                return mInterpolator != other.mInterpolator || mIndex != other.mIndex;
            }
        };

    public:
        Interpolator() = delete;

        Interpolator(Representation start, Representation finish, size_t steps)
                : mStart(start), mFinish(finish), mSteps(steps) {
            auto fSteps = static_cast<float>(mSteps);
            std::transform(mStart.begin(), mStart.end(), mFinish.begin(), mIncrement.begin(),
                           [=](float start, float finish) {
                               return (finish - start) / fSteps;
                           });
        }

        color_type operator()(index_type index) {
            color_type result{};
            auto fIndex = static_cast<float>(index);
            std::transform(mStart.begin(), mIncrement.begin(), result.begin(),
                           [=](float start, float increment) {
                               return start + increment * fIndex;
                           });
            return result;
        }

        Iterator begin() {
            return Iterator{*this};
        }

        Iterator end() {
            Iterator iterator{*this};
            iterator.mIndex = mSteps;
            return iterator;
        }
    };

    static constexpr color::HSVA DarkBaseColorHSVA{{200.f, .00, .25, 1.0}};
    static constexpr color::RGBA DarkBaseColor{DarkBaseColorHSVA};
    static constexpr color::RGBA DarkTopColor{DarkBaseColorHSVA.modValue(0.2)};
    static constexpr color::RGBA DarkBotColor{DarkBaseColorHSVA.modValue(-0.15)};
    static constexpr color::RGBA DarkLeftColor{DarkBaseColorHSVA.modValue(0.1)};
    static constexpr color::RGBA DarkRightColor{DarkBaseColorHSVA.modValue(-0.15)};
    static constexpr color::RGBA DarkInvertColor{DarkBaseColorHSVA.modValue(-0.075)};
    static constexpr color::RGBA DarkTextColour{DarkBaseColorHSVA.contrasting()};
    static constexpr color::HSVA DarkRedHSVA{ 0.f, 1.f, 0.55f, 1.f};
//  (67,139,40) https://www.color-hex.com/color-palette/105943
    static constexpr color::HSVA DarkGreenHSVA{79.f,1.f,.4f,1.f};
    static constexpr color::HSVA DarkYellowHSVA{ 50.f, 1.f, 0.55f, 1.f};
}

inline std::ostream& operator<<(std::ostream& strm, const rose::color::RGBA& rgba) {
    strm << "[RGBA " << rgba.r() << ',' << rgba.g() << ',' << rgba.b() << ',' << rgba.a() << "] ";
    return strm;
}

inline std::ostream& operator<<(std::ostream& strm, const rose::color::HSVA& hsva) {
    strm << "[HSVA " << hsva.hue() << ',' << hsva.saturation() << ',' << hsva.value() << ',' << hsva.alpha() << "] ";
    return strm;
}