include/fsdk/Types/Image.h

#pragma once

#include <fsdk/Def.h>
#include <fsdk/Types/Format.h>
#include <fsdk/Types/Rect.h>
#include <fsdk/Types/Result.h>
#include <fsdk/Types/RotationType.h>
#include <fsdk/Types/Sizer.h>
#include <fsdk/Types/SubImage.h>

namespace fsdk {

    struct IArchive;

    struct Image {

        enum class Type : uint8_t {
            BMP,
            JPG,
            PNG,
            PPM,
            TIFF,
            Unknown
        };

        enum class TargetDevice {
            CPU,
            GPU,
            NPU,
        };

        enum class ImageCompression {
            IC_NO_COMPRESSION,     
            IC_SMALL_COMPRESSION,  

            IC_MEDIUM_COMPRESSION, 
            IC_HARD_COMPRESSION,   
            IC_BEST_COMPRESSION,   
        };
        enum class Error : uint32_t {
            Ok,                   
            InvalidWidth,         
            InvalidHeight,        
            InvalidDataPtr,       
            InvalidDataSize,      
            InvalidImage,         
            InvalidArchive,       
            InvalidPath,          
            InvalidType,          
            InvalidFormat,        
            InvalidBitmap,        
            InvalidMemory,        
            InvalidConversion,    
            InvalidResidence,     
            InvalidDevice,        
            InvalidCudaKernel,    
            FailedToSave,         
            FailedToLoad,         
            FailedToInitialize,   
            InvalidInput,         
            ReleasedInOtherThread 
        };

        enum class MemoryResidence : uint32_t {
            MemoryCPU,     
            MemoryGPU,     
            MemoryNPU,     
            MemoryNPU_DPP, 
        };

        FSDK_API Image() noexcept;

