// Copyright (C) 2022  Davis E. King (davis@dlib.net), Martin Sandsmark, Adrià Arrufat
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_WEBP_IMPORT
#define DLIB_WEBP_IMPORT

#include <vector>

#include "webp_loader_abstract.h"
#include "image_loader.h"
#include "../pixel.h"
#include "../dir_nav.h"
#include "../test_for_odr_violations.h"

namespace dlib
{

    class webp_loader : noncopyable
    {
    public:

        webp_loader(const char* filename);
        webp_loader(const std::string& filename);
        webp_loader(const dlib::file& f);
        webp_loader(const unsigned char* imgbuffer, size_t buffersize);

        long nr() const;
        long nc() const;

        template<typename image_type>
        void get_image(image_type& image) const
        {
#ifndef DLIB_WEBP_SUPPORT
            /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                You are getting this error because you are trying to use the webp_loader
                object but you haven't defined DLIB_WEBP_SUPPORT.  You must do so to use
                this object.   You must also make sure you set your build environment
                to link against the libwebp library.
            !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
            static_assert(sizeof(image_type) == 0, "webp support not enabled.");
#endif
            image_view<image_type> vimg(image);
            vimg.set_size(height_, width_);
            typedef typename image_traits<image_type>::pixel_type pixel_type;

            unsigned char* output = reinterpret_cast<unsigned char*>(image_data(vimg));
            const int stride = width_step(vimg);
            const size_t output_size = stride * height_;

            if (pixel_traits<pixel_type>::rgb_alpha)
            {
                if (pixel_traits<pixel_type>::bgr_layout)
                    read_bgra(output, output_size, stride);
                else
                    read_rgba(output, output_size, stride);
                return;
            }
            if (pixel_traits<pixel_type>::rgb)
            {
                if (pixel_traits<pixel_type>::bgr_layout)
                    read_bgr(output, output_size, stride);
                else
                    read_rgb(output, output_size, stride);
                return;
            }
            // If we end up here, we are out of our fast path, and have to do it manually

            array2d<rgb_alpha_pixel> decoded;
            decoded.set_size(height_, width_);
            unsigned char* output_dec = reinterpret_cast<unsigned char*>(image_data(decoded));
            const int stride_dec = width_step(decoded);
            const size_t output_dec_size = stride_dec * height_;

            read_rgba(output_dec, output_dec_size, stride_dec);

            for (int r = 0; r < height_; r++)
            {
                for (int c = 0; c < width_; c++)
                {
                    assign_pixel(vimg[r][c], decoded[r][c]);
                }
            }
        }

    private:
        void get_info();
        void read_bgra(unsigned char *out, const size_t out_size, const int out_stride) const;
        void read_bgr(unsigned char *out, const size_t out_size, const int out_stride) const;
        void read_rgba(unsigned char *out, const size_t out_size, const int out_stride) const;
        void read_rgb(unsigned char *out, const size_t out_size, const int out_stride) const;
        void read_argb(unsigned char *out, const size_t out_size, const int out_stride) const;

        int height_;
        int width_;
        std::vector<unsigned char> data_;
    };

// ----------------------------------------------------------------------------------------

    template <
        typename image_type
        >
    void load_webp (
        image_type& image,
        const std::string& file_name
   )
    {
        webp_loader(file_name).get_image(image);
    }

    template <
        typename image_type
        >
    void load_webp (
        image_type& image,
        const unsigned char* imgbuff,
        size_t imgbuffsize
   )
    {
        webp_loader(imgbuff, imgbuffsize).get_image(image);
    }

    template <
        typename image_type
        >
    void load_webp (
        image_type& image,
        const char* imgbuff,
        size_t imgbuffsize
   )
    {
        webp_loader(reinterpret_cast<const unsigned char*>(imgbuff), imgbuffsize).get_image(image);
    }

// ----------------------------------------------------------------------------------------

}

#ifdef NO_MAKEFILE
#include "webp_loader.cpp"
#endif

#endif // DLIB_WEBP_IMPORT