using System;
using Chernobyl.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Creation;
using Chernobyl.Dependency;
using Chernobyl.Graphics;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Polygon;
using Chernobyl.Graphics.Polygon.Buffers;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Measures;
using Chernobyl.Utility;

namespace Chernobyl.Interface
{
    /// <summary>
    /// Used to give borders to various interface widgets such as buttons, edit 
    /// boxes, etc.
    /// </summary>
    public class Borders : DrawableTransformCollidable2D
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Borders"/> class that 
        /// places borders along all edges (Edge.Top, Edge.Left, Edge.Right, 
        /// Edge.Bottom) of the bordered item.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives out services.</param>
        public Borders(IEventCollection<object> services)
            : this(services, Edge.All)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Borders"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> instance that 
        /// takes and gives out services.</param>
        /// <param name="edges">The edges of the item where the border(s) 
        /// should be placed.</param>
        public Borders(IEventCollection<object> services, Edge edges)
        {
            _drawableImplementer = new Drawable();
            _drawableImplementer.DecoratoringDrawable = this;
            _decoratedTransform = new MatrixTransform();
            _shapeCollection = new ShapeCollection();

            Services = services;
            Services.Inject<Borders>(this);

            services.Create<IDrawBufferFactory, IDrawBuffer,
                            Pair<IEventCollection<object>, IBuffer>>(
                                (sender, e) => BorderDrawBuffer = e.CreatedInstance,
                                new Pair<IEventCollection<object>, IBuffer>(services, VertexColor.CreateSquare(Services, ColorRgba.Black)));
            
            Edges = edges;
        }

        /// <summary>
        /// The edges of the item where the border(s) 
        /// should be placed.
        /// </summary>
        /// <value>By default, the value of this property is 
        /// <see cref="Edge.All"/></value>
        public Edge Edges
        {
            get { return _edges; }
            set
            {
                _edges = value;

                if (_borderDrawableParent != null)
                    RefreshBorders();
            }
        }

        /// <summary>
        /// Recreates the borders on the edges of the object.
        /// </summary>
        void RefreshBorders()
        {
            if ((_edges & Edge.Right) == Edge.Right)
            {
                // create a TransformRectangle of 1x1. The transform rectangle will
                // automatically adjust as we scale the border. Currently, the border
                // is using a 1x1 square mesh element to render textures to, therefore, 
                // a 1x1 TransformRectangle will only work properly with a 1x1 mesh 
                // element square.
                Rectangle rectangle = new Rectangle(-0.5f, -0.5f, 1, 1);

                // create the right and attach it to this Border and the draw buffer
                RightBorder = new Render(Services, PrimitiveType.TriangleStrip, null, new RemoveScaleTransform(Axis.X | Axis.Z, true), rectangle);
                Transform.MakeParentChild(RightBorder, rectangle);
                Transform.MakeParentChild(this, RightBorder);
                _shapeCollection.Add(RightBorder);

                // position along the right of the item
                RightBorder.TranslateX(0.5f);
                
            }
            else if (RightBorder != null)
                RightBorder = RemoveBorder(RightBorder);

            if ((_edges & Edge.Left) == Edge.Left)
            {
                // create a TransformRectangle of 1x1. The transform rectangle will
                // automatically adjust as we scale the border. Currently, the border
                // is using a 1x1 square mesh element to render textures to, therefore, 
                // a 1x1 TransformRectangle will only work properly with a 1x1 mesh 
                // element square.
                Rectangle rectangle = new Rectangle(-0.5f, -0.5f, 1, 1);

                // create the left and attach it to this Border and the draw buffer
                LeftBorder = new Render(Services, PrimitiveType.TriangleStrip, null, new RemoveScaleTransform(Axis.X | Axis.Z, true), rectangle);
                Transform.MakeParentChild(RightBorder, rectangle);
                Transform.MakeParentChild(this, LeftBorder);
                _shapeCollection.Add(LeftBorder);

                // position along the left of the item
                LeftBorder.TranslateX(-0.5f);
                
            }
            else if (LeftBorder != null)
                LeftBorder = RemoveBorder(LeftBorder);

            if ((_edges & Edge.Top) == Edge.Top)
            {
                // create a TransformRectangle of 1x1. The transform rectangle will
                // automatically adjust as we scale the border. Currently, the border
                // is using a 1x1 square mesh element to render textures to, therefore, 
                // a 1x1 TransformRectangle will only work properly with a 1x1 mesh 
                // element square.
                Rectangle rectangle = new Rectangle(-0.5f, -0.5f, 1, 1);

                // create the top and attach it to this Border and the draw buffer
                TopBorder = new Render(Services, PrimitiveType.TriangleStrip, null, new RemoveScaleTransform(Axis.Y | Axis.Z, true), rectangle);
                Transform.MakeParentChild(RightBorder, rectangle);
                Transform.MakeParentChild(this, TopBorder);
                _shapeCollection.Add(TopBorder);

                // position along the top of the item
                TopBorder.Roll((Degree)90.0f);
                TopBorder.TranslateY(0.5f);
            }
            else if (TopBorder != null)
                TopBorder = RemoveBorder(TopBorder);

            if ((_edges & Edge.Bottom) == Edge.Bottom)
            {
                // create a TransformRectangle of 1x1. The transform rectangle will
                // automatically adjust as we scale the border. Currently, the border
                // is using a 1x1 square mesh element to render textures to, therefore, 
                // a 1x1 TransformRectangle will only work properly with a 1x1 mesh 
                // element square.
                Rectangle rectangle = new Rectangle(-0.5f, -0.5f, 1, 1);

                // create the bottom and attach it to this Border and the draw buffer
                BottomBorder = new Render(Services, PrimitiveType.TriangleStrip, null, new RemoveScaleTransform(Axis.Y | Axis.Z, true), rectangle);
                Transform.MakeParentChild(RightBorder, rectangle);
                Transform.MakeParentChild(this, BottomBorder);
                _shapeCollection.Add(BottomBorder);

                // position along the top of the item
                BottomBorder.Roll((Degree)90.0f);
                BottomBorder.TranslateY(-0.5f);
            }
            else if (BottomBorder != null)
                BottomBorder = RemoveBorder(BottomBorder);
        }

