using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics.Material.Shader.Parameters;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Plugin;
using Chernobyl.Utility;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna
{
    /// <summary>
    /// The viewport of the back buffer.
    /// </summary>
    public class XnaBackBufferViewport : IBackBufferViewport
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="XnaBackBufferViewport"/> 
        /// class.
        /// </summary>
        /// <param name="graphicsDevice">The instance whose
        /// <see cref="GraphicsDevice.Viewport" /> is used to build this instance.</param>
        /// <param name="projectionMatrix">The instance that is modified with
        /// changes to the projection.</param>
        public XnaBackBufferViewport(GraphicsDevice graphicsDevice, IShaderParameter<Matrix4> projectionMatrix)
        {
            graphicsDevice.ThrowIfNull("graphicsDevice");
            projectionMatrix.ThrowIfNull("projectionMatrix");

            ViewArea = new Rectangle(graphicsDevice.Viewport.X,
                                     graphicsDevice.Viewport.Y,
                                     graphicsDevice.Viewport.Width,
                                     graphicsDevice.Viewport.Height);

            // TODO: this shouldn't be placed here. We need to create a view frustum type class that includes 
            // information about the near and far plane. This view frustum should probably be collidable so 
            // we can do frustum culling. It should probably also be an IDrawable so that we can change the 
            // view frustum per draw graph and while drawing. 
            projectionMatrix.Value = Matrix4.Perspective((float)(Math.PI / 4.0), Width / Height, 0.1f, 100.0f);
        }

        /// <summary>
        /// The width of the viewport, in pixels.
        /// </summary>
        public float Width { get { return ViewArea.Width; } }

        /// <summary>
        /// The height of the viewport, in pixels.
        /// </summary>
        public float Height { get { return ViewArea.Height; } }

        /// <summary>
        /// The X pixel coordinate of the bottom left point on the viewport.
        /// </summary>
        public float X { get { return ViewArea.LeftSide; } }

        /// <summary>
        /// The Y pixel coordinate of the bottom left point on the viewport.
        /// </summary>
        public float Y { get { return ViewArea.Bottom; } }

        /// <summary>
        /// The viewable area of the render target. Note that all coordinates
        /// specified by the rectangle are in pixels.
        /// </summary>
        public Rectangle ViewArea { get; private set; }

        /// <summary>
        /// An Chernobyl plug-in that adds an <see cref="IBackBufferViewport"/>
        /// instance (<see cref="XnaBackBufferViewport"/> implementation) to the 
        /// services <see cref="IEventCollection{T}"/> passed to the constructor 
        /// of this instance. This type is auto-loaded by Chernobyl.
        /// </summary>
        public class Plugin : IPlugin
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Plugin"/> class.
            /// </summary>
            /// <param name="services">The <see cref="IEventCollection{T}"/> 
            /// instance that gives and takes services.</param>
            public Plugin(IEventCollection<object> services)
            {
                _services = services;
                services.Inject(this);
            }

            /// <summary>
            /// The instance that is modified with changes to the projection.
            /// </summary>
            [Inject]
            public IProjectionMatrixParameter ProjectionMatrix
            {
                set
                {
                    _projectionMatrix = value;
                    Configure();
                }
            }

            /// <summary>
            /// The instance whose 
            /// <see cref="Microsoft.Xna.Framework.Graphics.GraphicsDevice.Viewport"/> 
            /// is used to build this instance.
            /// </summary>
            [Inject]
            public GraphicsDevice GraphicsDevice
            {
                set
                {
                    _graphicsDevice = value;
                    Configure();
                }
            }

            /// <summary>
            /// Resets the projection matrix to a default value.
            /// </summary>
            void Configure()
            {
                if (_graphicsDevice != null && _projectionMatrix != null)
                    _services.Add(new XnaBackBufferViewport(_graphicsDevice, _projectionMatrix));
            }

            /// <summary>
            /// The <see cref="IEventCollection{T}"/> instance that gives and 
            /// takes services.
            /// </summary>
            readonly IEventCollection<object> _services;

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

            /// <summary>
            /// The backing field to <see cref="ProjectionMatrix"/>.
            /// </summary>
            IProjectionMatrixParameter _projectionMatrix;
        }
    }
}