Texture.h

#pragma once

#include <filesystem>
#include <memory>
#include <SDL.h>
#include "Font.h"
#include "ScreenMetrics.h"
#include "Surface.h"


namespace rose::sdl {

    class Renderer;

    class TextureDestroy {
    public:
        void operator()(SDL_Texture *sdlTexture) {
            SDL_DestroyTexture(sdlTexture);
        }
    };

    class Texture : public std::unique_ptr<SDL_Texture, TextureDestroy> {
    public:
        Texture() = default;

        ~Texture() = default;

        Texture(const Texture &) = delete;

        Texture(Texture &&) = default;

        Texture &operator=(const Texture &) = delete;

        Texture &operator=(Texture &&texture) = default;

        explicit Texture(SDL_Texture *texture) : Texture() { reset(texture); }

        Texture(Renderer &renderer, SDL_PixelFormatEnum format, SDL_TextureAccess access, int width, int height);

        Texture(Renderer &renderer, Size size);

        int setBlendMOde(SDL_BlendMode blendMode) {
            return SDL_SetTextureBlendMode(get(), blendMode);
        }

        [[nodiscard]] std::tuple<int, int> getSize() const noexcept {
            int w, h;
            SDL_QueryTexture(get(), nullptr, nullptr, &w, &h);
            return std::make_tuple(w, h);
        }
    };

    class TextureData : public Texture {
    public:
        TextureData() = default;

        TextureData(const TextureData &) = delete; 
        TextureData &operator=(const TextureData &) = delete; 

        TextureData(Renderer &renderer, SDL_PixelFormatEnum format, SDL_TextureAccess access, int width, int height)
                : Texture(renderer, format, access, width, height) {
            setMetaData();
        }

        TextureData(Renderer &renderer, Size size) : Texture(renderer, size) {
            setMetaData();
        }

        explicit TextureData(Texture &&texture) noexcept: TextureData() {
            (*this) = texture.release();
            setMetaData();
        }

        explicit TextureData(SDL_Texture *texture) noexcept: Texture(texture) {
            setMetaData();
        }

        TextureData(TextureData &&other) noexcept = default;

        TextureData &operator=(TextureData &&other) noexcept = default;

        TextureData &operator=(SDL_Texture *texture) {
            reset(texture);
            setMetaData();
            return *this;
        }

        [[nodiscard]] bool expired() const noexcept {
            return operator bool() && mLife < std::chrono::system_clock::now();
        }

        [[nodiscard]] bool dirty() const noexcept { return mDirty; }

        void setDirty(bool dirty) { mDirty = dirty; }

        std::string_view getPath() { return mPath; }

        [[nodiscard]] std::string_view getPath() const { return mPath; }

        template<typename StringType>
        void setPath(const StringType path) { mPath = path; }

        std::string_view getURI() { return mURI; }

        [[nodiscard]] std::string_view getURI() const { return mURI; }

        template<typename StringType>
        void setURI(const StringType URI) { mURI = URI; }

        std::string_view getName() { return mName; }

        [[nodiscard]] std::string_view getName() const { return mName; }

        template<typename StringType>
        void setName(const StringType Name) { mName = Name; }

        void setLoadedTime(const std::chrono::time_point<std::chrono::system_clock> loaded) { mLoaded = loaded; }

        void setScale(int scale) { mScale = scale; }

        [[nodiscard]] int getScale() const { return mScale; }

        [[nodiscard]] Size getSize() const { return mSize; }

        void getRectangle(SDL_Rect &rect) const {
            rect.x = rect.y = 0;
            rect.w = mSize.width();
            rect.h = mSize.height();
        }

        [[nodiscard]] Rectangle getRectangle() const {
            return Rectangle{0, 0, mSize.width(), mSize.height()};
        }

        void setSize(Size size) { mSize = size; }

    protected:
        void setMetaData() {
            int w, h;
            SDL_QueryTexture(get(), &mFormat, &mAccess, &w, &h);
            mSize = Size{w, h};
            mDirty = false;
        }

        Size mSize;      
        int mScale{
                1};      
        uint32_t mFormat{}; 
        int mAccess{};      
        std::string mPath;  
        std::string mURI;   

        std::string mName;
        bool mDirty{true};  

        std::chrono::time_point<std::chrono::system_clock> mLoaded{}, 
        mLife{}; 
    };

    TextureData CreateTextureFromFile(Renderer &renderer, std::filesystem::path &filePath);

    template<typename String>
    TextureData CreateTextureFromFile(Renderer &renderer, std::filesystem::path &dirPath, String fileName) {
        auto filePath = dirPath;
        filePath.append(fileName);
        return CreateTextureFromFile(renderer, filePath);
    }

    class GradientTexture;

