using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Graphics.Texture;
using Chernobyl.Mathematics.Geometry;
using Microsoft.Xna.Framework.Graphics;

namespace Chernobyl.Graphics.Xna.Controllers
{
    /// <summary>
    /// Used to control an XNA 2D texture.
    /// </summary>
    class XnaTexture2D : Rectangle, ITexture2D
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class that contains the 
        /// dependencies to inject into this instance.</param>
        /// <param name="width">The width of the texture in pixels.</param>
        /// <param name="height">The height of the texture in pixels.</param>
        /// <param name="mipmapLevels">The number of mipmap levels to generate.</param>
        /// <param name="textureFormat">The format of the texture data.</param>
        public XnaTexture2D(IEventCollection<object> services, uint width, uint height, uint mipmapLevels, TextureFormat textureFormat) 
            : base(0, 0, 0, 0)
        {
            TextureFormat = textureFormat;
            PixelCount = width * height;
            GraphicsDeviceSetter graphicsDeviceSetter = new GraphicsDeviceSetter(this, width, height, mipmapLevels);
            services.OfType<GraphicsDevice>(graphicsDeviceSetter.SetGraphicsDeviceAndConfigure);
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class that contains the 
        /// dependencies to inject into this instance.</param>
        /// <param name="texture">The XNA texture that this texture should use.</param>
        public XnaTexture2D(IEventCollection<object> services, Microsoft.Xna.Framework.Graphics.Texture2D texture)
            : base(0, 0, 0, 0)
        {
            XnaTexture = texture;
            Configure();
        }

        /// <summary>
        /// Configures some common parameters.
        /// </summary>
        public void Configure()
        {
            Width = XnaTexture.Width;
            Height = XnaTexture.Height;
            PixelCount = (uint)(Width * Height);
            IsReady = true;
        }

        /// <summary>
        /// Disposes of the texture controller used by this 
        /// 2D texture.
        /// </summary>
        public void Dispose()
        {
            if (XnaTexture != null)
                XnaTexture.Dispose();
        }

        /// <summary>
        /// A type used to retrieve the <see cref="GraphicsDevice"/> from an
        /// <see cref="IEventCollection{T}"/> and set it on an <see cref="XnaTexture2D"/>.
        /// </summary>
        struct GraphicsDeviceSetter
        {
            /// <summary>
            /// Initializes a new instance of the 
            /// <see cref="GraphicsDeviceSetter"/> struct.
            /// </summary>
            /// <param name="texture">The texture to set the 
            /// <see cref="GraphicsDevice"/> on and invoke 
            /// <see cref="XnaTexture2D.Configure()"/> on.</param>
            /// <param name="width">The width of the texture in pixels.</param>
            /// <param name="height">The height of the texture in pixels.</param>
            /// <param name="mipmapLevels">The number of mipmap levels to generate.</param>
            public GraphicsDeviceSetter(XnaTexture2D texture, uint width, uint height, uint mipmapLevels)
                : this()
            {
                Texture = texture;
                Width = width;
                Height = height;
                MipmapLevels = mipmapLevels;
            }

            /// <summary>
            /// The method that is invoked by the <see cref="IEventCollection{T}" />
            /// instance when the <see cref="GraphicsDevice" /> has been set.
            /// </summary>
            /// <param name="service">The service that was requested.</param>
            public void SetGraphicsDeviceAndConfigure(GraphicsDevice service)
            {
                Texture.XnaTexture =
                    new Microsoft.Xna.Framework.Graphics.Texture2D(service, (int)Width, (int)Height, (int)MipmapLevels,
                                                                   TextureUsage.AutoGenerateMipMap, Texture._surfaceFormat);
                Texture.Configure();
            }

            /// <summary>
            /// The texture to set the <see cref="GraphicsDevice"/> on and  
            /// invoke <see cref="XnaTexture2D.Configure()"/> on.
            /// </summary>
            XnaTexture2D Texture { get; set; }

            /// <summary>
            /// The width of the texture in pixels.
            /// </summary>
            uint Width { get; set; }

            /// <summary>
            /// The height of the texture in pixels.
            /// </summary>
            uint Height { get; set; }

            /// <summary>
            /// The number of mipmap levels to generate.
            /// </summary>
            uint MipmapLevels { get; set; }
        }

        /// <summary>
        /// Sets the data from the array passed in into the texture at mipmap
        /// level 0.
        /// </summary>
        /// <typeparam name="TData">The type of data to set into the texture.</typeparam>
        /// <param name="data">The data to set into the texture.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Set<TData>(TData[] data) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be set " + 
                "because the XNA texture has not been fully configured.");

