using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Input.Controls;
using Chernobyl.Input.Xna.Controls.Gamepad;
using Chernobyl.Input.Xna.Controls.Keyboard;
using Chernobyl.Input.Xna.Controls.Mouse;
using Chernobyl.Plugin;
using Chernobyl.Update;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using IUpdateable = Chernobyl.Update.IUpdateable;

namespace Chernobyl.Input.Xna
{
    /// <summary>
    /// Configures and holds information about Chernobyl.Input.Xna.
    /// </summary>
    public class XnaInputPlugin : Updateable, IPlugin
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> 
        /// instance that gives and takes services.</param>
        public XnaInputPlugin(IEventCollection<object> services)
        {
            _xnaGamepads = new SortedList<PlayerIndex, XnaGamepad>();
            Services = services;
            services.Inject(this);
        }

        /// <summary>
        /// The services provided by this plug-in or null if no services are
        /// provided.
        /// </summary>
        public IEventCollection<object> Services { get; private set; }

        /// <summary>
        /// The <see cref="Chernobyl.Update.IUpdateable"/> used to update the controls.
        /// </summary>
        [Inject(Type = typeof(IRootUpdateable))]
        public IUpdateable Updateable
        {
            get { return _updateable; }
            set
            {
                IUpdateable previousValue = _updateable;
                _updateable = value;

                if(previousValue != null)
                    Chernobyl.Update.Updateable.SeparateParentChild(previousValue, this);

                if(_updateable != null)
                    Chernobyl.Update.Updateable.MakeParentChild(_updateable, this);
            }
        }

        /// <summary>
        /// Provides the main mouse in the application.
        /// </summary>
        [Provide]
        public IMouse Mouse
        {
            get
            {
                if (_mouse == null)
                {
                    _mouse = new XnaMouse(Services);
                    Chernobyl.Update.Updateable.MakeParentChild(this, _mouse);
                }
                return _mouse;
            }
        }

        /// <summary>
        /// Provides the main keyboard in the application.
        /// </summary>
        [Provide]
        public IKeyboard Keyboard
        {
            get
            {
                if (_keyboard == null)
                {
                    _keyboard = new XnaKeyboard(Services);
                    Chernobyl.Update.Updateable.MakeParentChild(this, _keyboard);
                }
                return _keyboard;
            }
        }

        /// <summary>
        /// The <see cref="IGamepad"/> instances currently plugged into the
        /// device and are available for use. The 
        /// <see cref="IEventEnumerable{T}.ItemsAdded"/> and 
        /// <see cref="IEventEnumerable{T}.ItemsRemoved"/> can be used to know
        /// when a device has been connected or disconnected from the machine.
        /// </summary>
        [Inject(typeof(InputPlugin))]
        public IEventCollection<IGamepad> Gamepads
        {
            get { return _gamepads; }
            set
            {
                IEventCollection<IGamepad> previousValue = _gamepads;
                _gamepads = value;

                if(previousValue != null)
                {
                    // Remove the XNA gamepads from the old gamepad list.
                    foreach (KeyValuePair<PlayerIndex, XnaGamepad> gamepadPair in _xnaGamepads)
                        previousValue.Remove(gamepadPair.Value);
                }

                if (_gamepads != null)
                {
                    // Give the currently existing gamepads to the incoming list.
                    foreach (KeyValuePair<PlayerIndex, XnaGamepad> gamepadPair in _xnaGamepads)
                        _gamepads.Add(gamepadPair.Value);
                }
            }
        }

        /// <summary>
        /// By default, this method just loops through it's children
        /// and calls <see cref="Update"/> on them, passing in
        /// the delta time it receives.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since this update was last called.</param>
        public override void Update(TimeSpan deltaTime)
        {
            // Check for new gamepads.
            foreach (PlayerIndex playerIndex in Enum.GetValues(typeof(PlayerIndex)))
            {
                // Get the state of the gamepad
                // TODO: use GamePadDeadZone.None instead and calculate our own deadzone.
                GamePadState gamepadState = GamePad.GetState(playerIndex, GamePadDeadZone.Circular);

                XnaGamepad xnaGamepad;
                _xnaGamepads.TryGetValue(playerIndex, out xnaGamepad);

                if(gamepadState.IsConnected == true)
                {
                    if(xnaGamepad == null)
                    {
                        // This gamepad has just connected. We need to create a
                        // new gamepad to represent it.
                        xnaGamepad = new XnaGamepad(Services, playerIndex, gamepadState);
                        MakeParentChild(this, xnaGamepad);

                        _xnaGamepads.Add(playerIndex, xnaGamepad);
                        
                        if (Gamepads != null)
                            Gamepads.Add(xnaGamepad);
                    }
                    else
                    {
                        // The gamepad already exists so we'll just update its
                        // state.
                        xnaGamepad.State = gamepadState;
                    }
                }
                else
                {
                    // This gamepad is no longer available. Remove it from our
                    // lists.
                    if (xnaGamepad != null)
                    {
                        xnaGamepad.State = gamepadState;
                        SeparateParentChild(this, xnaGamepad);

                        _xnaGamepads.Remove(playerIndex);

                        if (Gamepads != null)
                            Gamepads.Remove(xnaGamepad);
                    }
                }
            }

            base.Update(deltaTime);
        }

        /// <summary>
        /// The <see cref="XnaGamepad"/> instances currently connected to this 
        /// device.
        /// </summary>
        SortedList<PlayerIndex, XnaGamepad> _xnaGamepads;

        /// <summary>
        /// The backing field to <see cref="Keyboard"/>.
        /// </summary>
        IKeyboard _keyboard;

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

        /// <summary>
        /// The backing field to <see cref="Updateable"/>.
        /// </summary>
        IUpdateable _updateable;

        /// <summary>
        /// The backing field to <see cref="Gamepads"/>.
        /// </summary>
        IEventCollection<IGamepad> _gamepads;
    }
}