using System;
using System.Collections.Generic;
using System.Diagnostics;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Texture;
using Chernobyl.Graphics.Writing;
using Chernobyl.Input.Controls;
using Chernobyl.Interface.Input;
using Chernobyl.Interface.Tool;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Plugin;
using Chernobyl.Utility;

namespace Chernobyl.Interface
{
    /// <summary>
    /// The main class for the Chernobyl.Interface plug-in module. This class
    /// provides Chernobyl.Interface specific parent for the rest of Chernobyl
    /// and other client code.
    /// </summary>
    public class Interface : DecoratingEventList<object>, IPlugin
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Interface"/> class.
        /// </summary>
        /// <param name="parent">The instance that is the parent to this
        /// <see cref="IEventCollection{T}"/> instance.</param>
        public Interface(IEventCollection<object> parent)
        {
            Trace = new TraceSource("Chernobyl.Interface");
            
            _parent = parent;
            parent.Add(this);

            parent.Inject(this);
        }

        /// <summary>
        /// A <see cref="TraceSource"/> used to output errors, warnings, information, 
        /// etc., that are specific to Chernobyl.Interface. This 
        /// <see cref="TraceSource"/> will have the name "Chernobyl.Interface".
        /// </summary>
        public static TraceSource Trace { get; private set; }

        /// <summary>
        /// Setting the <see cref="ISearchPaths"/> instance here will add the 
        /// Chernobyl.Interface specific search paths to the 
        /// <see cref="ISearchPaths"/> instance.
        /// </summary>
        [Inject]
        public ISearchPaths SearchPaths
        {
            set
            {
                value.Add("../../Chernobyl.Interface");
            }
        }

        /// <summary>
        /// The <see cref="IMouse"/> that the <see cref="ICursor"/> will attach 
        /// to so that the cursor can be moved around the screen.
        /// </summary>
        [Inject]
        public IMouse Mouse
        {
            set
            {
                _mouse = value;
                _mouseCursor = new Cursor(_parent, "data/images/cursor.tga", _mouse);
            }
        }

        /// <summary>
        /// The <see cref="IEventCollection{T}"/> class that holds interface factory collections.
        /// </summary>
        [Provide]
        public IInterfaceFactoryCollectionServices InterfaceFactoriesCollections 
        { 
            get
            {
                if(_interfaceFactoriesCollections == null)
                {
                    _interfaceFactoriesCollections = new InterfaceFactoryCollectionServices();

                    //////////////////////////////////////////////////////////////////////////
                    // set some default interface factory collection into the interface 
                    // factory collection services instance
                    //////////////////////////////////////////////////////////////////////////

                    // IStandardInterfaceFactoryCollection
                    {
                        IStandardInterfaceFactoryCollection standardInterfaceFactories = new StandardInterfaceFactoryCollection();
                        InterfaceFactoriesCollections.Add(standardInterfaceFactories);
                        standardInterfaceFactories.Add(new KeyValuePair<Type, InterfaceFactory>(typeof(object), item => new Text(_parent, item.ToString())));
                    }

                    // IIconInterfaceFactoryCollection
                    {
                        IIconInterfaceFactoryCollection iconInterfaceFactories = new IconInterfaceFactoryCollection();
                        InterfaceFactoriesCollections.Add(iconInterfaceFactories);
                        iconInterfaceFactories.Add(new KeyValuePair<Type, InterfaceFactory>(typeof(string), item => new Sprite(_parent, new Texture2D(_parent, "interface/images/icons/text.tga"))));
                    }
                }

                return _interfaceFactoriesCollections;
            }
        }

        /// <summary>
        /// The instance that determines where instance are placed for the
        /// layering of controls.
        /// </summary>
        [Provide]
        public LayerBucket Layers
        {
            get
            {
                return _layers ?? (_layers = new LayerBucket(_parent));
            }
        }

        /// <summary>
        /// The instance that is used by the user to control pointer interaction 
        /// with the Chernobyl interface.
        /// </summary>
        [Provide]
        public PointerControlCollection PointerControl
        {
            get { return _pointerControl ?? (_pointerControl = new PointerController(_parent)); }
        }

        /// <summary>
        /// The instance that is the parent to this <see cref="IEventCollection{T}"/> 
        /// instance.
        /// </summary>
        readonly IEventCollection<object> _parent;

        /// <summary>
        /// The instance that is displayed on the screen for the mouse pointer.
        /// Other cursors, such as those for the gamepads, are not created because
        /// client code may not want a gamepad cursor while a mouse cursor is likely
        /// needed if a mouse is plugged in. If this value is null then an IMouse
        /// was not provided to this instance.
        /// </summary>
        ICursor _mouseCursor;

        /// <summary>
        /// The backing field to <see cref="Mouse"/>
        /// </summary>
        IMouse _mouse;

        /// <summary>
        /// The backing field to <see cref="InterfaceFactoriesCollections"/>
        /// </summary>
        IInterfaceFactoryCollectionServices _interfaceFactoriesCollections;

