//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="GameController.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace DarkWynterEngine.Controllers
{
    #region Using Statements
    using System;
    using System.Diagnostics;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Storage;
    #endregion

    using Audio;
    using Globals;
    using ObjectLib;
    using Draw;

    /// <summary>
    /// Game Controller can have either a Mouse/Keyboard or XBox controller or both.
    /// It handles calling the controller interfaces of the system to ease portability between XBOX and PC
    /// and to provide an abstract movement and action interface usable by human players, bots, and network players.
    /// </summary>
    public class Controller
    {
#if !XBOX360
        private MouseState mouseState;
        private float MOUSE_ROTATION_SCALE = 0.005f;
        private float lastMouseX, lastMouseY;
        private int windowHeight, windowWidth;          // Game window Height and Width for resetting the Mouse position
        private int lastMouseWheelPos = 0;           // Position of mouse wheel on element list
#endif

        private KeyboardState keyboardState;
        private GamePadState gamePadState;

        private float GAMEPAD_ROTATION_SCALE_Y = 0.03f;
        private float GAMEPAD_ROTATION_SCALE_X = 0.03f;
        private float MENU_ANALOG_THRESHOLD = 0.4f;

        /// <summary>
        /// Type of controller
        /// </summary>
        public Enums.ControllerType playerControllerType = Enums.ControllerType.NONE;

        /// <summary>
        /// Player index associated with this controller
        /// </summary>
        public PlayerIndex playerControllerIndex;      // Controller Number

        private bool modeSwitchInputReleased = true;
        private bool attackSwitchInputReleased = true;
        private bool jumpKeyInputReleased = true;
        private bool fpsKeyInputReleased = true;
        private bool consoleKeyInputReleased = true;
        private bool movementTypeInputReleased = true;
        private bool menuUpInputReleased = true;
        private bool menuDownInputReleased = true;
        private bool menuLeftInputReleased = true;
        private bool menuRightInputReleased = true;
        private bool menuStartInputReleased = true;
        private bool menuBackInputReleased = true;
        private bool startInputReleased = true;
        private bool backInputReleased = true;
        private bool zoomInputReleased = true;
        private bool skipInputReleased = true;

        private bool blockStartBackInput = false;

        private Stopwatch dpadVerticalDelayTimer = new Stopwatch();
        private Stopwatch dpadHorizontalDelayTimer = new Stopwatch();

        /// <summary>
        /// This struct holds the controller updates for the player. It can be overriden as a test harness from public
        /// </summary>
        public struct GameInput
        {
            /// <summary>
            /// Returns the gravity for gpuObjects
            /// </summary>
            public float GetGPUGravityButton;
            /// <summary>
            /// Player rotation
            /// </summary>
            public Vector2 playerRotation;
            /// <summary>
            /// player motion
            /// </summary>
            public Vector2 playerMotion;
            /// <summary>
            /// Attack button
            /// </summary>
            public float attack;
            /// <summary>
            /// Attack amount (analog vs digital)
            /// </summary>
            public float attackAmount;
            /// <summary>
            /// Defend amount (analog vs digital)
            /// </summary>
            public float defendAmount;
            /// <summary>
            /// Amount of zoom
            /// </summary>
            public float zoomAmount;
            /// <summary>
            /// Terrain Mod enable/disable button
            /// </summary>
            public bool terrainModToggle;
            /// <summary>
            /// Walk or Hover mode button
            /// </summary>
            public bool movementTypeToggle;
            /// <summary>
            /// Jump... How high?
            /// </summary>
            public bool jump;
            /// <summary>
            /// Current attack type
            /// </summary>
            public Enums.AttackType modeSwitch;
            /// <summary>
            /// Current attack mode
            /// </summary>
            public Enums.AttackMode attackMode;
            /// <summary>
            /// Button for changing the gravity for gpuObjects
            /// </summary>
            public float gpuGravityButton;
            /// <summary>
            /// Bool check to see if this controller is being controlled by the player or by the system
            /// </summary>
            public bool manualOverride;

            // DEBUG
            public bool anyKey;

            /// <summary>
            /// Change in mass value
            /// </summary>
            public int massChangeDelta;
            /// <summary>
            /// Change in thermal value
            /// </summary>
            public int thermalChangeDelta;
            /// <summary>
            /// Toggle Frames Per Second Counter On/Off
            /// </summary>
            public bool fpsToggleButton;
            /// <summary>
            /// Toggles the Compiler console On/Off
            /// </summary>
            public bool compilerConsoleButton;

            /// <summary>
            /// Initialize our variables
            /// </summary>
            public void init()
            {
                playerRotation = Vector2.Zero;
                playerMotion = Vector2.Zero;
                attack = 0;
                attackAmount = 0;
                defendAmount = 0;
                terrainModToggle = false;
                movementTypeToggle = false;
                jump = false;
                modeSwitch = Enums.AttackType.NONE;
                manualOverride = false;
                massChangeDelta = 0;
                thermalChangeDelta = 0;
                manualOverride = false;
            }
        }
        /// <summary>
        /// Controller input object
        /// </summary>
        public GameInput gameInput = new GameInput();

        /// <summary>
        /// Struct for handling input while in the menus
        /// </summary>
        public struct MenuInput
        {
            /// <summary>
            /// Left button pressed
            /// </summary>
            public bool GetMenuLeft;
            /// <summary>
            /// Right button pressed
            /// </summary>
            public bool GetMenuRight;
            /// <summary>
            /// Up button pressed
            /// </summary>
            public bool GetMenuUp;
            /// <summary>
            /// Down button pressed
            /// </summary>
            public bool GetMenuDown;
            /// <summary>
            /// Check to see if the start or back button input has been blocked
            /// </summary>
            public bool IsStartBackInputBlocked;
            /// <summary>
            /// Start button pressed
            /// </summary>
            public bool GetStartPressed;
            /// <summary>
            /// Back button pressed
            /// </summary>
            public bool GetBackPressed;
            /// <summary>
            /// Menu start button pressed
            /// </summary>
            public bool GetMenuStartPressed;
            /// <summary>
            /// Menu back button pressed
            /// </summary>
            public bool GetMenuBackPressed;
            /// <summary>
            /// Start button released
            /// </summary>
            public bool GetAllStartReleased;
            /// <summary>
            /// Back button released
            /// </summary>
            public bool GetAllBackReleased;
            /// <summary>
            /// Menu start or back button was released
            /// </summary>
            public bool GetMenuStartBackReleased;

        }
        /// <summary>
        /// Menu Inputs
        /// </summary>
        public MenuInput menuInput = new MenuInput();

        /// <summary>
        /// Default Contructor
        /// </summary>
        public Controller(){}

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="controllerType">Controller type</param>
        /// <param name="playerIndex">Index of player associated with this controller</param>
        public Controller(Enums.ControllerType controllerType, PlayerIndex playerIndex)
        {
#if !XBOX360
            if (controllerType == Enums.ControllerType.PC_ONLY || controllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                mouseState = new MouseState();
                mouseState = Mouse.GetState();
                lastMouseX = mouseState.X;
                lastMouseY = mouseState.Y;
                lastMouseWheelPos = 0;

                keyboardState = new KeyboardState();

                playerControllerType = controllerType;
            }

            windowHeight = Statics.RenderSettings.clientHeight;
            windowWidth = Statics.RenderSettings.clientWidth;
#endif
            if (controllerType == Enums.ControllerType.XBOX_ONLY || controllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                gamePadState = new GamePadState();
                playerControllerIndex = playerIndex;

                playerControllerType = controllerType;
            }

            gameInput.init();

            modeSwitchInputReleased = true;
            attackSwitchInputReleased = true;
            movementTypeInputReleased = true;
            jumpKeyInputReleased = true;
            menuUpInputReleased = true;
            menuDownInputReleased = true;
            menuLeftInputReleased = true;
            menuRightInputReleased = true;
            menuStartInputReleased = true;
            menuBackInputReleased = true;
            startInputReleased = true;
            backInputReleased = true;

            //blockStartBackInput = false;

            dpadHorizontalDelayTimer = Stopwatch.StartNew();
            dpadVerticalDelayTimer = Stopwatch.StartNew();
        }

        private bool GetSkipButton()
        {
            if (skipInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.X))
                    {
                        skipInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.RightStick == ButtonState.Pressed)
                    {
                        skipInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.X) && gamePadState.Buttons.RightStick == ButtonState.Released)
            {
                skipInputReleased = true;
            }

            return false;
        }

        // Get key inputs for object rotation
        private Vector2 GetObjectRotation()
        {
            Vector2 mouseRotation = new Vector2(0.0f, 0.0f);
            Vector2 stickRotation = new Vector2(0.0f, 0.0f);
#if !XBOX360
            if (Statics.SystemSettings.WINDOW_IN_FOCUS)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (Statics.SystemSettings.gameState != Enums.EngineState.GAME_PAUSE)
                    {
                        if (mouseState.X > 0 && mouseState.X < windowWidth - 1 &&
                            mouseState.Y > 0 && mouseState.Y < windowHeight - 1)
                        {
                            if (lastMouseX != mouseState.X ||
                                lastMouseY != mouseState.Y)
                            {
                                float diffX = mouseState.X - lastMouseX;
                                float diffY = mouseState.Y - lastMouseY;
                                int xSign = (int)(diffX / Math.Abs(diffX));
                                int ySign = (int)(diffY / Math.Abs(diffY));
                                mouseRotation = new Vector2(MOUSE_ROTATION_SCALE * diffX,
                                                            -MOUSE_ROTATION_SCALE * diffY);
                            }
                        }

                        Mouse.SetPosition(windowWidth / 2, windowHeight / 2);
                        lastMouseX = windowWidth / 2;
                        lastMouseY = windowHeight / 2;
                    }
                    else
                    {
                        lastMouseX = mouseState.X;
                        lastMouseY = mouseState.Y;
                    }
                }
            }
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
#endif
            {
                int xSign = (int)(gamePadState.ThumbSticks.Right.X / Math.Abs(gamePadState.ThumbSticks.Right.X));
                int ySign = (int)(gamePadState.ThumbSticks.Right.Y / Math.Abs(gamePadState.ThumbSticks.Right.Y));

                stickRotation = new Vector2(GAMEPAD_ROTATION_SCALE_X * (gamePadState.ThumbSticks.Right.X * gamePadState.ThumbSticks.Right.X) * xSign,
                                            GAMEPAD_ROTATION_SCALE_Y * (gamePadState.ThumbSticks.Right.Y * gamePadState.ThumbSticks.Right.Y) * ySign);
            }

            // Window out of focus
            return mouseRotation + stickRotation;
        }

        // Get key inputs for object motion
        private Vector2 GetObjectMotion()
        {
            Vector2 motionVector = new Vector2(0.0f, 0.0f);

            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                if (keyboardState.IsKeyDown(Keys.A))
                {
                    motionVector.X = -10.0f;
                }
                else if (keyboardState.IsKeyDown(Keys.D))
                {
                    motionVector.X = 10.0f;
                }

                //Moving
                if (keyboardState.IsKeyDown(Keys.W))
                {
                    motionVector.Y = 10.0f;
                }
                else if (keyboardState.IsKeyDown(Keys.S))
                {
                    motionVector.Y = -10.0f;
                }
                if (playerControllerType == Enums.ControllerType.PC_ONLY)
                {
                    return motionVector;
                }
            }
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                int xSign = (int)(gamePadState.ThumbSticks.Left.X / Math.Abs(gamePadState.ThumbSticks.Left.X));
                int ySign = (int)(gamePadState.ThumbSticks.Left.Y / Math.Abs(gamePadState.ThumbSticks.Left.Y));

                motionVector += new Vector2((gamePadState.ThumbSticks.Left.X * gamePadState.ThumbSticks.Left.X) * xSign,
                                            (gamePadState.ThumbSticks.Left.Y * gamePadState.ThumbSticks.Left.Y) * ySign);

                if (playerControllerType == Enums.ControllerType.XBOX_ONLY)
                {
                    return motionVector;
                }
            }

            return motionVector;
        }

        // Get key input for movement type (hover or walk)
        private bool GetMovementTypeToggle()
        {
            if (movementTypeInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.LeftShift))
                    {
                        movementTypeInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.LeftStick == ButtonState.Pressed)
                    {
                        movementTypeInputReleased = false;
                        return true;
                    }
                }
            }
            else if (gamePadState.Buttons.LeftStick == ButtonState.Released && keyboardState.IsKeyUp(Keys.LeftShift))
            {
                movementTypeInputReleased = true;
            }
            return false;
        }

        // Get key inputs for Attack abilities
        private float GetAttackAmount()
        {
            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
#if !XBOX360
                if (mouseState.LeftButton == ButtonState.Pressed)
                {
                    return 0.5f;
                }
#endif
            }
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                if (gamePadState.Triggers.Right > 0.0f)
                {
                    return gamePadState.Triggers.Right;
                }
            }

            return 0.0f;
        }

        // Get key inputs for Defense mode
        private float GetDefendAmount()
        {
            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
#if !XBOX360
                if (mouseState.RightButton == ButtonState.Pressed)
                {
                    return 0.5f;
                }
#endif
            }
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                if (gamePadState.Triggers.Left > 0.0f)
                {
                    return gamePadState.Triggers.Left;
                }
            }

            return 0.0f;
        }

        // Get key inputs for Element Mode switching
        private Enums.AttackType GetElementModeSwitching(Enums.AttackType current)
        {
            Enums.AttackType elementSwitching = Enums.AttackType.NONE;
            int amount = 0;

            if (modeSwitchInputReleased == true && dpadHorizontalDelayTimer.ElapsedMilliseconds >= 100)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
#if !XBOX360
                    // Use the mousewheel to switch
                    if (Math.Abs(mouseState.ScrollWheelValue - lastMouseWheelPos) >= 200)
                    {
                        amount = (int)((mouseState.ScrollWheelValue - lastMouseWheelPos) / 100.0f);
                        lastMouseWheelPos = mouseState.ScrollWheelValue;
                        dpadHorizontalDelayTimer = Stopwatch.StartNew();
                    }
#endif

                    if (keyboardState.IsKeyDown(Keys.F1) || amount < 0)
                    {
                        if (current == Enums.AttackType.FIRE)
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        else if (current == Enums.AttackType.WATER)
                        {
                            elementSwitching = Enums.AttackType.FIRE;
                        }
                        else if (current == Enums.AttackType.EARTH)
                        {
                            elementSwitching = Enums.AttackType.TERRAIN;
                        }
                        else if (current == Enums.AttackType.WIND)
                        {
                            elementSwitching = Enums.AttackType.WATER;
                        }
                        else if (current == Enums.AttackType.TERRAIN)
                        {
                            elementSwitching = Enums.AttackType.WIND;
                        }
                        else
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        
                        modeSwitchInputReleased = false;
                    }
                    else if (keyboardState.IsKeyDown(Keys.F2) || amount > 0)
                    {
                        if (current == Enums.AttackType.FIRE)
                        {
                            elementSwitching = Enums.AttackType.WATER;
                        }
                        else if (current == Enums.AttackType.WATER)
                        {
                            elementSwitching = Enums.AttackType.WIND;
                        }
                        else if (current == Enums.AttackType.EARTH)
                        {
                            elementSwitching = Enums.AttackType.FIRE;
                        }
                        else if (current == Enums.AttackType.WIND)
                        {
                            elementSwitching = Enums.AttackType.TERRAIN;
                        }
                        else if (current == Enums.AttackType.TERRAIN)
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        else
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        modeSwitchInputReleased = false;
                    } 
                }
                //if we haven't already pressed something in keyboard and gamepad is enabled
                if (modeSwitchInputReleased == true &&
                    (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX))
                {
                    //begin cutting here
                    if (gamePadState.Buttons.A == ButtonState.Pressed || gamePadState.Buttons.X == ButtonState.Pressed)
                    {
                        if (current == Enums.AttackType.FIRE)
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        else if (current == Enums.AttackType.WATER)
                        {
                            elementSwitching = Enums.AttackType.FIRE;
                        }
                        else if (current == Enums.AttackType.EARTH)
                        {
                            elementSwitching = Enums.AttackType.TERRAIN;
                        }
                        else if (current == Enums.AttackType.WIND)
                        {
                            elementSwitching = Enums.AttackType.WATER;
                        }
                        else if (current == Enums.AttackType.TERRAIN)
                        {
                            elementSwitching = Enums.AttackType.WIND;
                        }
                        else
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }

                        modeSwitchInputReleased = false;
                    }
                    else if (gamePadState.Buttons.B == ButtonState.Pressed || gamePadState.Buttons.Y == ButtonState.Pressed)
                    {
                        if (current == Enums.AttackType.FIRE)
                        {
                            elementSwitching = Enums.AttackType.WATER;
                        }
                        else if (current == Enums.AttackType.WATER)
                        {
                            elementSwitching = Enums.AttackType.WIND;
                        }
                        else if (current == Enums.AttackType.EARTH)
                        {
                            elementSwitching = Enums.AttackType.FIRE;
                        }
                        else if (current == Enums.AttackType.WIND)
                        {
                            elementSwitching = Enums.AttackType.TERRAIN;
                        }
                        else if (current == Enums.AttackType.TERRAIN)
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        else
                        {
                            elementSwitching = Enums.AttackType.EARTH;
                        }
                        modeSwitchInputReleased = false;
                    }
                }
            }
            else
            {
                if (gamePadState.Buttons.A == ButtonState.Released &&
                    gamePadState.Buttons.B == ButtonState.Released &&
                    gamePadState.Buttons.X == ButtonState.Released &&
                    gamePadState.Buttons.Y == ButtonState.Released &&
                    keyboardState.IsKeyUp(Keys.F1) &&
                    keyboardState.IsKeyUp(Keys.F2) &&
                    keyboardState.IsKeyUp(Keys.F4) &&
                    keyboardState.IsKeyUp(Keys.F3))
                {
                    modeSwitchInputReleased = true;
                }
            }

            return elementSwitching;
        }

        private float GetZoomAmount()
        {
            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
#if !XBOX360
                if (keyboardState.IsKeyDown(Keys.Z))
                {
                    return 0.1f;
                }
                if (keyboardState.IsKeyDown(Keys.X))
                {
                    return -0.1f;
                }
#endif
            }
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                if (gamePadState.Buttons.X == ButtonState.Pressed)
                {
                    return 0.1f;
                }
                if (gamePadState.Buttons.Y == ButtonState.Pressed)
                {
                    return -0.1f;
                }
            }

            return 0.0f;

        }

        // Size of attack object
        private int GetMassChangeDelta()
        {
            int amount = 0;

            if (dpadHorizontalDelayTimer.ElapsedMilliseconds >= 100)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    // 3 or R: Up 
                    if (keyboardState.IsKeyDown(Keys.D3) || keyboardState.IsKeyDown(Keys.R) || keyboardState.IsKeyDown(Keys.Up))
                    {
                        amount += 5;
                        dpadHorizontalDelayTimer = Stopwatch.StartNew();
                    }
                    // 4 or F: Down
                    else if (keyboardState.IsKeyDown(Keys.D4) || keyboardState.IsKeyDown(Keys.F) || keyboardState.IsKeyDown(Keys.Down))
                    {
                        amount -= 5;
                        dpadHorizontalDelayTimer = Stopwatch.StartNew();
                    }
                }

                // If gamepad is enabled
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    // Up
                    if (gamePadState.DPad.Up == ButtonState.Pressed)
                    {
                        amount += 5;
                        dpadHorizontalDelayTimer = Stopwatch.StartNew();
                    }
                    // Down
                    else if (gamePadState.DPad.Down == ButtonState.Pressed)
                    {
                        amount -= 5;
                        dpadHorizontalDelayTimer = Stopwatch.StartNew();
                    }
                }
            }

            return amount;
        }

        // Temperature of attack object
        private int GetThermalChangeDelta()
        {
            int amount = 0;

            if (dpadVerticalDelayTimer.ElapsedMilliseconds >= 100)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    // 1 or Q: Left
                    if (keyboardState.IsKeyDown(Keys.D1) || keyboardState.IsKeyDown(Keys.Q) || keyboardState.IsKeyDown(Keys.Left))
                    {
                        amount -= 5;
                        dpadVerticalDelayTimer = Stopwatch.StartNew();
                    }
                    // 2 or E: Right
                    else if (keyboardState.IsKeyDown(Keys.D2) || keyboardState.IsKeyDown(Keys.E) || keyboardState.IsKeyDown(Keys.Right))
                    {
                        amount += 5;
                        dpadVerticalDelayTimer = Stopwatch.StartNew();
                    }
                }

                // If gamepad is enabled
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    // Left
                    if (gamePadState.DPad.Left == ButtonState.Pressed)
                    {
                        amount -= 5;
                        dpadVerticalDelayTimer = Stopwatch.StartNew();
                    }
                    // Right
                    else if (gamePadState.DPad.Right == ButtonState.Pressed)
                    {
                        amount += 5;
                        dpadVerticalDelayTimer = Stopwatch.StartNew();
                    }
                }
            }

            return amount;
        }

        // Get key inputs for jumping
        private bool GetJumpKey()
        {
            if (jumpKeyInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Space))
                    {
                        jumpKeyInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.LeftShoulder == ButtonState.Pressed)
                    {
                        jumpKeyInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.Space) && gamePadState.Buttons.LeftShoulder == ButtonState.Released)
            {
                jumpKeyInputReleased = true;
            }

            return false;
        }
        private void SetJumpReleased(bool b)
        {
            jumpKeyInputReleased = b;
        }
        
        //Get GPU-Object Gravity Toggle
        private float GetGPUGravityButton()
        {
            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                Keys[] keys = keyboardState.GetPressedKeys();

                if (keyboardState.IsKeyDown(Keys.J))
                {
                    return -0.1f;
                }
                else if (keyboardState.IsKeyDown(Keys.M))
                {
                    return 0.1f;
                }
            }
            // No Change
            return 0.0f;
        }

        private bool GetMenuLeft()
        {
            if (menuLeftInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Left))
                    {
                        menuLeftInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.DPad.Left == ButtonState.Pressed || gamePadState.ThumbSticks.Left.X < -MENU_ANALOG_THRESHOLD)
                    {
                        menuLeftInputReleased = false;
                        return true;
                    }
                }
            }
            else if (gamePadState.DPad.Left == ButtonState.Released && gamePadState.ThumbSticks.Left.X == 0 && keyboardState.IsKeyUp(Keys.Left))
            {
                menuLeftInputReleased = true;
            }

            return false;
        }
        private bool GetMenuRight()
        {
            if (menuRightInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Right))
                    {
                        menuRightInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.DPad.Right == ButtonState.Pressed || gamePadState.ThumbSticks.Left.X > MENU_ANALOG_THRESHOLD)
                    {
                        menuRightInputReleased = false;
                        return true;
                    }
                }
            }
            else if (gamePadState.DPad.Right == ButtonState.Released && gamePadState.ThumbSticks.Left.X == 0 && keyboardState.IsKeyUp(Keys.Right))
            {
                menuRightInputReleased = true;
            }

            return false;
        }
        private bool GetMenuUp()
        {
            if (menuUpInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Up))
                    {
                        menuUpInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.DPad.Up == ButtonState.Pressed || gamePadState.ThumbSticks.Left.Y > MENU_ANALOG_THRESHOLD)
                    {
                        menuUpInputReleased = false;
                        return true;
                    }
                }
            }
            else if (gamePadState.DPad.Up == ButtonState.Released && gamePadState.ThumbSticks.Left.Y == 0 && keyboardState.IsKeyUp(Keys.Up))
            {
                menuUpInputReleased = true;
            }

            return false;
        }
        private bool GetMenuDown()
        {
            if (menuDownInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Down))
                    {
                        menuDownInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.DPad.Down == ButtonState.Pressed || gamePadState.ThumbSticks.Left.Y < -MENU_ANALOG_THRESHOLD)
                    {
                        menuDownInputReleased = false;
                        return true;
                    }
                }
            }
            else if (gamePadState.DPad.Down == ButtonState.Released && gamePadState.ThumbSticks.Left.Y == 0 && keyboardState.IsKeyUp(Keys.Down))
            {
                menuDownInputReleased = true;
            }

            return false;
        }

        private bool GetStartPressed()
        {
            if (startInputReleased == true && blockStartBackInput == false)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Enter))
                    {
                        startInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.Start == ButtonState.Pressed)
                    {
                        startInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.Enter) && gamePadState.Buttons.Start == ButtonState.Released)
            {
                startInputReleased = true;
            }

            return false;
        }
        private bool GetBackPressed()
        {
            if (backInputReleased == true && blockStartBackInput == false)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Escape))
                    {
                        backInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.Back == ButtonState.Pressed)
                    {
                        backInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.Escape) && gamePadState.Buttons.Back == ButtonState.Released)
            {
                backInputReleased = true;
            }

            return false;
        }

        private bool GetMenuStartPressed()
        {
            if (menuStartInputReleased == true && blockStartBackInput == false)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Enter))
                    {
                        menuStartInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.Start == ButtonState.Pressed || gamePadState.Buttons.A == ButtonState.Pressed)
                    {
                        menuStartInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.Enter) && gamePadState.Buttons.Start == ButtonState.Released
                     && gamePadState.Buttons.A == ButtonState.Released)
            {
                menuStartInputReleased = true;
            }

            return false;
        }
        private bool GetMenuBackPressed()
        {
            if (menuBackInputReleased == true && blockStartBackInput == false)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.Escape))
                    {
                        menuBackInputReleased =false;
                        Statics.SystemSettings.gameState = Enums.EngineState.EXIT;
                        
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.Back == ButtonState.Pressed || gamePadState.Buttons.B == ButtonState.Pressed)
                    {
                        menuBackInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.Escape) && gamePadState.Buttons.Back == ButtonState.Released
                     && gamePadState.Buttons.B == ButtonState.Released)
            {
                menuBackInputReleased = true;
            }

            return false;
        }

        private bool GetAllStartReleased()
        {
            if (keyboardState.IsKeyUp(Keys.Enter) && gamePadState.Buttons.Start == ButtonState.Released
                     && gamePadState.Buttons.A == ButtonState.Released)
            {
                return true;
            }
            return false;
        }
        private bool GetAllBackReleased()
        {
            if (keyboardState.IsKeyUp(Keys.Escape) && gamePadState.Buttons.Back == ButtonState.Released
                     && gamePadState.Buttons.B == ButtonState.Released)
            {
                return true;
            }
            return false;
        }

        private bool GetMenuStartBackReleased()
        {
            return (GetAllBackReleased() && GetAllStartReleased());
        }
        private bool IsStartBackInputBlocked()
        {
            return blockStartBackInput;
        }


        /// <summary>
        /// Set the block start back button input
        /// </summary>
        /// <param name="block">Block or unblock</param>
        public void SetBlockStartBackInput(bool block)
        {
            blockStartBackInput = block;
        }
        /// <summary>
        /// Screen Saver check to see if any button has been pressed
        /// </summary>
        private void AnyButtonPressed()
        {
            if ((modeSwitchInputReleased && attackSwitchInputReleased && jumpKeyInputReleased && zoomInputReleased && fpsKeyInputReleased && consoleKeyInputReleased &&
                 menuUpInputReleased && menuDownInputReleased && menuLeftInputReleased && menuRightInputReleased && startInputReleased && backInputReleased) == false)
            {
                Statics.SystemSettings.screenSaverTimer.Reset();
                Statics.SystemSettings.screenSaverTimer.Start();
            }
        }

        /// <summary>
        /// Get FPS toggle button
        /// </summary>
        /// <returns>True if it has been reset, else false</returns>
        private bool GetFPSToggleButton()
        {
            if (fpsKeyInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.F12))
                    {
                        fpsKeyInputReleased = false;
                        return true;
                    }
                }
                if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (gamePadState.Buttons.LeftStick == ButtonState.Pressed)
                    {
                        fpsKeyInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.F12) && gamePadState.Buttons.LeftStick == ButtonState.Released)
            {
                fpsKeyInputReleased = true;
            }

            return false;
        }

        /// <summary>
        /// Get Compiler Console toggle button
        /// </summary>
        /// <returns>True if it has been reset, else false</returns>
        private bool GetConsoleToggleButton()
        {
            if (consoleKeyInputReleased == true)
            {
                if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
                {
                    if (keyboardState.IsKeyDown(Keys.OemTilde))
                    {
                        consoleKeyInputReleased = false;
                        return true;
                    }
                }
            }
            else if (keyboardState.IsKeyUp(Keys.OemTilde))
            {
                consoleKeyInputReleased = true;
                Statics.SystemSettings.enableCompilerConsole = !Statics.SystemSettings.enableCompilerConsole;

            }

            return false;
        }

        /// <summary>
        /// Gets current key inputs from controllers
        /// </summary>
        /// <param name="lastModeSelected">Last attack mode which was selected</param>
        public void Update(Enums.AttackType lastModeSelected)
        {
#if !XBOX360
            if (playerControllerType == Enums.ControllerType.PC_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                //We don't want to give mouse/keyboard controls when the window is not in focus
                if (Statics.SystemSettings.WINDOW_IN_FOCUS)
                {
                    mouseState = Mouse.GetState();
                    keyboardState = Keyboard.GetState();
                }
            }
#endif
            if (playerControllerType == Enums.ControllerType.XBOX_ONLY || playerControllerType == Enums.ControllerType.PC_AND_XBOX)
            {
                gamePadState = GamePad.GetState(playerControllerIndex);
            }

            // If not overriding the controls, update GameInput
            if (!gameInput.manualOverride)
            {
                // Controller check
                gameInput.gpuGravityButton = GetGPUGravityButton();
                gameInput.playerRotation = GetObjectRotation();
                gameInput.playerMotion = GetObjectMotion();
                gameInput.attackAmount = GetAttackAmount();
                gameInput.defendAmount = GetDefendAmount();
                gameInput.attack = gameInput.attackAmount - gameInput.defendAmount;
                gameInput.gpuGravityButton = GetGPUGravityButton();
                gameInput.zoomAmount = GetZoomAmount();
                gameInput.fpsToggleButton = GetFPSToggleButton();
                gameInput.compilerConsoleButton = GetConsoleToggleButton();

                // Reset screensaver if any buttons pressed
                AnyButtonPressed();

                //Tweak and integrate these two
                // controllerInput.terrainModToggle = playerController.GetTerrainModToggle();
                gameInput.modeSwitch = GetElementModeSwitching(lastModeSelected);
                if (gameInput.modeSwitch == Enums.AttackType.TERRAIN && lastModeSelected != Enums.AttackType.TERRAIN)
                {
                    gameInput.terrainModToggle = true;
                }
                else if (gameInput.modeSwitch == Enums.AttackType.NONE)
                {
                    gameInput.terrainModToggle = false;
                }
                else if (gameInput.modeSwitch != Enums.AttackType.TERRAIN && lastModeSelected == Enums.AttackType.TERRAIN)
                {
                    gameInput.terrainModToggle = true;
                }
                else
                {
                    gameInput.terrainModToggle = false;
                }

                gameInput.movementTypeToggle = GetMovementTypeToggle();

                gameInput.jump = GetJumpKey();
                gameInput.massChangeDelta = GetMassChangeDelta();
                gameInput.thermalChangeDelta = GetThermalChangeDelta();

                if (gameInput.massChangeDelta != 0 || gameInput.thermalChangeDelta != 0)
                {
                    Audio.MenuDPad();
                }
            }

            // Update menu controller
            menuInput.GetMenuLeft = GetMenuLeft();
            menuInput.GetMenuRight = GetMenuRight();
            menuInput.GetMenuUp = GetMenuUp();
            menuInput.GetMenuDown = GetMenuDown();
            menuInput.IsStartBackInputBlocked = IsStartBackInputBlocked();
            menuInput.GetStartPressed = GetStartPressed();
            menuInput.GetBackPressed = GetBackPressed();
            menuInput.GetMenuStartPressed = GetMenuStartPressed();
            menuInput.GetMenuBackPressed = GetMenuBackPressed();
            menuInput.GetAllStartReleased = GetAllStartReleased();
            menuInput.GetAllBackReleased = GetAllBackReleased();
            menuInput.GetMenuStartBackReleased = GetMenuStartBackReleased();

        }

        /// <summary>
        /// Checks to see if a new controller has been plugged in
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        public static void CheckForControllers(ObjectLibrary objectLibrary)
        {
            int index = -1;
            Statics.SystemSettings.TOTAL_PLAYERS = 0;

            for (PlayerIndex i = PlayerIndex.One; i <= PlayerIndex.Four && index + 1 < Statics.GameSettings.numberOfHumansActive; i++)
            {
                index++;
                // Check if our gamepad is connected
                if (GamePad.GetState(i).IsConnected)
                {
                    // This player has not been initialized so increment number of players and create the new player.
                    Statics.SystemSettings.TOTAL_PLAYERS++;
                    Renderer.ResetViewports(Statics.SystemSettings.TOTAL_PLAYERS);
                    DarkWynterGame.playerController = new Controller(Enums.ControllerType.XBOX_ONLY, i);

                    // Initialize the player as alive
                    objectLibrary.humans[index].health = 100;
                    objectLibrary.humans[index].manna = 100;

                }
            }
#if !XBOX360
            // This part is to setup the default keyboard player in case there are no controllers connected
            if (Statics.SystemSettings.TOTAL_PLAYERS == 0)
            {
                // We have one player the keyboard player
                Statics.SystemSettings.TOTAL_PLAYERS++;

                // Create the player, PlayerIndex.One is passed as a default value and not used
                Renderer.ResetViewports(Statics.SystemSettings.TOTAL_PLAYERS);

                // If we are player 1 then we also have pc controls
                DarkWynterGame.playerController = new Controller(Enums.ControllerType.PC_ONLY, PlayerIndex.One);
                // Initialize the player as alive
                objectLibrary.humans[0].health = 100;
                objectLibrary.humans[0].manna = 100;
            }
            // If Player 1 has a controller make sure they are given the keyboard too
            else if (Statics.SystemSettings.TOTAL_PLAYERS >= 1)
            {
                if (DarkWynterGame.playerController.playerControllerType == Enums.ControllerType.XBOX_ONLY)
                {
                    DarkWynterGame.playerController = new Controller(Enums.ControllerType.PC_AND_XBOX, PlayerIndex.One);
                }
                else if (DarkWynterGame.playerController.playerControllerType == Enums.ControllerType.NONE)
                {
                    // Create the player, PlayerIndex.One is passed as a default value and not used
                    Renderer.ResetViewports(Statics.SystemSettings.TOTAL_PLAYERS);

                    // If we are player 1 then we also have pc controls
                    DarkWynterGame.playerController = new Controller(Enums.ControllerType.PC_ONLY, PlayerIndex.One);
                    // Initialize the player as alive
                    objectLibrary.humans[0].health = 100;
                    objectLibrary.humans[0].manna = 100;
                }
            }
#endif
        }

        /// <summary>
        /// Reset mouse after game returns from Pause
        /// </summary>
        public void ResetMouse()
        {
            //set the mouse cursor to the middle again and set last position
#if !XBOX360
            Mouse.SetPosition(windowWidth / 2, windowHeight / 2);
            lastMouseX = windowWidth / 2;
            lastMouseY = windowHeight / 2;
#endif
        }

        /// <summary>
        /// Kills the rumble on all controllers
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        public static void StopRumble(ObjectLibrary objectLibrary)
        {
            if (objectLibrary != null && objectLibrary.humans != null && objectLibrary.bots != null)
            {
                for (int i = 0; i < objectLibrary.humans.Count; i++)
                {
                    if (objectLibrary.humans[i] != null)
                    {
                        objectLibrary.humans[i].StopRumble();
                    }
                }

            }
        }        
    }
}