using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Polygon.Buffers;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Movement;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Controllers
{
    /// <summary>
    /// The XNA implementation of an <see cref="IRender"/>.
    /// </summary>
    public class XnaRender : DrawableTransform, IRender
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class whose services will be 
        /// injected into the render objects</param>
        /// <param name="primitiveType">The primitive type of the render object.</param>
        /// <param name="drawable">The <see cref="IDrawable"/> used by the created 
        /// <see cref="IRender"/> object to control drawing.</param>
        /// <param name="decoratedTransform">The <see cref="ITransform"/> used by the created 
        /// <see cref="IRender"/> to control transformations.</param>
        /// <param name="shape">The <see cref="IShape"/> used by the created 
        /// <see cref="IRender"/> to control shape related functionality.</param>
        public XnaRender(IEventCollection<object> services, Chernobyl.Graphics.Drawing.PrimitiveType primitiveType, 
            IDrawable drawable, ITransform decoratedTransform, IShape shape)
        {
            _drawableImplementer = drawable;
            _drawableImplementer.DecoratoringDrawable = this;
            _decoratedTransform = decoratedTransform;
            _shapeImplementer = shape;

            PrimitiveType = primitiveType;
            DrawMethod = NoOpDraw;
            services.Inject(this);
        }

        /// <summary>
        /// Calls draw on the children objects. Overload to add you own implementation.
        /// </summary>
        public override uint Draw()
        {
            DrawMethod();

            return base.Draw();
        }

        /// <summary>
        /// The method that draws the mesh
        /// </summary>
        public Action DrawMethod { get; set; }

        /// <summary>
        /// Draws a mesh with indices specified.
        /// </summary>
        public void DrawWithIndices()
        {
            SceneWorldMatrix.Value = WorldMatrix;
            VertexBuffer vertexBuffer = Mesh.XnaVertexBuffer;
            GraphicsDevice.DrawIndexedPrimitives(XnaPrimitiveType, 0, 0, (int)Mesh.Count, 0, Utility.GetPrimitiveCount(XnaPrimitiveType, Mesh.Count));
        }

        /// <summary>
        /// Draws a mesh without indices specified.
        /// </summary>
        public void DrawWithoutIndices()
        {
            SceneWorldMatrix.Value = WorldMatrix;
            VertexBuffer vertexBuffer = Mesh.XnaVertexBuffer;
            GraphicsDevice.DrawPrimitives(XnaPrimitiveType, 0, Utility.GetPrimitiveCount(XnaPrimitiveType, Mesh.Count));
        }

        /// <summary>
        /// A no-op (no operation) draw method that does nothing. This
        /// is the default DrawMethod used by this draw.
        /// </summary>
        public void NoOpDraw() {}

        /// <summary>
        /// The mesh element buffer used to draw the data.
        /// </summary>
        public IXnaMesh Mesh 
        {
            get { return _mesh; }
            set 
            { 
                _mesh = value;
                RevaluateDrawMethod();
            }
        }

        /// <summary>
        /// The index buffer used to draw the data.
        /// </summary>
        public IBuffer IndexBuffer
        {
            get { return _indexBuffer; }
            set
            {
                _indexBuffer = value;
                RevaluateDrawMethod();
            }
        }

        /// <summary>
        /// The primitive type being drawn.
        /// </summary>
        public Chernobyl.Graphics.Drawing.PrimitiveType PrimitiveType 
        { 
            get { return Utility.ToChernobylPrimitiveType(XnaPrimitiveType); } 
            set { XnaPrimitiveType = Utility.ToXnaPrimitiveType(value); } 
        }

        /// <summary>
        /// The graphics devices used by this draw.
        /// </summary>
        [Inject]
        public GraphicsDevice GraphicsDevice
        {
            get { return _graphicsDevice; }
            set
            {
                _graphicsDevice = value;
                RevaluateDrawMethod();
            }
        }

        /// <summary>
        /// The world matrix used to set our transformation on.
        /// </summary>
        [Inject]
        public IWorldMatrixParameter SceneWorldMatrix
        {
            get { return _sceneWorldMatrix; }
            set
            {
                _sceneWorldMatrix = value;
                RevaluateDrawMethod();
            }
        }        

        /// <summary>
        /// The largest width of the object in the object's X axis.
        /// </summary>
        public float Width
        {
            get { return _shapeImplementer.Width; }
        }

        /// <summary>
        /// The largest height of the object in the object's Y axis.
        /// </summary>
        public float Height
        {
            get { return _shapeImplementer.Height; }
        }

        /// <summary>
        /// The largest depth of the object in the object's Z axis.
        /// </summary>
        public float Depth
        {
            get { return _shapeImplementer.Depth; }
        }

        /// <summary>
        /// True if this <see cref="IShape"/> is convex, false if it is concave
        /// or has 0 <see cref="Dimensions"/> (such as a point). A
        /// <see cref="IShape"/> is convex if for every pair of points within
        /// the object, every point on the straight line segment that joins them
        /// is also within the object. A concave <see cref="IShape"/> is the
        /// opposite of this.
        /// </summary>
        public bool IsConvex
        {
            get { return _shapeImplementer.IsConvex; }
        }

        /// <summary>
        /// The amount of space taken up by an object on a flat plane in
        /// square metres (m^2).
        /// </summary>
        public float Area
        {
            get { return _shapeImplementer.Area; }
        }

        /// <summary>
        /// The amount of 3D space this object consumes in cubic metres (m^3).
        /// If this object is 2D, then the value of this property is zero.
        /// </summary>
        public float Volume
        {
            get { return _shapeImplementer.Volume; }
        }

        /// <summary>
        /// The length of the path that surrounds a shape specified in metres (m).
        /// In the case of a closed curve such as a circle, this value represents
        /// the circumference of the object.
        /// </summary>
        public float Perimeter
        {
            get { return _shapeImplementer.Perimeter; }
        }

        /// <summary>
        /// The minimum number of coordinates needed to specify each point
        /// within this object. For example: a point has 0 dimensions, a
        /// line has 1 dimension, a circle or rectangle has 2 dimensions, a
        /// cube or sphere has 3 dimensions, and a moving cube or sphere has 4.
        /// </summary>
        public uint Dimensions
        {
            get { return _shapeImplementer.Dimensions; }
        }

        /// <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 width and height 
        /// capabilities of this type.
        /// </summary>
        protected IShape GeometryImplementer { get { return _shapeImplementer; } }

        /// <summary>
        /// Checks the draw method to ensure that is the correct draw method
        /// given whether the IndexBuffer and Mesh exist.
        /// </summary>
        void RevaluateDrawMethod()
        {
            if (Mesh != null && GraphicsDevice != null && SceneWorldMatrix != null)
            {
                if (IndexBuffer != null)
                    DrawMethod = DrawWithIndices;
                else
                    DrawMethod = DrawWithoutIndices;
            }
            else
                DrawMethod = NoOpDraw;
        }

        /// <summary>
        /// The XNA primitive type.
        /// </summary>
        Microsoft.Xna.Framework.Graphics.PrimitiveType XnaPrimitiveType { get; set; }

        /// <summary>
        /// The backing field to <see cref="Mesh"/>.
        /// </summary>
        IXnaMesh _mesh;

        /// <summary>
        /// The backing field to <see cref="IndexBuffer"/>.
        /// </summary>
        IBuffer _indexBuffer;

        /// <summary>
        /// The backing field to <see cref="GraphicsDevice"/>
        /// </summary>
        GraphicsDevice _graphicsDevice;

        /// <summary>
        /// The backing field to <see cref="SceneWorldMatrix"/>.
        /// </summary>
        IWorldMatrixParameter _sceneWorldMatrix;

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

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

        /// <summary>
        /// The backing field to <see cref="GeometryImplementer"/>.
        /// </summary>
        IShape _shapeImplementer;
    }
}