/*
 * DSFML - The Simple and Fast Multimedia Library for D
 *
 * Copyright (c) 2013 - 2018 Jeremy DeHaan (dehaan.jeremiah@gmail.com)
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from the
 * use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not claim
 * that you wrote the original software. If you use this software in a product,
 * an acknowledgment in the product documentation would be appreciated but is
 * not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution
 *
 *
 * DSFML is based on SFML (Copyright Laurent Gomila)
 */

/**
 * $(U Image) is an abstraction to manipulate images as bidimensional arrays of
 * pixels. The class provides functions to load, read, write and save pixels, as
 * well as many other useful functions.
 *
 * $(U Image) can handle a unique internal representation of pixels, which is
 * RGBA 32 bits. This means that a pixel must be composed of 8 bits red, green,
 * blue and alpha channels – just like a $(COLOR_LINK). All the functions that
 * return an array of pixels follow this rule, and all parameters that you pass
 * to $(U Image) functions (such as `loadFromPixels`) must use this
 * representation as well.
 *
 * An $(U Image) can be copied, but it is a heavy resource and if possible you
 * should always use `const` references to pass or return them to avoid useless
 * copies.
 *
 * Example:
 * ---
 * // Load an image file from a file
 * auto background = new Image();
 * if (!background.loadFromFile("background.jpg"))
 *     return -1;
 *
 * // Create a 20x20 image filled with black color
 * auto image = new Image();
 * image.create(20, 20, Color.Black);
 *
 * // Copy image1 on image2 at position (10, 10)
 * image.copy(background, 10, 10);
 *
 * // Make the top-left pixel transparent
 * auto color = image.getPixel(0, 0);
 * color.a = 0;
 * image.setPixel(0, 0, color);
 *
 * // Save the image to a file
 * if (!image.saveToFile("result.png"))
 *     return -1;
 * ---
 *
 * See_Also:
 * $(TEXTURE_LINK)
 */
module dsfml.graphics.image;

import dsfml.graphics.color;
import dsfml.graphics.rect;

import dsfml.system.err;
import dsfml.system.inputstream;
import dsfml.system.vector2;

/**
 * Class for loading, manipulating and saving images.
 */
class Image
{
    package sfImage* sfPtr;

    /// Default constructor.
    this()
    {
        sfPtr = sfImage_construct();
    }

    package this(sfImage* image)
    {
        sfPtr = image;
    }

    /// Destructor.
    ~this()
    {
        import dsfml.system.config;
        mixin(destructorOutput);
        sfImage_destroy(sfPtr);
    }

    /**
     * Create the image and fill it with a unique color.
     *
     * Params:
     * 		width	= Width of the image
     * 		height	= Height of the image
     * 		color	= Fill color
     *
     */
    void create(uint width, uint height, Color color)
    {

        sfImage_createFromColor(sfPtr, width, height,color.r, color.b, color.g, color.a);
    }

    /**
     * Create the image from an array of pixels.
     *
     * The pixel array is assumed to contain 32-bits RGBA pixels, and have the
     * given width and height. If not, this is an undefined behaviour. If pixels
     * is null, an empty image is created.
     *
     * Params:
     * 		width	= Width of the image
     * 		height	= Height of the image
     * 		pixels	= Array of pixels to copy to the image
     *
     */
    void create(uint width, uint height, const(ubyte)[] pixels)
    {
        sfImage_createFromPixels(sfPtr, width, height,pixels.ptr);
    }

    /**
     * Load the image from a file on disk.
     *
     * The supported image formats are bmp, png, tga, jpg, gif, psd, hdr and
     * pic. Some format options are not supported, like progressive jpeg. If
     * this function fails, the image is left unchanged.
     *
     * Params:
     * 		filename	= Path of the image file to load
     *
     * Returns: true if loading succeeded, false if it failed
     */
    bool loadFromFile(const(char)[] filename)
    {
        return sfImage_loadFromFile(sfPtr, filename.ptr, filename.length);
    }

    /**
     * Load the image from a file in memory.
     *
     * The supported image formats are bmp, png, tga, jpg, gif, psd, hdr and
     * pic. Some format options are not supported, like progressive jpeg. If
     * this function fails, the image is left unchanged.
     *
     * Params:
     * 		data	= Data file in memory to load
     *
     * Returns: true if loading succeeded, false if it failed
     */
    bool loadFromMemory(const(void)[] data)
    {
        return sfImage_loadFromMemory(sfPtr, data.ptr, data.length);
    }

