using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Input.Controls;
using Chernobyl.Input.Controls.Axis;
using Chernobyl.Mathematics.Mechanics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;

namespace Chernobyl.Input.Xna.Controls.Gamepad
{
    /// <summary>
    /// An implementation of <see cref="IGamepad"/> that represents an XNA
    /// <see cref="IGamepad"/>.
    /// </summary>
    public class XnaGamepad : Control, IGamepad
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="XnaGamepad"/> 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="playerIndex">The player that controls this
        /// <see cref="IGamepad"/> instance.</param>
        /// <param name="initialState">The starting XNA state of this
        /// <see cref="IGamepad"/> instance.</param>
        public XnaGamepad(IEventCollection<object> services, PlayerIndex playerIndex, GamePadState initialState)
        {
            _services = services;
            PlayerIndex = playerIndex;
            State = initialState;
        }

        /// <summary>
        /// The A button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl A
        {
            get { return CheckedButtonCreation(ref _a, this, Capabilities.HasAButton, Buttons.A); }
        }

        /// <summary>
        /// The B button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl B
        {
            get { return CheckedButtonCreation(ref _b, this, Capabilities.HasBButton, Buttons.B); }
        }

        /// <summary>
        /// The X button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl C
        {
            get { return CheckedButtonCreation(ref _c, this, Capabilities.HasXButton, Buttons.X); }
        }

        /// <summary>
        /// The Y button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl D
        {
            get { return CheckedButtonCreation(ref _d, this, Capabilities.HasYButton, Buttons.Y); }
        }

        /// <summary>
        /// The left bumper button on the <see cref="IGamepad"/> or null if it
        /// does not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl LeftShoulder1
        {
            get { return CheckedButtonCreation(ref _leftShoulder1, this, Capabilities.HasLeftShoulderButton, Buttons.LeftShoulder); }
        }

        /// <summary>
        /// The right bumper on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl RightShoulder1
        {
            get { return CheckedButtonCreation(ref _rightShoulder1, this, Capabilities.HasRightShoulderButton, Buttons.RightShoulder); }
        }

        /// <summary>
        /// The left thumb stick on the <see cref="IGamepad"/> or null if it
        /// does not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IThumbstick LeftStick
        {
            get
            {
                return CheckedThumbstickCreation(ref _leftStick, Capabilities.HasLeftStickButton,
                                                 Buttons.LeftStick, Thumbstick.LeftRetriever);
            }
        }

        /// <summary>
        /// The right thumb stick on the <see cref="IGamepad"/> or null if it
        /// does not exist.
        /// </summary>
        public IThumbstick RightStick
        {
            get
            {
                return CheckedThumbstickCreation(ref _rightStick, Capabilities.HasRightStickButton,
                                                 Buttons.RightStick, Thumbstick.RightRetriever);
            }
        }

        /// <summary>
        /// The back button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl Select
        {
            get { return CheckedButtonCreation(ref _select, this, Capabilities.HasBackButton, Buttons.Back); }
        }

        /// <summary>
        /// The start button on the <see cref="IGamepad"/> or null if it does
        /// not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl Start
        {
            get { return CheckedButtonCreation(ref _start, this, Capabilities.HasStartButton, Buttons.Start); }
        }

        /// <summary>
        /// The big button on the <see cref="IGamepad"/> or null if it does not
        /// exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IButtonControl Main
        {
            get { return CheckedButtonCreation(ref _main, this, Capabilities.HasBigButton, Buttons.BigButton); }
        }

        /// <summary>
        /// The primary directional pad on the <see cref="IGamepad"/> or null if
        /// it does not exist.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public IDpad Dpad
        {
            get
            {
                ThrowIfDisconnected();

                if(_dpad == null)
                {
                    _dpad = new DpadControl(this);
                    MakeParentChild(this, _dpad);
                }

                return _dpad;
            }
        }

        /// <summary>
        /// The left trigger on the <see cref="IGamepad"/> or null if it does
        /// not exist. The left trigger has a maximum value of 1 and a minimum
        /// value of 0.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IAxisControl LeftTrigger
        {
            get { return CheckedTriggerCreation(ref _leftTrigger, Capabilities.HasLeftTrigger, xnag => xnag.State.Triggers.Left); }
        }

