/*
 * DSFML - The Simple and Fast Multimedia Library for D
 *
 * Copyright (c) 2013 - 2017 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
 */

/**
 * $(U Shape) is a drawable class that allows to define and display a custom
 * convex shape on a render target.
 *
 * It's only an abstract base, it needs to be specialized for concrete types of
 * shapes (circle, rectangle, convex polygon, star, ...).
 *
 * In addition to the attributes provided by the specialized shape classes, a
 * shape always has the following attributes:
 * $(UL
 * $(LI a texture)
 * $(LI a texture rectangle)
 * $(LI a fill color)
 * $(LI an outline color)
 * $(LI an outline thickness))
 *
 * $(PARA Each feature is optional, and can be disabled easily:)
 * $(UL
 * $(LI the texture can be null)
 * $(LI the fill/outline colors can be Color.Transparent)
 * $(LI the outline thickness can be zero))
 *
 * $(PARA You can write your own derived shape class, there are only two
 * abstract functions to override:)
 * $(UL
 * $(LI `getPointCount` must return the number of points of the shape)
 * $(LI `getPoint` must return the points of the shape))
 *
 * See_Also:
 * $(RECTANGLESHAPE_LINK), $(CIRCLESHAPE_LINK), $(CONVEXSHAPE_LINK),
 * $(TRANSFORMABLE_LINK)
 */
module dsfml.graphics.shape;

import dsfml.system.vector2;

import dsfml.graphics.color;
import dsfml.graphics.drawable;
import dsfml.graphics.primitivetype;
import dsfml.graphics.rect;
import dsfml.graphics.rendertarget;
import dsfml.graphics.renderstates;
import dsfml.graphics.texture;
import dsfml.graphics.transformable;
import dsfml.graphics.vertexarray;

import std.typecons : Rebindable;

/**
 * Base class for textured shapes with outline.
 */
class Shape : Drawable, Transformable
{
    mixin NormalTransformable;

    protected this()
    {
        m_vertices = new VertexArray(PrimitiveType.TrianglesFan,0);
        m_outlineVertices = new VertexArray(PrimitiveType.TrianglesStrip,0);
    }

    private
    {
        // Texture of the shape
        Rebindable!(const(Texture)) m_texture;
        // Rectangle defining the area of the source texture to display
        IntRect m_textureRect;
        // Fill color
        Color m_fillColor;
        // Outline color
        Color m_outlineColor;
        // Thickness of the shape's outline
        float m_outlineThickness = 0;
        // Vertex array containing the fill geometry
        VertexArray m_vertices;
        // Vertex array containing the outline geometry
        VertexArray m_outlineVertices;
        // Bounding rectangle of the inside (fill)
        FloatRect m_insideBounds;
        // Bounding rectangle of the whole shape (outline + fill)
        FloatRect m_bounds;
    }

    @property
    {
        /**
         * The sub-rectangle of the texture that the shape will display.
         *
         * The texture rect is useful when you don't want to display the whole
         * texture, but rather a part of it. By default, the texture rect covers
         * the entire texture.
         */
        IntRect textureRect(IntRect rect)
        {
            m_textureRect = rect;
            updateTexCoords();
            return rect;
        }
        /// ditto
        IntRect textureRect() const
        {
            return m_textureRect;
        }
    }

    @property
    {
        /**
         * The fill color of the shape.
         *
         * This color is modulated (multiplied) with the shape's texture if any.
         * It can be used to colorize the shape, or change its global opacity.
         * You can use `Color.Transparent` to make the inside of the shape
         * transparent, and have the outline alone. By default, the shape's fill
         * color is opaque white.
         */
        Color fillColor(Color color)
        {
            m_fillColor = color;
            updateFillColors();
            return color;
        }
        /// ditto
        Color fillColor() const
        {
            return m_fillColor;
        }
    }

    @property
    {
        /**
         * The outline color of the shape.
         *
         * By default, the shape's outline color is opaque white.
         */
        Color outlineColor(Color color)
        {
            m_outlineColor = color;
            updateOutlineColors();
            return color;
        }
        /// ditto
        Color outlineColor() const
        {
            return m_outlineColor;
        }
    }