    /**
     * Load the image from a custom stream.
     *
     * The supported image formats are bmp, png, tga, jpg, gif, psd, hdr and
     * pic. Some format options are not supported, like progressive jpeg. If
     * this function fails, the image is left unchanged.
     *
     * Params:
     * 		stream	= Source stream to read from
     *
     * Returns: true if loading succeeded, false if it failed
     */
    bool loadFromStream(InputStream stream)
    {
        return sfImage_loadFromStream(sfPtr, new imageStream(stream));
    }

    /**
     * Get the color of a pixel
     *
     * This function doesn't check the validity of the pixel coordinates; using
     * out-of-range values will result in an undefined behaviour.
     *
     * Params:
     * 		x	= X coordinate of the pixel to get
     * 		y	= Y coordinate of the pixel to get
     *
     * Returns: Color of the pixel at coordinates (x, y)
     */
    Color getPixel(uint x, uint y) const
    {
        Color temp;
        sfImage_getPixel(sfPtr, x,y, &temp.r, &temp.b, &temp.g, &temp.a);
        return temp;
    }

    /**
     * Get the read-only array of pixels that make up the image.
     *
     * The returned value points to an array of RGBA pixels made of 8 bits
     * integers components. The size of the array is:
     * `width * height * 4 (getSize().x * getSize().y * 4)`.
     *
     * Warning: the returned slice may become invalid if you modify the image,
     * so you should never store it for too long.
     *
     * Returns: Read-only array of pixels that make up the image.
     */
    const(ubyte)[] getPixelArray() const
    {
        Vector2u size = getSize();
        int length = size.x * size.y * 4;

        if(length!=0)
        {
            return sfImage_getPixelsPtr(sfPtr)[0..length];
        }
        else
        {
            err.writeln("Trying to access the pixels of an empty image");
            return [];
        }
    }

    /**
     * Return the size (width and height) of the image.
     *
     * Returns: Size of the image, in pixels.
     */
    Vector2u getSize() const
    {
        Vector2u temp;
        sfImage_getSize(sfPtr,&temp.x, &temp.y);
        return temp;
    }

    /**
     * Change the color of a pixel.
     *
     * This function doesn't check the validity of the pixel coordinates, using
     * out-of-range values will result in an undefined behaviour.
     *
     * Params:
     * 		x		= X coordinate of pixel to change
     * 		y		= Y coordinate of pixel to change
     * 		color	= New color of the pixel
     */
    void setPixel(uint x, uint y, Color color)
    {
        sfImage_setPixel(sfPtr, x,y,color.r, color.b,color.g, color.a);
    }

    /**
     * Copy pixels from another image onto this one.
     *
     * This function does a slow pixel copy and should not be used intensively.
     * It can be used to prepare a complex static image from several others, but
     * if you need this kind of feature in real-time you'd better use
     * RenderTexture.
     *
     * If sourceRect is empty, the whole image is copied. If applyAlpha is set
     * to true, the transparency of source pixels is applied. If it is false,
     * the pixels are copied unchanged with their alpha value.
     *
     * Params:
     * 	source		= Source image to copy
     * 	destX		= X coordinate of the destination position
     * 	destY		= Y coordinate of the destination position
     * 	sourceRect	= Sub-rectangle of the source image to copy
     * 	applyAlpha	= Should the copy take the source transparency into account?
     */
    void copyImage(const(Image) source, uint destX, uint destY, IntRect sourceRect = IntRect(0,0,0,0), bool applyAlpha = false)
    {
        sfImage_copyImage(sfPtr, source.sfPtr, destX, destY,sourceRect.left, sourceRect.top, sourceRect.width, sourceRect.height, applyAlpha);
    }

    /**
     * Create a transparency mask from a specified color-key.
     *
     * This function sets the alpha value of every pixel matching the given
     * color to alpha (0 by default) so that they become transparent.
     *
     * Params:
     * 		maskColor   = Color to make transparent
     * 		alpha	    = Alpha value to assign to transparent pixels
     */
    void createMaskFromColor(Color maskColor, ubyte alpha = 0)
    {
        sfImage_createMaskFromColor(sfPtr,maskColor.r,maskColor.b, maskColor.g, maskColor.a, alpha);
    }