        FSDK_API Image(
            int width,
            int height,
            Format format,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Image(
            int width,
            int height,
            Format format,
            const void* data,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Image(
            int width,
            int height,
            Format format,
            void* data,
            bool copy,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Image(const Image& other) noexcept;

        FSDK_API Image(Image&& other) noexcept;

        FSDK_API explicit Image(const SubImage& subImage) noexcept;

        FSDK_API ~Image();

        FSDK_API Result<Error> create(
            int width,
            int height,
            Format format,
            bool cleanup = true,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Result<Error> create(
            int width,
            int height,
            Format format,
            const void* data,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Result<Error> create(
            int width,
            int height,
            Format format,
            void* data,
            bool copy,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Result<Error>
        create(const fsdk::Image& source, MemoryResidence residence, int deviceId = 0) noexcept;

        FSDK_API Result<Error> set(
            int width,
            int height,
            Format format,
            const void* data,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Result<Error> set(
            int width,
            int height,
            Format format,
            void* data,
            bool copy,
            MemoryResidence residence = MemoryResidence::MemoryCPU,
            int deviceId = 0) noexcept;

        FSDK_API Result<Error> set(const Image& other) noexcept;

        FSDK_API Result<Error> set(const SubImage& subImage) noexcept;

        FSDK_API SubImage map(int x, int y, int width, int height) const noexcept;

        SubImage map(const Rect& rect) const noexcept {
            return map(rect.x, rect.y, rect.width, rect.height);
        }

        SubImage map(const Size& size) const noexcept {
            return map(Point2i(0, 0), size);
        }

        SubImage map(const Point2i& origin, const Size& size) const noexcept {
            return map(origin.x, origin.y, size.x, size.y);
        }

        FSDK_API Image extract(int x, int y, int width, int height) const noexcept;

        FSDK_API Result<Image::Error> extract(Image& dest, int x, int y, int width, int height) const noexcept;

        FSDK_API Result<Image::Error> extract(Image& dest, const Rect& rect) const noexcept;

        FSDK_API Result<Error> rescale(Image& dest, float scale) const noexcept;

        Image extract(const Rect& rect) const noexcept {
            return extract(rect.x, rect.y, rect.width, rect.height);
        }

        Image extract(const Size& size) const noexcept {
            return extract(Point2i(0, 0), size);
        }

        Image extract(const Point2i& origin, const Size& size) const noexcept {
            return extract(origin.x, origin.y, size.x, size.y);
        }

        FSDK_API static Result<Error>
        guessTypeFromMemory(const void* data, const uint32_t sizeInBytes, Type& type) noexcept;

        Image clone() const noexcept {
            return {getWidth(), getHeight(), getFormat(), getData(), getMemoryResidence(), getDeviceId()};
        }

        FSDK_API Result<Image::Error> convert(
            Image& dest,
            int x,
            int y,
            int width,
            int height,
            Format format,
            TargetDevice device = TargetDevice::CPU) const noexcept;

        Result<Image::Error> convert(
            Image& dest,
            const Point2i& origin,
            const Size& size,
            Format format,
            TargetDevice device = TargetDevice::CPU) const noexcept {
            return convert(dest, origin.x, origin.y, size.x, size.y, format, device);
        }

        Result<Image::Error>
        convert(Image& dest, const Size& size, Format format, TargetDevice device = TargetDevice::CPU)
            const noexcept {
            return convert(dest, Point2i(0, 0), size, format, device);
        }

        Result<Image::Error>
        convert(Image& dest, const Rect& rect, Format format, TargetDevice device = TargetDevice::CPU)
            const noexcept {
            return convert(dest, rect.x, rect.y, rect.width, rect.height, format, device);
        }

        Result<Image::Error>
        convert(Image& dest, Format format, TargetDevice device = TargetDevice::CPU) const noexcept {
            return convert(dest, getRect(), format, device);
        }

        FSDK_API Image rescale(float scale) const noexcept;

        FSDK_API Result<Image::Error> save(
            const char* path,
            fsdk::Image::ImageCompression additionalFlag =
                fsdk::Image::ImageCompression::IC_NO_COMPRESSION) const noexcept;

        FSDK_API Result<Error> save(const char* path, const Format format) const noexcept;

        FSDK_API Result<Image::Error> saveToMemory(
            Image::Type type,
            IArchive* archive,
            fsdk::Image::ImageCompression additionalFlag =
                fsdk::Image::ImageCompression::IC_NO_COMPRESSION) const noexcept;

        FSDK_API Result<Image::Error>
        saveToMemory(Image::Type type, IArchive* archive, const Format format) const noexcept;

        FSDK_API Result<Error> load(const char* path) noexcept;

        FSDK_API Result<Error> load(const char* path, const Format format) noexcept;

        FSDK_API Result<Error> loadFromMemory(const void* data, const uint32_t sizeInBytes) noexcept;

        FSDK_API Result<Error> rotate(Image& dest, RotationType rotationType) const noexcept;

        FSDK_API Result<Error>
        loadFromMemory(const void* data, const uint32_t sizeInBytes, const Format format) noexcept;

        FSDK_API Result<Error>
        loadFromMemoryOfType(const void* data, const uint32_t sizeInBytes, const Type type) noexcept;

        FSDK_API Result<Error> loadFromMemoryOfType(
            const void* data,
            const uint32_t sizeInBytes,
            const Type type,
            const Format format) noexcept;

        Image& operator=(const Image& other) noexcept {
            set(other);

            return *this;
        }

        Image& operator=(Image&& other) noexcept {
            if(this != &other) {
                release();
                swap(other);
            }

            return *this;
        }

        bool isNull() const noexcept {
            return getData() == nullptr;
        }

        bool isValid() const noexcept {
            return !isNull() && getHeight() > 0 && getWidth() > 0 && getFormat().isValid();
        }

        operator bool() const noexcept {
            return isValid();
        }

        FSDK_API void* getScanLine(int y) noexcept;

        FSDK_API const void* getScanLine(int y) const noexcept;

        FSDK_API int getDataSize() const noexcept;

        FSDK_API void getDataSize(Sizer& sizer) const noexcept;

        template <typename T>
        T* getScanLineAs(int y) noexcept {
            return reinterpret_cast<T*>(getScanLine(y));
        }

        template <typename T>
        const T* getScanLineAs(int y) const noexcept {
            return reinterpret_cast<const T*>(getScanLine(y));
        }

        void* getData() noexcept {
            return m_data;
        }

        const void* getData() const noexcept {
            return m_data;
        }

        template <typename T>
        T* getDataAs() noexcept {
            return reinterpret_cast<T*>(getData());
        }

        template <typename T>
        const T* getDataAs() const noexcept {
            return reinterpret_cast<const T*>(getData());
        }

        int getRowSize() const noexcept {
            return getFormat().computePitch(getWidth());
        }

        int getWidth() const noexcept {
            return m_width;
        }

        int getHeight() const noexcept {
            return m_height;
        }

        float getAspectRatio() const noexcept {
            return static_cast<float>(getWidth()) / static_cast<float>(getHeight());
        }

        Format getFormat() const noexcept {
            return m_format;
        }

        MemoryResidence getMemoryResidence() const noexcept {
            return m_residence;
        }

        int getDeviceId() const noexcept {
            return m_deviceId;
        }

        Size getSize() const noexcept {
            return Size(getWidth(), getHeight());
        }

        Rect getRect() const noexcept {
            return Rect(0, 0, getWidth(), getHeight());
        }

        bool ownsData() const noexcept {
            return !!m_ref;
        }

        bool isSharedWith(const Image& other) const noexcept {
            return getData() == other.getData();
        }

        void swap(Image& other) noexcept {
            std::swap(m_data, other.m_data);
            std::swap(m_ref, other.m_ref);
            std::swap(m_height, other.m_height);
            std::swap(m_width, other.m_width);
            std::swap(m_format, other.m_format);
            std::swap(m_residence, other.m_residence);
        }

        void reset() noexcept {
            Image().swap(*this);
        }

        bool equalWeak(const fsdk::Image& other) const noexcept {
            return m_width == other.getWidth() && m_height == other.getHeight() && m_format == other.getFormat() &&
                         m_residence == other.getMemoryResidence();
        }

        bool equalStrong(const fsdk::Image& other) const noexcept {
            return equalWeak(other) && m_data == other.getData();
        }

        FSDK_API void putPixel(uint32_t x, uint32_t y) noexcept;

    protected:
        void* m_data;    
        int* m_ref;      
        int m_height;    
        int m_width;     
        int m_deviceId;  
        Format m_format; 
        MemoryResidence m_residence;

        FSDK_API static void* allocate(int size) noexcept;

        FSDK_API static void deallocate(void* memory) noexcept;

        FSDK_API int retain() noexcept;

        FSDK_API int release() noexcept;

        FSDK_API int getRefCount() const noexcept;
    };

    const char* toString(Image::MemoryResidence residence);

    template <>
    struct ErrorTraits<Image::Error> {

        static bool isOk(Image::Error error) noexcept {
            return error == Image::Error::Ok;
        }

        static const char* toString(Image::Error error) noexcept {
            switch(error) {
            case Image::Error::Ok:
                return "Ok";
            case Image::Error::InvalidType:
                return "Unsupported type";
            case Image::Error::InvalidPath:
                return "Invalid path";
            case Image::Error::FailedToSave:
                return "Error during image saving";
            case Image::Error::FailedToLoad:
                return "Error during image loading";
            case Image::Error::InvalidImage:
                return "Invalid image";
            case Image::Error::InvalidWidth:
                return "Invalid image width";
            case Image::Error::InvalidHeight:
                return "Invalid image height";
            case Image::Error::InvalidFormat:
                return "Unsupported format";
            case Image::Error::InvalidMemory:
                return "Memory error";
            case Image::Error::InvalidBitmap:
                return "Bitmap error";
            case Image::Error::InvalidArchive:
                return "Archive error";
            case Image::Error::InvalidDataPtr:
                return "Bad input data pointer";
            case Image::Error::InvalidDataSize:
                return "Bad input data size";
            case Image::Error::InvalidConversion:
                return "Required conversion not implemented";
            case Image::Error::InvalidDevice:
                return "Selected Target Device is not supported for this system";
            case Image::Error::FailedToInitialize:
                return "Error during initialization";
            case Image::Error::ReleasedInOtherThread:
                return "Failed to retain image: it was released in another thread.";
            case Image::Error::InvalidInput:
                return "InvalidInput";
            default:
                return "Unknown error";
            }
        }
    };

    using ImageType = Image::Type;
    using ImageError = Image::Error;
    using TargetDevice = Image::TargetDevice;
    using ImageCompression = Image::ImageCompression;

} // namespace fsdk