    @property
    {
        /**
         * The thickness of the shape's outline.
         *
         * Note that negative values are allowed (so that the outline expands
         * towards the center of the shape), and using zero disables the
         * outline. By default, the outline thickness is 0.
         */
        float outlineThickness(float thickness)
        {
            m_outlineThickness = thickness;
            update();
            return thickness;
        }
        /// ditto
        float outlineThickness() const
        {
            return m_outlineThickness;
        }
    }

    @property
    {
        /**
         * The total number of points in the shape.
         */
        abstract uint pointCount();
    }

    /**
     * Get the global bounding rectangle of the entity.
     *
     * The returned rectangle is in global coordinates, which means that it
     * takes in account the transformations (translation, rotation, scale, ...)
     * that are applied to the entity. In other words, this function returns the
     * bounds of the sprite in the global 2D world's coordinate system.
     *
     * Returns: Global bounding rectangle of the entity.
     */
    FloatRect getGlobalBounds()
    {
        return getTransform().transformRect(getLocalBounds());
    }

    /**
     * Get the local bounding rectangle of the entity.
     *
     * The returned rectangle is in local coordinates, which means that it
     * ignores the transformations (translation, rotation, scale, ...) that are
     * applied to the entity. In other words, this function returns the bounds
     * of the entity in the entity's coordinate system.
     *
     * Returns: Local bounding rectangle of the entity.
     */
    FloatRect getLocalBounds() const
    {
        return m_bounds;
    }

    /**
     * Get a point of the shape.
     *
     * The result is undefined if index is out of the valid range.
     *
     * Params:
     * 	index = Index of the point to get, in range [0 .. getPointCount() - 1]
     *
     * Returns: Index-th point of the shape.
     */
    abstract Vector2f getPoint(uint index) const;

    /**
     * Get the source texture of the shape.
     *
     * If the shape has no source texture, a NULL pointer is returned. The
     * returned pointer is const, which means that you can't modify the texture
     * when you retrieve it with this function.
     *
     * Returns: The shape's texture.
     */
    const(Texture) getTexture() const
    {
        return m_texture;
    }

    /**
     * Change the source texture of the shape.
     *
     * The texture argument refers to a texture that must exist as long as the
     * shape uses it. Indeed, the shape doesn't store its own copy of the
     * texture, but rather keeps a pointer to the one that you passed to this
     * function. If the source texture is destroyed and the shape tries to use
     * it, the behaviour is undefined. texture can be NULL to disable texturing.
     *
     * If resetRect is true, the TextureRect property of the shape is
     * automatically adjusted to the size of the new texture. If it is false,
     * the texture rect is left unchanged.
     *
     * Params:
     * 	texture	  = New texture
     * 	resetRect = Should the texture rect be reset to the size of the new
     *              texture?
     */
    void setTexture(const(Texture) texture, bool resetRect = false)
    {
        if((texture !is null) && (resetRect || (m_texture is null)))
        {
            textureRect = IntRect(0, 0, texture.getSize().x, texture.getSize().y);
        }

        m_texture = (texture is null)? null:texture;
    }

    /**
     * Draw the shape to a render target.
     *
     * Params:
     * 		renderTarget	= Target to draw to
     * 		renderStates	= Current render states
     */
    override void draw(RenderTarget renderTarget, RenderStates renderStates)
    {
        renderStates.transform = renderStates.transform * getTransform();
        renderStates.texture = m_texture;
        renderTarget.draw(m_vertices, renderStates);

        // Render the outline
        if (m_outlineThickness != 0)
        {
            renderStates.texture = null;
            renderTarget.draw(m_outlineVertices, renderStates);
        }
    }

