using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics.Polygon.Buffers;
using Chernobyl.Readiness;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Controllers
{
    /// <summary>
    /// Represents an XNA index buffer.
    /// </summary>
    /// <typeparam name="TData">The type of data that is going to be stored in
    /// this buffer like ushort or uint. It is recommend that you use
    /// <see cref="ushort"/>s when possible to reduce the video memory used.
    /// You can use <see cref="ushort"/>s, if the number of mesh elements
    /// referred to by the indices is less or equal to the highest number a
    /// ushort can hold. For example, a 2 byte ushort can be a max value of
    /// 65,535 so you would only use the type ushort if the number of mesh
    /// elements is equal to or less than 65,535.</typeparam>
    public class XnaIndexBuffer<TData> : XnaBuffer<TData> where TData : struct 
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="XnaIndexBuffer{TData}"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        /// <param name="indices">The index data to place in this buffer.</param>
        public XnaIndexBuffer(IEventCollection<object> services, TData[] indices)
        {
            _initialIndices = indices;
            _count = (uint)indices.Length;
            services.Inject(this);
        }

        /// <summary>
        /// Gets the data in the buffer.
        /// </summary>
        /// <param name="dataOut">The array that is to be filled with the data in the buffer.</param>
        /// <param name="startIndex">The index in this buffer to start pulling the data from.</param>
        /// <param name="elementCount">The number of elements to pull from the buffer.</param>
        /// <exception cref="NotReadyException">Thrown if this <see cref="IBuffer"/>
        /// has not been fully configured (i.e <see cref="IReadyable.IsReady"/>
        /// is false). Listen to the <see cref="IReadyable.BecameReady"/> event
        /// to  know when this <see cref="IBuffer"/> is ready.</exception>
        public override void Get(out TData[] dataOut, uint startIndex, uint elementCount)
        {
            if (elementCount == 0)
                throw new ArgumentException("The parameter \"elementCount\" is zero. You must copy over at least 1 element.", "elementCount");

            dataOut = new TData[elementCount];
            IndexBuffer.GetData(dataOut, (int)startIndex, (int)elementCount);
        }

        /// <summary>
        /// Disposes of the resources used by this index buffer (like the XNA index buffer).
        /// </summary>
        public override void Dispose()
        {
            if (IndexBuffer != null)
                IndexBuffer.Dispose();
        }

        /// <summary>
        /// Sets the XNA index buffer onto the graphics device.
        /// </summary>
        public override void Apply()
        {
            GraphicsDevice.Indices = IndexBuffer;
        }

        /// <summary>
        /// Passes this XNA buffer to the render passed in so the render takes
        /// into account the data of the buffer.
        /// </summary>
        /// <param name="render">The render that should know about this buffer.</param>
        public override void SetRender(XnaRender render)
        {
            render.IndexBuffer = this;
        }

        /// <summary>
        /// The number of indices in this buffer.
        /// </summary>
        public override uint Count
        {
            get { return _count; }
        }

        /// <summary>
        /// The size of this buffer in bytes.
        /// </summary>
        public override uint SizeInBytes
        {
            get { return (uint) IndexBuffer.SizeInBytes; }
        }

        /// <summary>
        /// The XNA index buffer used to hold the indices.
        /// </summary>
        public IndexBuffer IndexBuffer { get; set; }

        /// <summary>
        /// The graphics device used by this index buffer controller. 
        /// </summary>
        [Inject]
        public GraphicsDevice GraphicsDevice
        {
            get { return _graphicsDevice; }
            set
            {
                if (_graphicsDevice != value)
                {
                    // If we are resetting the GraphicsDevice we'll need to grab a
                    // copy of the indices so that we can recreate the IndexBuffer
                    // with the new GraphicsDevice
                    if (IndexBuffer != null)
                    {
                        _initialIndices = new TData[Count];
                        IndexBuffer.GetData(_initialIndices);
                    }

                    _graphicsDevice = value;

                    // if the XNA index buffer was already created, dispose of it 
                    // to make room for the new one
                    if (IndexBuffer != null)
                        IndexBuffer.Dispose();

                    IndexBuffer = new IndexBuffer(_graphicsDevice, typeof(TData), _initialIndices.Length, BufferUsage.None);
                    IndexBuffer.SetData(_initialIndices);

                    // We no longer need this copy of the indices.
                    _initialIndices = null;

                    IsReady = true;   
                }
            }
        }

        /// <summary>
        /// The indices that this instance originally received in its
        /// constructor or null if they have been removed following initialization.
        /// </summary>
        TData[] _initialIndices;

        /// <summary>
        /// The backing field to <see cref="Count"/>.
        /// </summary>
        uint _count;

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