            XnaTexture.SetData(data);
            if(DataChanged != null)
                DataChanged(this, new TextureDataEventArgs(new TextureDataEventArgs.Modification(0, PixelCount)));
        }

        /// <summary>
        /// Set the raw texture data into the texture, starting at the beginning of
        /// the texture and ending at <paramref name="elementCount"/>, at mipmap
        /// level 0.
        /// </summary>
        /// <typeparam name="TData">The data type of the texture data.</typeparam>
        /// <param name="data">The data to set.</param>
        /// <param name="startIndex">The starting element in <paramref name="data"/> at which to start copying data.</param>
        /// <param name="elementCount">The number of elements to copy over from <paramref name="data"/>.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Set<TData>(TData[] data, uint startIndex, uint elementCount) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be set " +
                "because the XNA texture has not been fully configured.");

            XnaTexture.SetData(data, (int)startIndex, (int)elementCount, SetDataOptions.None);
            if (DataChanged != null)
                DataChanged(this, new TextureDataEventArgs(new TextureDataEventArgs.Modification(startIndex, elementCount)));
        }

        /// <summary>
        /// Sets the texture data.
        /// </summary>
        /// <typeparam name="TData">The data type of the texture data.</typeparam>
        /// <param name="mipmapLevel">The mipmap level to place the data into.</param>
        /// <param name="setSection">The region or area of the texture to place the data into. If <paramref name="setSection"/>
        /// is null then the entire texture will be set to the passed in data.</param>
        /// <param name="data">The data to set.</param>
        /// <param name="startIndex">The starting element in <paramref name="data"/> at which to start copying data.</param>
        /// <param name="elementCount">The number of elements to copy over from <paramref name="data"/>.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Set<TData>(uint mipmapLevel, Rectangle setSection, TData[] data, uint startIndex, uint elementCount) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be set " +
                "because the XNA texture has not been fully configured.");

            if (setSection != null)
            {
                XnaTexture.SetData((int)mipmapLevel, new Microsoft.Xna.Framework.Rectangle((int)setSection.LeftSide, (int)setSection.Bottom, (int)setSection.Width, (int)setSection.Height), data, (int)startIndex, (int)elementCount, SetDataOptions.None);

                if (DataChanged != null)
                    DataChanged(this, new TextureDataEventArgs(new TextureDataEventArgs.Modification(setSection, (uint)Width)));
            }
            else
            {
                XnaTexture.SetData((int)mipmapLevel, null, data, (int)startIndex, (int)elementCount, SetDataOptions.None);

                if (DataChanged != null)
                    DataChanged(this, new TextureDataEventArgs(new TextureDataEventArgs.Modification(startIndex, elementCount)));
            }
        }

        /// <summary>
        /// Gets the texture data.
        /// </summary>
        /// <typeparam name="TData">The data type of the texture data.</typeparam>
        /// <param name="mipmapLevel">The mipmap level to get the data from.</param>
        /// <param name="getSection">The region or area of the texture to get the data from. If <paramref name="getSection"/>
        /// is null then the entire texture will be will be placed into <paramref name="data"/>.</param>
        /// <param name="data">The array that is to be filled with the texture data.</param>
        /// <param name="startIndex">The index in the <paramref name="data"/> array to start copying the data from the texture.</param>
        /// <param name="elementCount">The number of elements to copy over from the texture.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Get<TData>(uint mipmapLevel, Rectangle getSection, out TData[] data, uint startIndex, uint elementCount) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be " +
                "retrieved because the XNA texture has not been fully configured.");

            data = new TData[elementCount];
            if (getSection != null)
                XnaTexture.GetData((int)mipmapLevel, new Microsoft.Xna.Framework.Rectangle((int)getSection.LeftSide, (int)getSection.Bottom, (int)getSection.Width, (int)getSection.Height), data, (int)startIndex, (int)elementCount);
            else
                XnaTexture.GetData((int)mipmapLevel, null, data, (int)startIndex, (int)elementCount);
        }

        /// <summary>
        /// Retrieves all of the raw data in the texture at mipmap level 0.
        /// </summary>
        /// <typeparam name="TData">The data type of the texture data.</typeparam>
        /// <param name="data">The array that is to be filled with the texture data. This 
        /// array must be of a size that is large enough to receive all of the texture data.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Get<TData>(TData[] data) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be " +
                "retrieved because the XNA texture has not been fully configured.");

            XnaTexture.GetData(data);
        }

        /// <summary>
        /// Gets the raw texture data at mipmap level zero.
        /// </summary>
        /// <typeparam name="TData">The data type of the texture data.</typeparam>
        /// <param name="data">The array that is to be filled with the texture data.</param>
        /// <param name="startIndex">The index in the <paramref name="data"/> array to start copying the data from the texture.</param>
        /// <param name="elementCount">The number of elements to copy over from the texture.</param>
        /// <exception cref="NotReadyException">Thrown if this XNA texture has
        /// not been fully configured.</exception>
        public void Get<TData>(out TData[] data, uint startIndex, uint elementCount) where TData : struct
        {
            if (IsReady == false)
                throw new NotReadyException("The texture data cannot be " +
                "retrieved because the XNA texture has not been fully configured.");

            data = new TData[elementCount];
            XnaTexture.GetData(data, (int)startIndex, (int)elementCount);
        }

        /// <summary>
        /// Invoked right after a change to the data of the texture has been made.
        /// </summary>
        public event EventHandler<TextureDataEventArgs> DataChanged;

        /// <summary>
        /// True if this texture has been loaded, false if otherwise.
        /// </summary>
        public bool IsReady
        {
            get { return _isReady; }
            set
            {
                bool wasReady = _isReady;
                _isReady = value;

                if (_becameReady != null && wasReady == false && _isReady == true)
                    _becameReady(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// An event that is thrown right after this <see cref="ITexture2D"/>
        /// has been loaded or readied. If an event handler is assigned to this 
        /// event after it has become ready, then that event handler will be
        /// immediately invoked.
        /// </summary>
        public event EventHandler BecameReady
        {
            add
            {
                if (IsReady == true)
                    value(this, EventArgs.Empty);

                _becameReady += value;
            }
            remove { _becameReady -= value; }
        }

        /// <summary>
        /// The number of pixels in the entire texture.
        /// </summary>
        public uint PixelCount { get; private set; }

        /// <summary>
        /// The number of levels for mipmaps
        /// </summary>
        public uint MipmapLevelsCount { get { return (uint)XnaTexture.LevelCount; } }

        /// <summary>
        /// The XNA texture used to represent this texture.
        /// </summary>
        public Microsoft.Xna.Framework.Graphics.Texture2D XnaTexture { get; set; }

        /// <summary>
        /// The <see cref="ITexture2D"/> that controls the 3D API texture (such
        /// as XNA, DirectX, OpenGL, etc) or null if this <see cref="ITexture2D"/> 
        /// does not have a controller.
        /// </summary>
        public ITexture2D Controller { get { return null; } }

        /// <summary>
        /// The <see cref="ITexture2D"/> that controls the 3D API texture (such
        /// as XNA, DirectX, OpenGL, etc) or null if this <see cref="ITexture2D"/>
        /// does not have a controller.
        /// </summary>
        ITexture ITexture.Controller { get { return null; } }

        /// <summary>
        /// Gets/sets the format of this texture.
        /// </summary>
        TextureFormat TextureFormat 
        {
            get {return Utility.ToTextureFormat(_surfaceFormat);}
            set { _surfaceFormat = Utility.ToSurfaceFormat(value); }
        }

        /// <summary>
        /// The XNA texture format.
        /// </summary>
        SurfaceFormat _surfaceFormat;

        /// <summary>
        /// The backing field to <see cref="IsReady"/>.
        /// </summary>
        bool _isReady;

        /// <summary>
        /// The backing field to <see cref="BecameReady"/>.
        /// </summary>
        EventHandler _becameReady;
    }
}