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/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,      
            FailedToSave,       
            FailedToLoad,       
            FailedToInitialize, 
            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) noexcept;

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

        FSDK_API Image(
            int width,
            int height,
            Format format,
            void* data,
            bool copy,
            MemoryResidence residence = MemoryResidence::MemoryCPU) 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) noexcept;

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

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

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

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

        FSDK_API Result<Error> set(
            int width,
            int height,
            Format format,
            void* data,
            bool copy,
            MemoryResidence residence = MemoryResidence::MemoryCPU) 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;

        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 Image(
                getWidth(),
                getHeight(),
                getFormat(),
                getData());
        }

        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> 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;
        }

        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) noexcept {
            return
                m_width == other.getWidth() &&
                m_height == other.getHeight() &&
                m_format == other.getFormat() &&
                m_residence == other.getMemoryResidence();
        }

        bool equalStrong(const fsdk::Image& other) 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;            

        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;
    };

    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.";
                default: return "Unknown error";
            }
        }
    };

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

}