rgb.h

#pragma once
#include "util/const_functions.h"
#include "util/fixedpoint.h"
#include <algorithm>
#include <cstdint>
#include <functional>
#include <limits>
#include <type_traits>

class RGB {
public:
    using channel_type = uint8_t;

    static constexpr auto channel_min = std::numeric_limits<channel_type>::min();

    static constexpr auto channel_max = std::numeric_limits<channel_type>::max();

    channel_type r = 0;

    channel_type g = 0;

    channel_type b = 0;

    constexpr RGB& operator=(const RGB& other) = default;

    static constexpr RGB monochrome(uint8_t brightness) {
        return RGB{.r = brightness, .g = brightness, .b = brightness};
    }

    static RGB fromHue(int32_t hue);

    static RGB fromHuePastel(int32_t hue);

    template <typename UnaryOp> // std::function<channel_type(channel_type)>
    requires std::convertible_to<UnaryOp, std::function<channel_type(channel_type)>>
    [[nodiscard]] constexpr RGB transform(UnaryOp transformFn) const {
        return RGB(transformFn(r), transformFn(g), transformFn(b));
    }

    [[nodiscard]] constexpr RGB forTail() const {
        uint32_t averageBrightness = ((uint32_t)r + g + b);
        return transform([averageBrightness](channel_type channel) { //<
            return (((int32_t)channel * 21 + averageBrightness) * 120) >> 14;
        });
    }

    [[nodiscard]] constexpr RGB forBlur() const {
        uint32_t averageBrightness = (uint32_t)r * 5 + g * 9 + b * 9;
        return transform([averageBrightness](channel_type channel) { //<
            return ((uint32_t)channel * 5 + averageBrightness) >> 5;
        });
    }

    static constexpr RGB average(RGB colourA, RGB colourB) {
        return RGB::transform2(colourA, colourB, [](channel_type channelA, channel_type channelB) {
            auto average = (static_cast<uint32_t>(channelA) + static_cast<uint32_t>(channelB)) / 2;
            return std::clamp<uint32_t>(average, 0, channel_max);
        });
    }

    [[nodiscard]] constexpr RGB dim(uint8_t level = 1) const {
        return transform([level](channel_type channel) { return channel >> level; });
    }

    [[nodiscard]] constexpr RGB dull() const {
        return transform([](channel_type channel) { //<
            return std::clamp<channel_type>(channel, 5, 50);
        });
    }

    [[nodiscard]] constexpr RGB greyOut(int32_t proportion) {
        uint32_t totalRGB = (uint32_t)r + g + b; // max 765
 
        return transform([proportion, totalRGB](channel_type channel) {
            auto val = rshift_round(
                (uint32_t)channel * (uint32_t)(0x808080 - proportion) + ((int32_t)totalRGB * (proportion >> 5)), 23);
            return std::clamp<uint32_t>(val, 0, channel_max);
        });
    }

    [[nodiscard]] static constexpr RGB blend(RGB sourceA, RGB sourceB, uint16_t index) {
        return transform2(sourceA, sourceB, [index](channel_type channelA, channel_type channelB) { //<
            return blendChannel(channelA, channelB, index);
        });
    }

    [[nodiscard]] static constexpr RGB blend2(RGB sourceA, RGB sourceB, uint16_t indexA, uint16_t indexB) {
        return transform2(sourceA, sourceB, [indexA, indexB](channel_type channelA, channel_type channelB) {
            return blendChannel2(channelA, channelB, indexA, indexB);
        });
    }

    bool operator==(RGB const&) const = default;

    constexpr channel_type& operator[](size_t idx) {
        switch (idx) {
        case 0:
            return r;
        case 1:
            return g;
        case 2:
            return b;
        default:
            __builtin_unreachable(); // TODO: should be std::unreachable() with C++23
        }
    }

    static constexpr size_t size() { return 3; }

    constexpr channel_type* begin() { return &this->r; }

    constexpr channel_type* end() { return (&this->b + 1); }

    template <typename BinaryOp>
    requires std::convertible_to<BinaryOp, std::function<channel_type(channel_type, channel_type)>>
    static constexpr RGB transform2(RGB colourA, RGB colourB, BinaryOp transformFn) {
        return RGB(transformFn(colourA.r, colourB.r), transformFn(colourA.g, colourB.g),
                   transformFn(colourA.b, colourB.b));
    }

    [[nodiscard]] constexpr RGB adjust(uint8_t intensity, uint8_t brightnessDivider) const {
        return transform([intensity, brightnessDivider](channel_type channel) { //<
            return ((channel * intensity / 255) / brightnessDivider);
        });
    }

    [[nodiscard]] constexpr RGB adjustFractional(uint16_t numerator, uint16_t divisor) const {
        return transform([numerator, divisor](channel_type channel) { //<
            return ((channel * numerator) / divisor);
        });
    }

    constexpr RGB rotate() { return xform(RMat); }
 
private:
    static constexpr uint32_t IMat[4][4] = {
        {ONE_Q16, 0, 0, 0},
        {0, ONE_Q16, 0, 0},
        {0, 0, ONE_Q16, 0},
        {0, 0, 0, ONE_Q16},
    };
    static constexpr float c = 0.5403f;
    static constexpr float s = 0.8414f;
    static constexpr uint32_t RMat[4][4] = {
        {(uint32_t)(c * ONE_Q16), 0, (uint32_t)(s* ONE_Q16), 0},
        {(uint32_t)(s * ONE_Q16), (uint32_t)(c* ONE_Q16), 0, 0},
        {0, (uint32_t)(s* ONE_Q16), (uint32_t)(c* ONE_Q16), 0},
        {0, 0, 0, ONE_Q16},
    };
 
    constexpr RGB xform(const uint32_t mat[4][4]) {
        return {
            .r = static_cast<channel_type>((r * mat[0][0] + g * mat[1][0] + b * mat[2][0] + mat[3][0]) >> 16),
            .g = static_cast<channel_type>((r * mat[0][1] + g * mat[1][1] + b * mat[2][1] + mat[3][1]) >> 16),
            .b = static_cast<channel_type>((r * mat[0][2] + g * mat[1][2] + b * mat[2][2] + mat[3][2]) >> 16),
        };
    }

    static constexpr channel_type blendChannel(uint32_t channelA, uint32_t channelB, uint16_t index) {
        return blendChannel2(channelA, channelB, index, (std::numeric_limits<uint16_t>::max() - index + 1));
    }

    static constexpr channel_type blendChannel2(uint32_t channelA, uint32_t channelB, uint16_t indexA,
                                                uint16_t indexB) {
        uint32_t newRGB = rshift_round(channelA * indexA, 16) + rshift_round(channelB * indexB, 16);
        return std::clamp<uint32_t>(newRGB, 0, channel_max);
    }
};
static_assert(std::is_trivially_copyable_v<RGB>, "RGB must be trivially copyable");