    /// Create a copy of the Image.
    @property Image dup() const
    {
        return new Image(sfImage_copy(sfPtr));
    }

    /// Flip the image horizontally (left <-> right)
    void flipHorizontally()
    {
        sfImage_flipHorizontally(sfPtr);
    }

    /// Flip the image vertically (top <-> bottom)
    void flipVertically()
    {
        sfImage_flipVertically(sfPtr);
    }

    /**
     * Save the image to a file on disk.
     *
     * The format of the image is automatically deduced from the extension. The
     * supported image formats are bmp, png, tga and jpg. The destination file
     * is overwritten if it already exists. This function fails if the image is
     * empty.
     *
     * Params:
     * 		filename	= Path of the file to save
     *
     * Returns: true if saving was successful
     */
    bool saveToFile(const(char)[] filename) const
    {
        return sfImage_saveToFile(sfPtr, filename.ptr, filename.length);
    }
}

unittest
{
    version(DSFML_Unittest_Graphics)
    {
        import std.stdio;

        writeln("Unit test for Image");

        auto image = new Image();

        image.create(100,100,Color.Blue);

        assert(image.getPixel(0,0) == Color.Blue);

        image.setPixel(0,0,Color.Green);

        assert(image.getPixel(0,0) == Color.Green);

        image.flipHorizontally();

        assert(image.getPixel(99,0) == Color.Green);

        image.flipVertically();

        assert(image.getPixel(99,99) == Color.Green);

        assert(image.getSize() == Vector2u(100,100));

        writeln();
    }
}

private extern(C++) interface imageInputStream
{
    long read(void* data, long size);

    long seek(long position);

    long tell();

    long getSize();
}

private class imageStream:imageInputStream
{
    private InputStream myStream;

    this(InputStream stream)
    {
        myStream = stream;
    }

    extern(C++)long read(void* data, long size)
    {
        return myStream.read(data[0..cast(size_t)size]);
    }

    extern(C++)long seek(long position)
    {
        return myStream.seek(position);
    }

    extern(C++)long tell()
    {
        return myStream.tell();
    }

    extern(C++)long getSize()
    {
        return myStream.getSize();
    }
}

package extern(C) struct sfImage;

private extern(C):

//Construct a new image
sfImage* sfImage_construct();

void sfImage_create(sfImage* image, uint width, uint height);

//Create an image and fill it with a unique color
void sfImage_createFromColor(sfImage* image, uint width, uint height, ubyte r, ubyte b, ubyte g, ubyte a);

//Create an image from an array of pixels
void sfImage_createFromPixels(sfImage* image, uint width, uint height, const(ubyte)* pixels);

//Create an image from a file on disk
bool sfImage_loadFromFile(sfImage* image, const(char)* filename, size_t length);

//Create an image from a file in memory
bool sfImage_loadFromMemory(sfImage* image, const(void)* data, size_t size);

//Create an image from a custom stream
bool sfImage_loadFromStream(sfImage* image, imageInputStream stream);

//Copy an existing image
sfImage* sfImage_copy(const(sfImage)* image);

//Destroy an existing image
void sfImage_destroy(sfImage* image);

//Save an image to a file on disk
bool sfImage_saveToFile(const sfImage* image, const char* filename, size_t length);

//Return the size of an image
void sfImage_getSize(const sfImage* image, uint* width, uint* height);

//Create a transparency mask from a specified color-key
void sfImage_createMaskFromColor(sfImage* image, ubyte r, ubyte b, ubyte g, ubyte a, ubyte alpha);

//Copy pixels from an image onto another
void sfImage_copyImage(sfImage* image, const(sfImage)* source, uint destX, uint destY, int sourceRectLeft, int sourceRectTop, int sourceRectWidth, int sourceRectHeight, bool applyAlpha);

//Change the color of a pixel in an image
void sfImage_setPixel(sfImage* image, uint x, uint y, ubyte r, ubyte b, ubyte g, ubyte a);

//Get the color of a pixel in an image
void sfImage_getPixel(const sfImage* image, uint x, uint y, ubyte* r, ubyte* b, ubyte* g, ubyte* a);

//Get a read-only pointer to the array of pixels of an image
const(ubyte)* sfImage_getPixelsPtr(const sfImage* image);

//Flip an image horizontally (left <-> right)
void sfImage_flipHorizontally(sfImage* image);

//Flip an image vertically (top <-> bottom)
void sfImage_flipVertically(sfImage* image);