    class GradientTexture : public Texture {
    public:
        GradientTexture() = default;

        ~GradientTexture() = default;

        GradientTexture(const GradientTexture &) = delete;

        GradientTexture(GradientTexture &&) = default;

        GradientTexture &operator=(const GradientTexture &) = delete;

        GradientTexture &operator=(GradientTexture &&) = delete;

        GradientTexture(Renderer &renderer, const color::RGBA &topLeft, const color::RGBA &topRight,
                        const color::RGBA &bottomLeft, const color::RGBA &bottomRight);

        GradientTexture(Renderer &renderer, const color::RGBA &start, const color::RGBA &end,
                        Orientation orientation = Orientation::Horizontal);

        void setColors(const color::RGBA &topLeft, const color::RGBA &topRight, const color::RGBA &bottomLeft,
                       const color::RGBA &bottomRight);

        void setColors(const color::RGBA &start, const color::RGBA &end,
                       Orientation orientation = Orientation::Horizontal);
    };

    class GradientScale : public Texture {
    protected:

    public:
        GradientScale() = default;

        ~GradientScale() = default;

        GradientScale(const GradientScale &) = delete;

        GradientScale(GradientScale &&) = default;

        GradientScale &operator=(const GradientScale &) = delete;

        GradientScale &operator=(GradientScale &&) = delete;
    };

    class PixelFormatDestroy {
    public:
        void operator()(SDL_PixelFormat *sdlPixelFormat) {
            SDL_FreeFormat(sdlPixelFormat);
        }
    };

    class PixelFormat : public std::unique_ptr<SDL_PixelFormat, PixelFormatDestroy> {
    public:
        PixelFormat() = default;

        explicit PixelFormat(SDL_PixelFormat *sdlPixelFormat)
                : std::unique_ptr<SDL_PixelFormat, PixelFormatDestroy>(sdlPixelFormat) {}

        explicit PixelFormat(SDL_PixelFormatEnum format) : PixelFormat(SDL_AllocFormat(format)) {}
    };

    uint32_t mapRGBA(SDL_PixelFormatEnum pixelFormat, const color::RGBA &color);

    uint32_t mapRGBA(PixelFormat &pixelFormat, const color::RGBA &color);

    uint32_t mapRGBA(SDL_PixelFormat *format, const color::RGBA &color);

    color::RGBA getRGBA(PixelFormat &pixelFormat, uint32_t pixel);

    color::RGBA getRGBA(SDL_PixelFormat *format, uint32_t pixel);

    template<typename Color>
    inline sdl::Texture
    renderTextureBlended(sdl::Renderer &renderer, FontPointer &font, const std::string &text, const Color &color) {
        static_assert(std::is_same_v<Color, ::rose::color::RGBA> ||
                      std::is_same_v<Color, ::rose::color::HSVA> ||
                      std::is_same_v<Color, SDL_Color>,
                      "Color type is not supported.");
        if constexpr (std::is_same_v<Color, ::rose::color::RGBA>) {
            auto fg = color.toSdlColor();
            return renderTextureBlended(renderer, font, text, fg);
        } else if constexpr (std::is_same_v<Color, ::rose::color::HSVA>) {
            auto fg = color::RGBA{color}.toSdlColor();
            return renderTextureBlended(renderer, font, text, fg);
        } else if constexpr (std::is_same_v<Color, SDL_Color>) {
            sdl::Surface surface{TTF_RenderText_Blended(font.get(), text.c_str(), color)};
            return sdl::Texture{SDL_CreateTextureFromSurface(renderer.get(), surface.get())};
        }
    }

    template<typename Color>
    sdl::Texture
    inline renderTextureBlendedUTF8(sdl::Renderer &renderer, FontPointer &font, const std::string &text,
                                    const Color &color) {
        static_assert(std::is_same_v<Color, ::rose::color::RGBA> ||
                      std::is_same_v<Color, ::rose::color::HSVA> ||
                      std::is_same_v<Color, SDL_Color>,
                      "Color type is not supported.");
        if constexpr (std::is_same_v<Color, ::rose::color::RGBA>) {
            auto fg = color.toSdlColor();
            return renderTextureBlendedUTF8(renderer, font, text, fg);
        } else if constexpr (std::is_same_v<Color, ::rose::color::HSVA>) {
            auto fg = color::RGBA{color}.toSdlColor();
            return renderTextureBlendedUTF8(renderer, font, text, fg);
        } else if constexpr (std::is_same_v<Color, SDL_Color>) {
            sdl::Surface surface{TTF_RenderUTF8_Blended(font.get(), text.c_str(), color)};
            return sdl::Texture{SDL_CreateTextureFromSurface(renderer.get(), surface.get())};
        }
    }

}