        /// <summary>
        /// The left trigger on the <see cref="IGamepad"/> or null if it does
        /// not exist. The left trigger has a maximum value of 1 and a minimum
        /// value of 0.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        public IAxisControl RightTrigger
        {
            get { return CheckedTriggerCreation(ref _rightTrigger, Capabilities.HasRightTrigger, xnag => xnag.State.Triggers.Right); }
        }

        /// <summary>
        /// The amount of vibration, between 0 and 1, in the left motor. 0 means
        /// no vibration, 1 means maximum vibration.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the value
        /// set on this property is less than 0 or greater than 1.</exception>
        /// <exception cref="DisconnectedException">Thrown if this 
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public float LeftVibration
        {
            get { return _leftVibration; }
            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The value of the IGamepad.LeftVibration cannot be " +
                        "less than zero.");

                if (value > 1)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The value of the IGamepad.LeftVibration cannot be " +
                        "greater than one.");

                _leftVibration = value;
                GamePad.SetVibration(PlayerIndex, _leftVibration, RightVibration);
            }
        }

        /// <summary>
        /// The amount of vibration, between 0 and 1, in the right motor. 0 means
        /// no vibration, 1 means maximum vibration.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the value
        /// set on this property is less than 0 or greater than 1.</exception>
        /// <exception cref="DisconnectedException">Thrown if this 
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        public float RightVibration
        {
            get { return _rightVibration; }
            set
            {
                if (value < 0)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The value of the IGamepad.RightVibration cannot be " + 
                        "less than zero.");

                if(value > 1)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The value of the IGamepad.RightVibration cannot be " +
                        "greater than one.");

                _rightVibration = value;
                GamePad.SetVibration(PlayerIndex, LeftVibration, _rightVibration);
            }
        }

        /// <summary>
        /// The player that controls this <see cref="IGamepad"/> instance.
        /// </summary>
        public PlayerIndex PlayerIndex
        {
            get { return _playerIndex; }
            private set
            {
                _playerIndex = value;
                Capabilities = GamePad.GetCapabilities(_playerIndex);
            }
        }

        /// <summary>
        /// The current XNA state of this <see cref="IGamepad"/> instance.
        /// </summary>
        /// <exception cref="ArgumentNullException">Thrown if the value set on
        /// this property is null.</exception>
        public GamePadState State
        {
            get { return _state; }
            set
            {
                _state = value;
                _isConnected = _state.IsConnected;

                if (_isConnected == false)
                {
                    if (DisconnectedMethod != null)
                        DisconnectedMethod(this, EventArgs.Empty);
                }
                    
            }
        }

        /// <summary>
        /// The control available from the XNA <see cref="IGamepad"/>.
        /// </summary>
        public GamePadCapabilities Capabilities { get; private set; }

        /// <summary>
        /// An <see cref="IButtonControl"/> used to represent an XNA gamepad
        /// button.
        /// </summary>
        public class Button : ButtonControl
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Button"/> 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="gamepad">The XNA <see cref="IGamepad"/> instance
            /// this <see cref="IButtonControl"/> belongs to.</param>
            /// <param name="button">The button that this instance refers to.</param>
            public Button(IEventCollection<object> services, XnaGamepad gamepad, Buttons button)
                : base(services)
            {
                _gamepad = gamepad;
                _gamepad.Disconnected += OnGamepadDisconnected;
                _button = button;
            }

            /// <summary>
            /// An event that is invoked when the gamepad has disconnected.
            /// This method will attempt to raise the 
            /// <see cref="IControl.Disconnected"/> event.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance 
            /// containing the event data.</param>
            void OnGamepadDisconnected(object sender, EventArgs e)
            {
                if (DisconnectedMethod != null)
                    DisconnectedMethod(this, e);
            }

            /// <summary>
            /// True if the button is down, false if otherwise.
            /// </summary>
            /// <exception cref="DisconnectedException">Thrown if this 
            /// <see cref="IGamepad"/> has been disconnected.</exception>
            public override bool IsDown
            {
                get
                {
                    _gamepad.ThrowIfDisconnected();
                    return _gamepad.State.IsButtonDown(_button);
                }
                protected set
                {
                    throw new NotSupportedException("You cannot set the state " + 
                                                    "of a XNA gamepad button.");
                }
            }

            /// <summary>
            /// The XNA <see cref="IGamepad"/> instance this 
            /// <see cref="IButtonControl"/> belongs to.
            /// </summary>
            XnaGamepad _gamepad;

            /// <summary>
            /// The button that this instance refers to.
            /// </summary>
            Buttons _button;
        }

        /// <summary>
        /// Represents the XNA gamepads thumbsticks.
        /// </summary>
        public class Thumbstick : Axis2DControl, IThumbstick
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Thumbstick"/> 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="gamepad">The XNA <see cref="IGamepad"/> instance
            /// this <see cref="IButtonControl"/> belongs to.</param>
            /// <param name="button">The button that this instance refers to.</param>
            /// <param name="retrieveCurrentValue">The method which is used to
            /// retrieve the current <see cref="Microsoft.Xna.Framework.Vector2"/> 
            /// value of the thumbsticks.</param>
            public Thumbstick(IEventCollection<object> services, XnaGamepad gamepad, Buttons button,
                Func<XnaGamepad, Microsoft.Xna.Framework.Vector2> retrieveCurrentValue)
                : base(services)
            {
                _services = services;
                _gamepad = gamepad;
                _gamepad.Disconnected += OnGamepadDisconnected;
                _button = button;

                Axis xControl  = new Axis(_services, _gamepad, xnag => retrieveCurrentValue(xnag).X);
                xControl.Sensitivity = 10.0f;
                X = xControl;
                Control.MakeParentChild(this, xControl);

                Axis yControl = new Axis(_services, _gamepad, xnag => retrieveCurrentValue(xnag).Y);
                yControl.Sensitivity = 10.0f;
                Y = yControl;
                Control.MakeParentChild(this, yControl);
            }

            /// <summary>
            /// Used to retrieve the <see cref="Microsoft.Xna.Framework.Vector2"/> 
            /// value of the left thumbstick.
            /// </summary>
            /// <param name="gamepad">The gamepad to retrieve the value from.</param>
            /// <returns>The value that was retrieved.</returns>
            public static Microsoft.Xna.Framework.Vector2 LeftRetriever(XnaGamepad gamepad)
            {
                gamepad.ThrowIfDisconnected();
                return gamepad.State.ThumbSticks.Left;
            }

            /// <summary>
            /// Used to retrieve the <see cref="Microsoft.Xna.Framework.Vector2"/> 
            /// value of the right thumbstick.
            /// </summary>
            /// <param name="gamepad">The gamepad to retrieve the value from.</param>
            /// <returns>The value that was retrieved.</returns>
            public static Microsoft.Xna.Framework.Vector2 RightRetriever(XnaGamepad gamepad)
            {
                gamepad.ThrowIfDisconnected();
                return gamepad.State.ThumbSticks.Right;
            }

            /// <summary>
            /// Checks to see if a thumbsticks or buttons state has been changed 
            /// and fires the necessary events if so. Also calls update on the 
            /// children.
            /// </summary>
            /// <param name="deltaTime">The amount of time that has passed 
            /// since the last call to update.</param>
            public override void Update(TimeSpan deltaTime)
            {
                // update the previous state
                bool previousState = WasDown;
                WasDown = IsDown;

                // check if the new button state has changed
                if (IsDown != previousState)
                {
                    // yes it has
                    EventArgs<IButton> e = new EventArgs<IButton>(this);

                    if (OnChange != null)
                        OnChange(this, EventArgs.Empty);

                    if (IsDown == true && OnDown != null)
                        OnDown(this, EventArgs.Empty);
                    else if (OnUp != null)
                        OnUp(this, e);
                }

                base.Update(deltaTime);
            }

            /// <summary>
            /// True if the button was down, false
            /// if otherwise (set to the previous 
            /// value of "IsDown").
            /// </summary>
            public bool WasDown { get; protected set; }

            /// <summary>
            /// True if the button is down, false
            /// if otherwise.
            /// </summary>
            public virtual bool IsDown
            {
                get
                {
                    _gamepad.ThrowIfDisconnected();
                    return _gamepad.State.IsButtonDown(_button);
                }
            }

            /// <summary>
            /// An event that is raised when this button is pushed down or 
            /// turned on.
            /// </summary>
            public event EventHandler OnDown;

            /// <summary>
            /// An event that is raised when this button has stopped being 
            /// pushed down or is off.
            /// </summary>
            public event EventHandler OnUp;

            /// <summary>
            /// An event that is raised when this button's state has changed.
            /// </summary>
            public event EventHandler OnChange;

            /// <summary>
            /// An event that is invoked when the gamepad has disconnected.
            /// This method will attempt to raise the 
            /// <see cref="IControl.Disconnected"/> event.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance 
            /// containing the event data.</param>
            void OnGamepadDisconnected(object sender, EventArgs e)
            {
                if (DisconnectedMethod != null)
                    DisconnectedMethod(this, e);
            }

            /// <summary>
            /// The instance that gives out services for use by this type and 
            /// takes services from this type for use by other systems.
            /// </summary>
            IEventCollection<object> _services;

            /// <summary>
            /// The XNA <see cref="IGamepad"/> instance this instance belongs to.
            /// </summary>
            XnaGamepad _gamepad;

            /// <summary>
            /// The button that this instance refers to.
            /// </summary>
            Buttons _button;
        }

        /// <summary>
        /// Used to represent one axis on an XNA <see cref="IGamepad"/>.
        /// </summary>
        public class Axis : AxisControl
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Axis"/> 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="gamepad">The XNA <see cref="IGamepad"/> instance
            /// this <see cref="IControl"/> belongs to.</param>
            /// <param name="retrieveCurrentValue">The method which is used
            /// to retrieve the current <see cref="float"/> value of the 
            /// thumbstick axis.</param>
            public Axis(IEventCollection<object> services, XnaGamepad gamepad, Func<XnaGamepad, float> retrieveCurrentValue)
                : base(services)
            {
                _gamepad = gamepad;
                _gamepad.Disconnected += OnGamepadDisconnected;
                _retrieveCurrentValue = retrieveCurrentValue;
            }

            /// <summary>
            /// The amount of change, from the axis' <see cref="IAxis.PreviousValue"/>
            /// to its <see cref="IAxis.CurrentValue"/>. Implementors should return
            /// the raw change amount and not try to apply
            /// <see cref="IAxis.Sensitivity"/> to the returned value. The
            /// <see cref="AxisControl"/> class will apply the
            /// <see cref="IAxis.Sensitivity"/> value for you.
            /// </summary>
            protected override float OverridableChangeAmount
            {
                get { return _retrieveCurrentValue(_gamepad); }
            }

            /// <summary>
            /// An event that is invoked when the gamepad has disconnected.
            /// This method will attempt to raise the 
            /// <see cref="IControl.Disconnected"/> event.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance 
            /// containing the event data.</param>
            void OnGamepadDisconnected(object sender, EventArgs e)
            {
                if (DisconnectedMethod != null)
                    DisconnectedMethod(this, e);
            }

            /// <summary>
            /// The XNA <see cref="IGamepad"/> instance this instance 
            /// belongs to.
            /// </summary>
            XnaGamepad _gamepad;

            /// <summary>
            /// The method which is used to retrieve the current 
            /// <see cref="float"/> value of the thumbstick axis.
            /// </summary>
            Func<XnaGamepad, float> _retrieveCurrentValue;
        }

        /// <summary>
        /// Used to represent the XNA <see cref="IGamepad"/> instance's 
        /// <see cref="IDpad"/>.
        /// </summary>
        public class DpadControl : Control, IDpad
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="DpadControl"/> class.
            /// </summary>
            /// <param name="gamepad">The gamepad.</param>
            public DpadControl(XnaGamepad gamepad)
            {
                _gamepad = gamepad;
                _gamepad.Disconnected += OnGamepadDisconnected;
            }

            /// <summary>
            /// The top button on the <see cref="IDpad"/> or null if it does not
            /// exist.
            /// </summary>
            public IButtonControl Up
            {
                get { return _gamepad.CheckedButtonCreation(ref _up, this, _gamepad.Capabilities.HasDPadUpButton, Buttons.DPadUp); }
            }

            /// <summary>
            /// The right button on the <see cref="IDpad"/> or null if it does not
            /// exist.
            /// </summary>
            public IButtonControl Right
            {
                get { return _gamepad.CheckedButtonCreation(ref _right, this, _gamepad.Capabilities.HasDPadRightButton, Buttons.DPadRight); }
            }

            /// <summary>
            /// The bottom button on the <see cref="IDpad"/> or null if it does not
            /// exist.
            /// </summary>
            public IButtonControl Down
            {
                get { return _gamepad.CheckedButtonCreation(ref _down, this, _gamepad.Capabilities.HasDPadDownButton, Buttons.DPadDown); }
            }

            /// <summary>
            /// The left button on the <see cref="IDpad"/> or null if it does not
            /// exist.
            /// </summary>
            public IButtonControl Left
            {
                get { return _gamepad.CheckedButtonCreation(ref _left, this, _gamepad.Capabilities.HasDPadLeftButton, Buttons.DPadLeft); }
            }

            /// <summary>
            /// An event that is invoked when the gamepad has disconnected.
            /// This method will attempt to raise the 
            /// <see cref="IControl.Disconnected"/> event.
            /// </summary>
            /// <param name="sender">The instance that generated the event.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance 
            /// containing the event data.</param>
            void OnGamepadDisconnected(object sender, EventArgs e)
            {
                if (DisconnectedMethod != null)
                    DisconnectedMethod(this, e);
            }

            /// <summary>
            /// The XNA <see cref="IGamepad"/> instance this instance belongs to.
            /// </summary>
            XnaGamepad _gamepad;

            /// <summary>
            /// The backing field to <see cref="Up"/>.
            /// </summary>
            IButtonControl _up;

            /// <summary>
            /// The backing field to <see cref="Right"/>.
            /// </summary>
            IButtonControl _right;

            /// <summary>
            /// The backing field to <see cref="Down"/>.
            /// </summary>
            IButtonControl _down;

            /// <summary>
            /// The backing field to <see cref="Left"/>.
            /// </summary>
            IButtonControl _left;
        }


        /// <summary>
        /// Creates and configures a <see cref="Button"/> instance but only if
        /// the <paramref name="button"/> is null and the
        /// <paramref name="hasButton"/> value is true. The created button or
        /// null is then returned.
        /// </summary>
        /// <param name="button">The <see cref="Button"/> that is to be checked
        /// for existence before attempting to create one.</param>
        /// <param name="parent">The <see cref="IControl"/> that is the parent
        /// to this control.</param>
        /// <param name="hasButton">True if the <see cref="Button"/> getting
        /// created is available on the XNA gamepad.</param>
        /// <param name="xnaValue">The XNA value of the <see cref="Button"/> to
        /// create.</param>
        /// <returns>
        /// The <see cref="Button"/> instance that has been created or
        /// null if <paramref name="button"/> was not null and
        /// <paramref name="hasButton"/> is true.
        /// </returns>
        /// <exception cref="DisconnectedException">Thrown if this
        ///   <see cref="IGamepad"/> has been disconnected.</exception>
        IButtonControl CheckedButtonCreation(ref IButtonControl button, IControl parent, bool hasButton, Buttons xnaValue)
        {
            ThrowIfDisconnected();

            if (button == null && hasButton == true)
            {
                button = new Button(_services, this, xnaValue);
                MakeParentChild(parent, button);
            }

            return button;
        }

        /// <summary>
        /// Creates and configures a <see cref="Thumbstick"/> instance but only
        /// if the <paramref name="thumbstick"/> is null and the
        /// <paramref name="hasThumbstick"/> value is true. The created
        /// thumbstick or null is then returned.
        /// </summary>
        /// <param name="thumbstick">The <see cref="Thumbstick"/> that is to be
        /// checked for existence before attempting to create one.</param>
        /// <param name="hasThumbstick">True if the <see cref="Thumbstick"/>
        /// getting created is available on the XNA gamepad.</param>
        /// <param name="xnaValue">The XNA value of the <see cref="Thumbstick"/>
        /// to create.</param>
        /// <param name="retrieveCurrentValue">The method which is used to
        /// retrieve the current <see cref="Microsoft.Xna.Framework.Vector2"/> 
        /// value of the thumbsticks.</param>
        /// <returns>The <see cref="Thumbstick"/> instance that has been created
        /// or null if <paramref name="thumbstick"/> was not null and
        /// <paramref name="hasThumbstick"/> is true.</returns>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        IThumbstick CheckedThumbstickCreation(ref IThumbstick thumbstick, bool hasThumbstick,
            Buttons xnaValue, Func<XnaGamepad, Microsoft.Xna.Framework.Vector2> retrieveCurrentValue)
        {
            ThrowIfDisconnected();

            if (thumbstick == null && hasThumbstick == true)
            {
                thumbstick = new Thumbstick(_services, this, xnaValue, retrieveCurrentValue);
                MakeParentChild(this, thumbstick);
            }

            return thumbstick;
        }

        /// <summary>
        /// Creates and configures a trigger instance but only if the 
        /// <paramref name="trigger"/> is null and the
        /// <paramref name="hasThumbstick"/> value is true. The created
        /// thumbstick or null is then returned.
        /// </summary>
        /// <param name="trigger">The gamepad trigger that is to be checked for 
        /// existence before attempting to create one.</param>
        /// <param name="hasThumbstick">True if the trigger getting created is 
        /// available on the XNA gamepad.</param>
        /// <param name="retrieveCurrentValue">The method which is used to
        /// retrieve the current <see cref="float"/> value of the trigger.</param>
        /// <returns>The trigger instance that has been created or null if 
        /// <paramref name="trigger"/> was not null and
        /// <paramref name="hasThumbstick"/> is true.</returns>
        /// <exception cref="DisconnectedException">Thrown if this
        /// <see cref="IGamepad"/> has been disconnected.</exception>
        IAxisControl CheckedTriggerCreation(ref IAxisControl trigger, bool hasThumbstick,
            Func<XnaGamepad, float> retrieveCurrentValue)
        {
            ThrowIfDisconnected();

            if (trigger == null && hasThumbstick == true)
            {
                trigger = new Axis(_services, this, retrieveCurrentValue);
                MakeParentChild(this, trigger);
            }

            return trigger;
        }

        /// <summary>
        /// Throws a <see cref="DisconnectedException"/> if this 
        /// <see cref="IGamepad"/> is disconnected.
        /// </summary>
        /// <exception cref="DisconnectedException">Thrown if the controller is
        /// disconnected.</exception>
        void ThrowIfDisconnected()
        {
            if(_isConnected == false)
                throw new DisconnectedException(this, "Unable to perform the " + 
                                                "requested action. The gamepad " + 
                                                "has been disconnected.");
        }

        /// <summary>
        /// The instance that gives out services for use 
        /// by this type and takes services from this type for use by other 
        /// systems.
        /// </summary>
        IEventCollection<object> _services;

        /// <summary>
        /// True if the gamepad is disconnected, false if otherwise.
        /// </summary>
        bool _isConnected;

        /// <summary>
        /// The backing field to <see cref="A"/>.
        /// </summary>
        IButtonControl _a;

        /// <summary>
        /// The backing field to <see cref="B"/>.
        /// </summary>
        IButtonControl _b;

        /// <summary>
        /// The backing field to <see cref="C"/>.
        /// </summary>
        IButtonControl _c;

        /// <summary>
        /// The backing field to <see cref="D"/>.
        /// </summary>
        IButtonControl _d;

        /// <summary>
        /// The backing field to <see cref="LeftShoulder1"/>.
        /// </summary>
        IButtonControl _leftShoulder1;

        /// <summary>
        /// The backing field to <see cref="RightShoulder1"/>.
        /// </summary>
        IButtonControl _rightShoulder1;

        /// <summary>
        /// The backing field to <see cref="LeftStick"/>.
        /// </summary>
        IThumbstick _leftStick;

        /// <summary>
        /// The backing field to <see cref="RightStick"/>.
        /// </summary>
        IThumbstick _rightStick;

        /// <summary>
        /// The backing field to <see cref="Select"/>.
        /// </summary>
        IButtonControl _select;

        /// <summary>
        /// The backing field to <see cref="Start"/>.
        /// </summary>
        IButtonControl _start;

        /// <summary>
        /// The backing field to <see cref="Main"/>.
        /// </summary>
        IButtonControl _main;

        /// <summary>
        /// The backing field to <see cref="Dpad"/>.
        /// </summary>
        IDpad _dpad;

        /// <summary>
        /// The backing field to <see cref="LeftTrigger"/>.
        /// </summary>
        IAxisControl _leftTrigger;

        /// <summary>
        /// The backing field to <see cref="RightTrigger"/>.
        /// </summary>
        IAxisControl _rightTrigger;

        /// <summary>
        /// The backing field to <see cref="LeftVibration"/>.
        /// </summary>
        float _leftVibration;

        /// <summary>
        /// The backing field to <see cref="RightVibration"/>.
        /// </summary>
        float _rightVibration;

        /// <summary>
        /// The backing field to <see cref="PlayerIndex"/>.
        /// </summary>
        PlayerIndex _playerIndex;

        /// <summary>
        /// The backing field to <see cref="State"/>.
        /// </summary>
        GamePadState _state;
    }
}