        /// <summary>
        /// Removes a border from the item.
        /// </summary>
        /// <param name="border">The border to remove from the item.</param>
        /// <returns>The new value of the <see cref="IRender"/> 
        /// <paramref name="border"/> passed in.</returns>
        IRender RemoveBorder(IRender border)
        {
            // Separate the border from this parent and remove it from the 
            // draw path
            Transform.SeperateParentChild(this, border);
            BorderDrawBuffer.DrawableChildren.Remove(border);
            _shapeCollection.Remove(border);
            return null;
        }

        /// <summary>
        /// The <see cref="Scene"/> used for rendering borders. The 
        /// <see cref="Scene.Draw2D"/> drawable will be used as the actual 
        /// parent.
        /// </summary>
        [Inject]
        public Scene DefaultScene
        {
            set
            {
                _borderDrawableParent = value.Draw2D;
                RefreshBorders();
            }
        }

        /// <summary>
        /// The <see cref="IRender"/> used to render the border on the right side 
        /// of the item.
        /// </summary>
        IRender RightBorder { get; set; }

        /// <summary>
        /// The <see cref="IRender"/> used to render the border on the left side 
        /// of the item.
        /// </summary>
        IRender LeftBorder { get; set; }

        /// <summary>
        /// The <see cref="IRender"/> used to render the border on the top of 
        /// the item.
        /// </summary>
        IRender TopBorder { get; set; }

        /// <summary>
        /// The <see cref="IRender"/> used to render the border on the bottom of 
        /// the item.
        /// </summary>
        IRender BottomBorder { get; set; }

        /// <summary>
        /// The <see cref="IDrawBuffer"/> used to render the mesh element data of 
        /// the border squares.
        /// </summary>
        /// <value>The border draw buffer.</value>
        IDrawBuffer BorderDrawBuffer
        {
            get { return _borderDrawBuffer; }
            set
            {
                value.ThrowIfNull("value");

                IDrawBuffer previousValue = _borderDrawBuffer;
                _borderDrawBuffer = value;

                if (previousValue != null)
                {
                    if (previousValue.DrawableParent == _borderDrawableParent)
                        previousValue.DrawableParent = null;
                }

                _borderDrawBuffer.DrawableParent = _borderDrawableParent; 
            }
        }

        /// <summary>
        /// The services instance that was given to this class in it's constructor.
        /// This instance is used to create borders.
        /// </summary>
        IEventCollection<object> Services { get; set; }

        /// <summary>
        /// The collidable that implements the collision of this object.
        /// </summary>
        protected override ICollidable2D CollidableImplementer
        {
            get { throw new NotImplementedException(); }
        }

        /// <summary>
        /// The drawable that implements the drawing of this object.
        /// </summary>
        protected override IDrawable DrawableImplementer
        {
            get { return _drawableImplementer; }
        }

        /// <summary>
        /// The transform that provides this transforms capabilities.
        /// </summary>
        protected override ITransform DecoratedTransform
        {
            get { return _decoratedTransform; }
        }

        /// <summary>
        /// The <see cref="IShape"/> that implements the
        /// <see cref="IShape"/> interface for this object.
        /// </summary>
        protected override IShape ShapeImplementer
        {
            get { return _shapeCollection; }
        }

        /// <summary>
        /// Backing field to <see cref="Edges"/>.
        /// </summary>
        Edge _edges;

        /// <summary>
        /// The <see cref="IDrawable"/> that will become the parent of new 
        /// borders.
        /// </summary>
        IDrawable _borderDrawableParent;

        /// <summary>
        /// The backing field to <see cref="DrawableImplementer"/>.
        /// </summary>
        IDrawable _drawableImplementer;

        /// <summary>
        /// The backing field to <see cref="DecoratedTransform"/>.
        /// </summary>
        ITransform _decoratedTransform;

        /// <summary>
        /// The <see cref="ShapeCollection"/> that calculates the width and 
        /// height of the Borders.
        /// </summary>
        ShapeCollection _shapeCollection;

        /// <summary>
        /// The backing field to <see cref="BorderDrawBuffer"/>.
        /// </summary>
        IDrawBuffer _borderDrawBuffer;
    }
}