    /**
     * Recompute the internal geometry of the shape.
     *
     * This function must be called by the derived class everytime the shape's
     * points change (ie. the result of either `getPointCount` or `getPoint` is
     * different).
     */
    protected void update()
    {
        // Get the total number of points of the shape
        uint count = pointCount();
        if (count < 3)
        {
            m_vertices.resize(0);
            m_outlineVertices.resize(0);
            return;
        }

        m_vertices.resize(count + 2); // + 2 for center and repeated first point

        // Position
        for (uint i = 0; i < count; ++i)
        {
            m_vertices[i + 1].position = getPoint(i);
        }
        m_vertices[count + 1].position = m_vertices[1].position;

        // Update the bounding rectangle
        m_vertices[0] = m_vertices[1]; // so that the result of getBounds() is correct
        m_insideBounds = m_vertices.getBounds();

        // Compute the center and make it the first vertex
        m_vertices[0].position.x = m_insideBounds.left + m_insideBounds.width / 2;
        m_vertices[0].position.y = m_insideBounds.top + m_insideBounds.height / 2;

        // Color
        updateFillColors();

        // Texture coordinates
        updateTexCoords();

        // Outline
        updateOutline();
    }

    private
    {
        Vector2f computeNormal(Vector2f p1, Vector2f p2)
        {
            Vector2f normal = Vector2f(p1.y - p2.y, p2.x - p1.x);
            float length = sqrt(normal.x * normal.x + normal.y * normal.y);
            if (length != 0f)
            {
                normal /= length;
            }
            return normal;
        }

        float dotProduct(Vector2f p1, Vector2f p2)
        {
            return (p1.x * p2.x) + (p1.y * p2.y);
        }

        //update methods
        void updateFillColors()
        {
            for(uint i = 0; i < m_vertices.getVertexCount(); ++i)
            {
                m_vertices[i].color = m_fillColor;
            }
        }

        void updateTexCoords()
        {

            for (uint i = 0; i < m_vertices.getVertexCount(); ++i)
            {
                float xratio = (m_vertices[i].position.x - m_insideBounds.left) / m_insideBounds.width;
                float yratio = (m_vertices[i].position.y - m_insideBounds.top) / m_insideBounds.height;

                m_vertices[i].texCoords.x = m_textureRect.left + m_textureRect.width * xratio;
                m_vertices[i].texCoords.y = m_textureRect.top + m_textureRect.height * yratio;

            }
        }

        void updateOutline()
        {
            uint count = m_vertices.getVertexCount() - 2;
            m_outlineVertices.resize((count + 1) * 2);

            for (uint i = 0; i < count; ++i)
            {
                uint index = i + 1;

                // Get the two segments shared by the current point
                Vector2f p0 = (i == 0) ? m_vertices[count].position : m_vertices[index - 1].position;
                Vector2f p1 = m_vertices[index].position;
                Vector2f p2 = m_vertices[index + 1].position;

                // Compute their normal
                Vector2f n1 = computeNormal(p0, p1);
                Vector2f n2 = computeNormal(p1, p2);

                // Make sure that the normals point towards the outside of the shape
                // (this depends on the order in which the points were defined)
                if (dotProduct(n1, m_vertices[0].position - p1) > 0)
                    n1 = -n1;
                if (dotProduct(n2, m_vertices[0].position - p1) > 0)
                    n2 = -n2;

                // Combine them to get the extrusion direction
                float factor = 1f + (n1.x * n2.x + n1.y * n2.y);
                Vector2f normal = (n1 + n2) / factor;

                // Update the outline points
                m_outlineVertices[i * 2 + 0].position = p1;
                m_outlineVertices[i * 2 + 1].position = p1 + normal * m_outlineThickness;
            }

            // Duplicate the first point at the end, to close the outline
            m_outlineVertices[count * 2 + 0].position = m_outlineVertices[0].position;
            m_outlineVertices[count * 2 + 1].position = m_outlineVertices[1].position;

            // Update outline colors
            updateOutlineColors();

            // Update the shape's bounds
            m_bounds = m_outlineVertices.getBounds();
        }

        void updateOutlineColors()
        {
            for (uint i = 0; i < m_outlineVertices.getVertexCount(); ++i)
            {
                m_outlineVertices[i].color = m_outlineColor;
            }
        }
    }
}

unittest
{
    //meant to be inherited. Unit test?
}