        /// <summary>
        /// The backing field to <see cref="Layers"/>.
        /// </summary>
        LayerBucket _layers;

        /// <summary>
        /// The backing field to <see cref="PointerControl"/>.
        /// </summary>
        PointerControlCollection _pointerControl;

        /// <summary>
        /// The holder for the interface <see cref="Layout"/>s used for adding 
        /// interface layers.
        /// </summary>
        public class LayerBucket
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="LayerBucket"/> struct.
            /// </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>
            public LayerBucket(IEventCollection<object> services)
                : this(services, DefaultLayerOffsetAmount)
            { }

            /// <summary>
            /// Initializes a new instance of the <see cref="LayerBucket"/> struct.
            /// </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="layerOffsetAmount">The layer offset amount.</param>
            public LayerBucket(IEventCollection<object> services, Vector3 layerOffsetAmount)
            {
                LayerOffsetAmount = layerOffsetAmount;
                services.Inject(this);
            }

            /// <summary>
            /// A transform that is responsible for layering 2D interface widgets.
            /// This is the layer farthest away from the screen. It is where the 
            /// bottom most widgets lie. 
            /// </summary>
            /// <value>The bottom most layer of the widgets. By default, the value
            /// of this property is a <see cref="Layout"/> whose 
            /// <see cref="Layout.PositionModifier"/> has been set to a 
            /// vector denoted by <see cref="DefaultLayerOffsetAmount"/>.</value>
            public Layout BottomLayerTransform { get; set; }

            /// <summary>
            /// A transform that is responsible for layering 2D interface widgets.
            /// This is the layer between the bottom and top layers. It is where  
            /// the middle widgets lie. 
            /// </summary>
            /// <value>The middle layer of the widgets. By default, the value
            /// of this property is a <see cref="Layout"/> whose 
            /// <see cref="Layout.PositionModifier"/> has been set to a 
            /// vector denoted by <see cref="DefaultLayerOffsetAmount"/>.</value>
            public Layout MiddleLayerTransform { get; set; }

            /// <summary>
            /// A transform that is responsible for layering 2D interface widgets.
            /// This is the layer closest to the screen. It is where the top most 
            /// widgets lie. 
            /// </summary>
            /// <value>The top most layer of the widgets. By default, the value
            /// of this property is a <see cref="Layout"/> whose 
            /// <see cref="Layout.PositionModifier"/> has been set to a 
            /// vector denoted by <see cref="DefaultLayerOffsetAmount"/>.</value>
            public Layout TopLayerTransform { get; set; }

            /// <summary>
            /// The default amount to offset the interface layers by. This 
            /// field has the value of Vector3(0.0f, 0.0f, 0.001f).
            /// <seealso cref="BottomLayerTransform"/>
            /// <seealso cref="MiddleLayerTransform"/>
            /// <seealso cref="TopLayerTransform"/>
            /// </summary>
            public static readonly Vector3 DefaultLayerOffsetAmount = new Vector3(0.0f, 0.0f, 0.001f);

            /// <summary>
            /// The amount that each interface <see cref="Layout"/> transform will 
            /// offset it's children transforms by. The default value of this property 
            /// is given by the field <see cref="DefaultLayerOffsetAmount"/>.
            /// </summary>
            Vector3 LayerOffsetAmount { get; set; }

            /// <summary>
            /// The <see cref="Layout"/> transform that will become the root 
            /// <see cref="Layout"/> transform for the interface 
            /// <see cref="Layout"/> transforms.
            /// </summary>
            [Inject]
            public Layout LayersTransform
            {
                set
                {
                    //////////////////////////////////////////////////////////////////////////
                    // Setup the layers - give each of them a layer offset amount and
                    // attach them to the root layers transform
                    //////////////////////////////////////////////////////////////////////////

                    TopLayerTransform = new Layout(LayerOffsetAmount, Axis.Z);
                    value.Add(TopLayerTransform);
                    

                    MiddleLayerTransform = new Layout(LayerOffsetAmount, Axis.Z);
                    value.Add(MiddleLayerTransform);

                    BottomLayerTransform = new Layout(LayerOffsetAmount, Axis.Z);
                    value.Add(BottomLayerTransform);
                }
            }
        }

        /// <summary>
        /// A type that gathers together the controls used for controlling
        /// aspects of the Chernobyl interface.
        /// </summary>
        class PointerController : PointerControlCollection
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="PointerController"/> 
            /// 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>
            public PointerController(IEventCollection<object> services)
            {
                services.OfType<IMouse>(service => Mouse = service);
            }

            /// <summary>
            /// The <see cref="IMouse"/> that is to interact with the GUI.
            /// </summary>
            IMouse Mouse
            {
                set
                {
                    value.ThrowIfNull("value");

                    if (_mouse != null)
                        Remove(_mouse);

                    _mouse = new MousePointerControl(value);
                    Add(_mouse);
                }
            }

            /// <summary>
            /// The mouse GUI interaction method.
            /// </summary>
            MousePointerControl _mouse;
        }
    }
}