using Chernobyl.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.ComponentModel;
using Chernobyl.Creation;
using Chernobyl.Event;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Polygon.Buffers;

namespace Chernobyl.Graphics.Xna.Controllers
{
    /// <summary>
    /// Responsible for handling the XNA specific drawing of a 
    /// <see cref="IBuffer"/>'s data.
    /// </summary>
    public class XnaDrawBuffer : Drawable, IDrawBuffer
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services instance that takes services and
        /// gives services.</param>
        /// <param name="buffer">The buffer whose data is to be rendered.</param>
        public XnaDrawBuffer(IEventCollection<object> services, IBuffer buffer)
        {
            DescendantAdded += XnaDrawBufferDescendantAdded;
            Buffer = buffer;
        }

        /// <summary>
        /// Applies the XnaBuffer so that its data can be properly drawn to the 
        /// screen.
        /// </summary>
        public override void PreDraw()
        {
            _buffer.Apply();
        }

        /// <summary>
        /// The IBuffer whose data is being drawn by this buffer.
        /// </summary>
        public IBuffer Buffer 
        {
            get { return _buffer; }
            set
            {
                // the "soul" of the buffer should be the XnaBuffer.
                BufferDecorator buffer = (BufferDecorator)value;
                if (buffer != null)
                    _buffer = (IXnaBuffer)buffer.DecoratedBuffer;
            }
        }

        /// <summary>
        /// Returns null since there is not controller for the XNA buffer.
        /// </summary>
        public IDrawBuffer Controller { get { return null; } }

        /// <summary>
        /// Gets or sets the name of the instance.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// A type that creates <see cref="XnaDrawBuffer"/> instances.
        /// </summary>
        public class Factory : Builder<IDrawBuffer>, IDrawBufferFactory
        {
            /// <summary>
            /// Constructs an instance of type <see cref="XnaDrawBuffer"/>.
            /// </summary>
            /// <param name="callback">The method that should be invoked when the
            /// instance has been created, when its creation was canceled, or when
            /// an error occurred during its creation. Note that this callback may
            /// be invoked on another thread.</param>
            /// <param name="args">The instance that contains the factory arguments.
            /// <see cref="Pair{TFirst, TSecond}.First"/> contains the instance 
            /// that gives out services for use by this type and takes services 
            /// from this type for use by other systems. 
            /// <see cref="Pair{TFirst, TSecond}.Second"/> contains the buffer 
            /// whose data is to be rendered.</param>
            /// <returns>
            /// The <see cref="ITask"/> that can be used to control and
            /// track the creation/configuration of the instance.
            /// </returns>
            public ITask Create(CreationCompletedEventHandler<IDrawBuffer> callback, Pair<IEventCollection<object>, IBuffer> args)
            {
                ReportCreation(callback, new CreationEventArgs<IDrawBuffer>(new XnaDrawBuffer(args.First, args.Second)));
                return Task.Simple;
            }
        }

        /// <summary>
        /// This method is invoked by the DescendantAdded event. This method 
        /// will look to see if the item added was a Render, if it was it will 
        /// get the XnaRender of that Render and give it the XnaBuffer of this 
        /// class using XnaBuffer.SetRender(XnaRender).
        /// </summary>
        /// <param name="sender">The sender of the argument.</param>
        /// <param name="e">The arguments to the event.</param>
        void XnaDrawBufferDescendantAdded(object sender, EventArgs<IDrawable> e)
        {
            Render render = e.Value as Render;
            if (render != null)
            {
                XnaRender xnaRender = render.Controller as XnaRender;
                if (xnaRender != null)
                    _buffer.SetRender(xnaRender);
            }
        }

        /// <summary>
        /// The backing field to <see cref="Buffer"/> and the XNA specific buffer.
        /// </summary>
        IXnaBuffer _buffer;
    }
}