//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="MenuSystem.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {License Information: Creative Commons}
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace ElementalGame
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    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;
    using System.Threading;
    using System.Xml;
    #endregion

    public class MenuSystem
    {
        public TitleScreen titleScreen;                        // Idle Screen
        public ControlsScreen controlsScreen;
        public GameSetup gameSetup;
        public LevelSetup levelSetup;
        public PlayerSetup playerSetup;
        public GameOverScreen gameOverScreen;
        public PauseScreen pauseScreen;
        public LoadingScreen loadScreen;
        public SorryScreen sorryScreen;
        public ConfirmExitScreen confirmExitScreen;
        public CreditsScreen creditsScreen;
        
        public Scene1 scene1;
        public Scene2 scene2;
        public Scene3 scene3;
        public Scene4 scene4;
        public Scene5 scene5;

        public Texture2D storyModeTexture;
        public Texture2D deathMatchTexture;
        public Texture2D survivalTexture;
        public Texture2D lastmanTexture;

        public int playerNumber = 0;

        private int currentLevelIter = 0;

        private int currentPlayerIter = -1;

        private struct DirectionInput
        {
            public bool menuUp;
            public bool menuDown;
            public bool menuLeft;
            public bool menuRight;
        }

        public static volatile bool TERRAIN_DEMO_DONE = true;
        private Effect effect;
        private Texture2D whiteTexture;

        public MenuSystem()
        {
            titleScreen = new TitleScreen();                        // Idle Screen
            controlsScreen = new ControlsScreen();
            gameSetup = new GameSetup();
            levelSetup = new LevelSetup();
            playerSetup = new PlayerSetup();
            gameOverScreen = new GameOverScreen();
            pauseScreen = new PauseScreen();
            loadScreen = new LoadingScreen();
            sorryScreen = new SorryScreen();
            confirmExitScreen = new ConfirmExitScreen();
            creditsScreen = new CreditsScreen();

            scene1 = new Scene1();
            scene2 = new Scene2();
            scene3 = new Scene3();
            scene4 = new Scene4();
            scene5 = new Scene5();

            effect = ElementalGame.content.Load<Effect>("Shaders/ElementalGPU");
            whiteTexture = ElementalGame.content.Load<Texture2D>("_textures/whitesquare");
        }

        public void CheckMenuChange(GraphicsDeviceManager graphics, 
                                    ContentManager content, 
                                    GameController Player1Controller, 
                                    GameFlow gameFlow)
        {
            // This was for threading the terrain load but its fast enough now
            // If thread is null
            //if (loadTerrainThread == null)
            //{
            //    //loadTerrainThread = new Thread(new ParameterizedThreadStart(gameFlow.LoadTerrainDemo));
            //    TERRAIN_DEMO_DONE = true;
            //}
            // Update Controller Input
            Player1Controller.UpdateControllers();

            DirectionInput input = new DirectionInput();

            input.menuUp = Player1Controller.GetMenuUp();
            input.menuDown = Player1Controller.GetMenuDown();
            input.menuLeft = Player1Controller.GetMenuLeft();
            input.menuRight = Player1Controller.GetMenuRight();

            // Check if the FPS counter was toggled
            if (Player1Controller.GetFPSToggleButton())
            {
                ElementalGame.enableFPSDisplay = !ElementalGame.enableFPSDisplay;
            }

            if (ElementalGame.gameState == ElementalGame.GameState.NOT_SUPPORTED)
            {
                //just check for quit
                if (Player1Controller.GetBackPressed())
                {
                    // Exit 
                    Audio.MenuBack();           // Play a sound
                    ElementalGame.gameState = ElementalGame.GameState.EXIT;                // Exit
                }
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.CONTROL_SCREEN)
            {
                CheckControlsScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.GAME_OVER)
            {
                CheckEndGameScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.GAME_PAUSE)
            {
                CheckPauseScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.GAME_SETUP)
            {
                CheckGameSetupScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.PLAYER_SETUP)
            {
                CheckPlayerSetupScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.LEVEL_SETUP)
            {
                CheckLevelSetupScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.TITLE_SCREEN)
            {
                CheckTitleScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.CONFIRM_EXIT)
            {
                CheckConfirmExitScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.CREDITS)
            {
                CheckCreditsScreen(graphics, content, Player1Controller, gameFlow, input);
            }
            else if (ElementalGame.gameState == ElementalGame.GameState.GAME_MODE)
            {
                CheckGameModeScreen(graphics, content, Player1Controller, gameFlow, input);
            }
        }

        private void CheckControlsScreen(GraphicsDeviceManager graphics,
                                ContentManager content,
                                GameController Player1Controller,
                                GameFlow gameFlow,
                                DirectionInput input)
        {
            // Exit 
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();           // Play a sound
                ElementalGame.gameState = ElementalGame.GameState.TITLE_SCREEN;                // Exit
                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }

            // Start
            if (Player1Controller.GetMenuStartPressed())
            {
                // Play a sound
                //Audio.PlayTitleSong();

                // Load Player Demo
                //gameFlow.objectLibrary = new ObjectLibrary(XML.SystemSettings.MAX_HUMANS);
                gameFlow.objectLibrary.LoadDarkMatter();
                gameFlow.objectLibrary.LoadMatter();

                // Switch Menus
                ElementalGame.gameState = ElementalGame.GameState.GAME_SETUP;
                Logging.addEventString("Starting game past intro");

                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }
            Player1Controller.AnyButtonPressed();
        }

        private void CheckConfirmExitScreen(GraphicsDeviceManager graphics, 
                                            ContentManager content, 
                                            GameController Player1Controller, 
                                            GameFlow gameFlow, 
                                            DirectionInput input)
        {
            // CONFIRM EXIT SCREEN ------------------------------------
            // Exit 
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();           // Play a sound
                ElementalGame.gameState = ElementalGame.GameState.CREDITS;
            }

            // Start
            else if (Player1Controller.GetMenuStartPressed())
            {
                // Play a sound
                Audio.MenuStart();
                ElementalGame.gameState = ElementalGame.GameState.TITLE_SCREEN;
                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }
        }

        private void CheckCreditsScreen(GraphicsDeviceManager graphics, 
                                        ContentManager content, 
                                        GameController Player1Controller, 
                                        GameFlow gameFlow, 
                                        DirectionInput input)
        {
            // CREDITS SCREEN ------------------------------------
            // Exit 
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();           // Play a sound
                ElementalGame.gameState = ElementalGame.GameState.EXIT;
            }
        }

        private void CheckTitleScreen(GraphicsDeviceManager graphics, 
                                      ContentManager content, 
                                      GameController Player1Controller, 
                                      GameFlow gameFlow, 
                                      DirectionInput input)
        {
            // TITLE SCREEN ------------------------------------
            // Exit 
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();           // Play a sound
                ElementalGame.gameState = ElementalGame.GameState.CONFIRM_EXIT;                // Exit

                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }

            // Start
            else if (Player1Controller.GetMenuStartPressed())
            {
                // Show controls
                ElementalGame.gameState = ElementalGame.GameState.CONTROL_SCREEN;

                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }
            Player1Controller.AnyButtonPressed();
        }

        private void CheckGameSetupScreen(GraphicsDeviceManager graphics,
                                          ContentManager content,
                                          GameController Player1Controller,
                                          GameFlow gameFlow,
                                          DirectionInput input)
        {
            if (Player1Controller.IsStartBackInputBlocked())
            {
                if (Player1Controller.GetMenuStartBackReleased() == true)
                {
                    Player1Controller.SetBlockStartBackInput(false);
                }
            }

            int numControllersBefore = XML.SystemSettings.TOTAL_PLAYERS;
            //reset the controllers for all players.. start over
            gameFlow.objectLibrary.DeinitializeHumans();
            //load the number of gamepads connected to set default # players
            ElementalGame.CheckForControllers(4, gameFlow);

            if (XML.SystemSettings.TOTAL_PLAYERS != numControllersBefore)
            {
                ((GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("# Players:")).SetRange(1, XML.SystemSettings.TOTAL_PLAYERS);
                ((GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("# Players:")).SetValue(XML.SystemSettings.TOTAL_PLAYERS);
            }

            // Load Game ------------------------------------
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();                       // Play a sound
                ElementalGame.gameState = ElementalGame.GameState.TITLE_SCREEN;      // Switch Modes
                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }

            else if (Player1Controller.GetMenuStartPressed())
            {
                // Play a sound
                Audio.MenuStart();

                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();

                // Load Game Data
                GameSetupCommit(gameFlow.objectLibrary);
                gameFlow.LoadGame();

                XML.LoadLevelIndex();

                //If story mode we don't need Level select
                if (GameFlow.gameType == GameFlow.GameType.STORY_MODE)
                {
                    // Load next CutScene
                    GameRules.storyElement = GameRules.StoryElement.CUTSCENE;

                    // Clear keys
                    gameFlow.objectLibrary.humans[0].numberOfKeysFound = 0;

                    // --------------------  START CUTSCENES HERE -------------------------
                    scene1 = new Scene1();
                    scene2 = new Scene2();
                    scene3 = new Scene3();
                    scene4 = new Scene4();
                    scene5 = new Scene5();

                    Audio.PlayLevelSong("Scene1");
                    scene1.StartCutScene();
                    ElementalGame.gameState = ElementalGame.GameState.GAME_MODE;
                }
                else
                {
                    // Load Terrain Demo
                    levelSetup.GetMapNameLabel().SetTitle("Map: " + XML.levelInfo[currentLevelIter].name);
                    levelSetup.GetDescriptionLabel().SetTitle(XML.levelInfo[currentLevelIter].description);
                    gameFlow.LoadTerrainDemo(XML.levelInfo[currentLevelIter].filepath);//graphics, levelInfo[currentLevelIter].filepath, content);

                    // Switch modes
                    ElementalGame.gameState = ElementalGame.GameState.LEVEL_SETUP;
                }
            }

            // If they pressed Up then get the previous element
            else if (input.menuUp)
            {
                Audio.MenuUp();
                gameSetup.GetMenu().PreviousMenuElement();
            }
            // Or if they pressed down, get the next one
            else if (input.menuDown)
            {
                Audio.MenuDown();
                gameSetup.GetMenu().NextMenuElement();
            }
            else if (input.menuLeft)
            {
                CheckMenuDirectionals(gameSetup.GetMenu().GetActiveMenuElement(), gameFlow, input);
            }
            else if (input.menuRight)
            {
                CheckMenuDirectionals(gameSetup.GetMenu().GetActiveMenuElement(), gameFlow, input);
            }
            if (gameSetup.GetMenu().GetActiveMenuElement().GetTitle() == "Game type:")
            {
                GameMenuOption option = (GameMenuOption)gameSetup.GetMenu().GetActiveMenuElement();
                //need to change the settings depending on what is available here

                if (option.GetActiveOption() == "Story Mode")
                {
                    gameSetup.GetMenu().GetMenuElement("# Players:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Max kills:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Difficulty:").Show();
                    gameSetup.GetMenu().GetMenuElement("Bots:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Bot intelligence:").Show();
                    gameSetup.SetBackground(storyModeTexture);
                }

                else if (option.GetActiveOption() == "Last man standing")
                {
                    gameSetup.GetMenu().GetMenuElement("# Players:").Show();
                    gameSetup.GetMenu().GetMenuElement("Max kills:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Difficulty:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Bots:").Show();
                    gameSetup.GetMenu().GetMenuElement("Bot intelligence:").Show();
                    gameSetup.SetBackground(lastmanTexture);
                }
                else if (option.GetActiveOption() == "Deathmatch")
                {
                    gameSetup.GetMenu().GetMenuElement("# Players:").Show();
                    gameSetup.GetMenu().GetMenuElement("Max kills:").Show();
                    gameSetup.GetMenu().GetMenuElement("Difficulty:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Bots:").Show();
                    gameSetup.GetMenu().GetMenuElement("Bot intelligence:").Show();
                    gameSetup.SetBackground(deathMatchTexture);
                }
                else if (option.GetActiveOption() == "Survival")
                {
                    gameSetup.GetMenu().GetMenuElement("# Players:").Show();
                    gameSetup.GetMenu().GetMenuElement("Max kills:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Difficulty:").Show();
                    gameSetup.GetMenu().GetMenuElement("Bots:").Hide();
                    gameSetup.GetMenu().GetMenuElement("Bot intelligence:").Show();
                    gameSetup.SetBackground(survivalTexture);
                }
            }

            Player1Controller.AnyButtonPressed();
        }

        private void CheckLevelSetupScreen(GraphicsDeviceManager graphics,
                                           ContentManager content,
                                           GameController Player1Controller,
                                           GameFlow gameFlow,
                                           DirectionInput input)
        {
            if (Player1Controller.IsStartBackInputBlocked())
            {
                if (Player1Controller.GetMenuStartBackReleased() == true)
                {
                    Player1Controller.SetBlockStartBackInput(false);
                }
            }

            // Load Level ------------------------------------
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();
                ElementalGame.gameState = ElementalGame.GameState.GAME_SETUP;
                ElementalGame.loadDarkMatter = true;
            }

            else if (Player1Controller.GetMenuStartPressed())
            {
                Audio.MenuStart();
                //Set it to load mode
                ElementalGame.gameState = ElementalGame.GameState.LOAD_LEVEL;
                ElementalGame.drewLoadScreen = false;
            }
            // If they pressed Up then get the previous element
            else if (input.menuUp)
            {
                Audio.MenuUp();

                currentLevelIter--;
                if (currentLevelIter < 0)
                {
                    currentLevelIter = XML.levelInfo.Count - 1;
                }
                levelSetup.GetMapNameLabel().SetTitle("Map: " + XML.levelInfo[currentLevelIter].name);
                levelSetup.GetDescriptionLabel().SetTitle(XML.levelInfo[currentLevelIter].description);
                //Highlight the right glyph
                ((GameMenuImageScroller)levelSetup.GetDisplayMenu().GetMenuElement(0)).PreviousItem();
 
                if (TERRAIN_DEMO_DONE == false)
                {
                    //must first stop thread.. 
                    //loadTerrainThread.Abort();
                    //while (loadTerrainThread.IsAlive) ;
                }
                gameFlow.LoadTerrainDemo(XML.levelInfo[currentLevelIter].filepath);//graphics, levelInfo[currentLevelIter].filepath, content);
            }
            // Or if they pressed down, get the next one
            else if (input.menuDown)
            {
                Audio.MenuDown();

                currentLevelIter++;
                if (currentLevelIter > XML.levelInfo.Count - 1)
                {
                    currentLevelIter = 0;
                }
                levelSetup.GetMapNameLabel().SetTitle("Map: " + XML.levelInfo[currentLevelIter].name);
                levelSetup.GetDescriptionLabel().SetTitle(XML.levelInfo[currentLevelIter].description);
                ((GameMenuImageScroller)levelSetup.GetDisplayMenu().GetMenuElement(0)).NextItem();
                gameFlow.LoadTerrainDemo(XML.levelInfo[currentLevelIter].filepath);//raphics, levelInfo[currentLevelIter].filepath, content);
            }
        }

        private void CheckPlayerSetupScreen(GraphicsDeviceManager graphics,
                                            ContentManager content,
                                            GameController Player1Controller,
                                            GameFlow gameFlow,
                                            DirectionInput input)
        {
            // Load Player ------------------------------------
            if (playerNumber < XML.SystemSettings.TOTAL_PLAYERS)
            {
                GameController controller = gameFlow.objectLibrary.humans[playerNumber].playerController;
                controller.UpdateControllers();

                if (controller.IsStartBackInputBlocked())
                {
                    if (controller.GetMenuStartPressed() == false && controller.GetMenuBackPressed() == false)
                    {
                        if (controller.GetMenuStartBackReleased() == true)
                        {
                            controller.SetBlockStartBackInput(false);
                        }
                    }
                }

                input.menuUp = controller.GetMenuUp();
                input.menuDown = controller.GetMenuDown();
                input.menuLeft = controller.GetMenuLeft();
                input.menuRight = controller.GetMenuRight();

                if (controller.GetMenuBackPressed())
                {
                    Audio.MenuBack();                                                   // Play a sound
                    ElementalGame.gameState = ElementalGame.GameState.GAME_SETUP;      // Switch Modes
                }
                else if (controller.GetMenuStartPressed() && !controller.IsStartBackInputBlocked())
                {
                    // Play a sound
                    Audio.MenuUp();

                    controller.SetBlockStartBackInput(true);

                    // Load Player Data
                    PlayerSetupCommit(gameFlow.objectLibrary, playerNumber);
                }
                else if (input.menuLeft)
                {
                    Audio.MenuPlayerShuffleLeft();
                    CheckMenuDirectionals(playerSetup.GetMenu().GetActiveMenuElement(), gameFlow, input);

                    GameMenuImageScroller scroller = (GameMenuImageScroller)playerSetup.GetMenu().GetMenuElement(0);

                    currentPlayerIter = scroller.GetActiveIndex();
                    if (currentPlayerIter >= 0)
                    {
                        gameFlow.objectLibrary.humans[playerNumber].LoadPlayer(XML.playerInfo[currentPlayerIter]);
                    }
                    playerSetup.GetDiagnosisDisplay().RandomIndex();
                    
                }
                else if (input.menuRight)
                {
                    Audio.MenuPlayerShuffleRight();
                    CheckMenuDirectionals(playerSetup.GetMenu().GetActiveMenuElement(), gameFlow, input);

                    GameMenuImageScroller scroller = (GameMenuImageScroller)playerSetup.GetMenu().GetMenuElement(0);

                    currentPlayerIter = scroller.GetActiveIndex();

                    if (currentPlayerIter < XML.playerInfo.Count)
                    {
                        gameFlow.objectLibrary.humans[playerNumber].LoadPlayer(XML.playerInfo[currentPlayerIter]);
                    }
                    playerSetup.GetDiagnosisDisplay().RandomIndex();
                }
            }
        }

        private void CheckGameModeScreen(GraphicsDeviceManager graphics,
                                         ContentManager content,
                                         GameController Player1Controller,
                                         GameFlow gameFlow,
                                         DirectionInput input)
        {
            // if NOT in a cutscene
            if (GameFlow.gameType == GameFlow.GameType.STORY_MODE)
            {
                if (GameRules.storyElement == GameRules.StoryElement.CUTSCENE)
                {
                    if (Player1Controller.GetSkipButton())
                    {
                        //skip it 
                        if (GameRules.cutSceneIndex == 0)
                        {
                            scene1.Skip();
                        }
                        if (GameRules.cutSceneIndex == 1)
                        {
                            scene2.Skip();
                        }
                        if (GameRules.cutSceneIndex == 2)
                        {
                            scene3.Skip();
                        }
                        if (GameRules.cutSceneIndex == 3)
                        {
                            scene4.Skip();
                        }
                        if (GameRules.cutSceneIndex == 4)
                        {
                            scene5.Skip();
                        }
                    }
                    //don't run the rest
                    return;
                }
            }

            // GAME MODE ------------------------------------
            if (Player1Controller.IsStartBackInputBlocked())
            {
                if (Player1Controller.GetMenuStartBackReleased() == true)
                {
                    Player1Controller.SetBlockStartBackInput(false);
                }
            }
            for (int i = 0; i < gameFlow.objectLibrary.humans.Count; i++)
            {
                GameController controller = gameFlow.objectLibrary.humans[i].playerController;
                controller.UpdateControllers();

                if (controller.IsStartBackInputBlocked())
                {
                    if (controller.GetMenuStartPressed() == false && controller.GetMenuBackPressed() == false)
                    {
                        if (controller.GetMenuStartBackReleased() == true)
                        {
                            controller.SetBlockStartBackInput(false);
                        }
                    }
                }

                // If in game and user presses back
                if (controller.GetBackPressed())
                {
                    gameFlow.StopAllSoundsAndRumble();
                    Player1Controller.SetBlockStartBackInput(true);

                    Audio.MenuBack();
                    Audio.PlayTitleSong();

                    ElementalGame.gameState = ElementalGame.GameState.GAME_SETUP;

                    ElementalGame.jiggler.Reset();
                    ElementalGame.jiggler.Start();
                }
                else if (controller.GetStartPressed() && !controller.IsStartBackInputBlocked())
                {
                    Audio.MenuStart();
                    //Pause the game
                    ElementalGame.gameState = ElementalGame.GameState.GAME_PAUSE;
                    ElementalGame.playerThatPaused = i;
                    pauseScreen.SetPlayerOptions(gameFlow.objectLibrary.humans[i]);

                    ElementalGame.jiggler.Reset();
                    ElementalGame.jiggler.Start();
                }
            }
        }

        private void CheckPauseScreen(GraphicsDeviceManager graphics,
                                      ContentManager content,
                                      GameController Player1Controller,
                                      GameFlow gameFlow,
                                      DirectionInput input)
        {
            // GAME PAUSE -----------------------------------
            GameController controller = gameFlow.objectLibrary.humans[ElementalGame.playerThatPaused].playerController;
            controller.UpdateControllers();
            input.menuUp = controller.GetMenuUp();
            input.menuDown = controller.GetMenuDown();
            input.menuLeft = controller.GetMenuLeft();
            input.menuRight = controller.GetMenuRight();


            if (controller.GetStartPressed())
            {
                Audio.MenuStart();
                //Commit menu changes
                PauseMenuCommit(gameFlow.objectLibrary, ElementalGame.playerThatPaused);

                //Resume the game
                ElementalGame.gameState = ElementalGame.GameState.GAME_MODE;
                ElementalGame.playerThatPaused = -1;

                //reset mouse cursor
                controller.JustUnPaused();
                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }
            // If they pressed Up then get the previous element
            else if (input.menuUp)
            {
                Audio.MenuUp();
                pauseScreen.GetPlayerPauseMenu().PreviousMenuElement();
            }
            // Or if they pressed down, get the next one
            else if (input.menuDown)
            {
                Audio.MenuDown();
                pauseScreen.GetPlayerPauseMenu().NextMenuElement();
            }
            else if (input.menuLeft)
            {
                CheckMenuDirectionals(pauseScreen.GetPlayerPauseMenu().GetActiveMenuElement(), gameFlow, input);
            }
            else if (input.menuRight)
            {
                CheckMenuDirectionals(pauseScreen.GetPlayerPauseMenu().GetActiveMenuElement(), gameFlow, input);
            }

            controller.AnyButtonPressed();
        }

        private void CheckEndGameScreen(GraphicsDeviceManager graphics,
                                        ContentManager content,
                                        GameController Player1Controller,
                                        GameFlow gameFlow,
                                        DirectionInput input)
        {
            // GAME OVER ------------------------------------
            // Wait for input and go back to title
            if (Player1Controller.GetMenuStartPressed())
            {
                Audio.PlayTitleSong();
                ElementalGame.gameState = ElementalGame.GameState.GAME_SETUP;

                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }

            // If the player presses back they can quit here
            if (Player1Controller.GetMenuBackPressed())
            {
                Audio.MenuBack();
                ElementalGame.gameState = ElementalGame.GameState.TITLE_SCREEN;
                ElementalGame.jiggler.Reset();
                ElementalGame.jiggler.Start();
            }
            else if (input.menuUp)
            {
            }
            else if (input.menuDown)
            {
            }
            else if (input.menuLeft)
            {
            }
            else if (input.menuRight)
            {
            }
        }

        private void CheckMenuDirectionals(GameMenuElement activeElement, GameFlow gameFlow, DirectionInput input)
        {
            // OptionBox
            if (activeElement.GetElementType() == MenuElementType.OPTION)
            {
                // Cast as option and change value
                GameMenuOption option = (GameMenuOption)activeElement;
                // If they pressed left, get previous option
                if (input.menuLeft)
                {
                    Audio.MenuLeft();
                    option.PreviousOption();
                }
                // Or if they pressed right, get next option
                else if (input.menuRight)
                {
                    Audio.MenuRight();
                    option.NextOption();
                }
            }

            // ValueSlider
            else if (activeElement.GetElementType() == MenuElementType.VALUE)
            {
                // Cast as ValueInput type and change value
                GameMenuValueInput valueInput = (GameMenuValueInput)activeElement;
                //int activeIndex = playerSetup.GetMenu().GetActiveIndex();

                // If they pressed left, decrease the value
                if (input.menuLeft)
                {
                    Audio.MenuLeft();
                    valueInput.Decrement();
                }
                // Or if they pressed right, increase it
                else if(input.menuRight)
                {
                    Audio.MenuRight();
                    valueInput.Increment();
                }
            }

            else if (activeElement.GetElementType() == MenuElementType.IMAGE_SCROLL)
            {
                // Cast as ValueInput type and change value
                GameMenuImageScroller scroller = (GameMenuImageScroller)activeElement;
                //int activeIndex = playerSetup.GetMenu().GetActiveIndex();

                // If they pressed left, decrease the value
                if (input.menuLeft)
                {
                    Audio.MenuLeft();
                    scroller.PreviousItem();
                }
                // Or if they pressed right, increase it
                else if (input.menuRight)
                {
                    Audio.MenuRight();
                    scroller.NextItem();
                }
            }
        }

        private void GameSetupCommit(ObjectLibrary objectLibrary)
        {
            GameMenuOption option;      // Text Option
            GameMenuValueInput value;   // Numeric Option

            // Number of players that will play
            value = (GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("# Players:");
            GameFlow.numberOfHumansActive = value.GetValue();

            // Game type selection
            option = (GameMenuOption)gameSetup.GetMenu().GetMenuElement("Game type:");

            if (option.GetActiveOption() == "Story Mode")
            {
                GameFlow.gameType = GameFlow.GameType.STORY_MODE;
            }
            else if (option.GetActiveOption() == "Last man standing")
            {
                GameFlow.gameType = GameFlow.GameType.LAST_MAN_STANDING;
            }
            else if (option.GetActiveOption() == "Deathmatch")
            {
                GameFlow.gameType = GameFlow.GameType.POINT_DEATHMATCH;
            }
            else if (option.GetActiveOption() == "Survival")
            {
                GameFlow.gameType = GameFlow.GameType.SURVIVAL;
            }
            // Max number of kills to win
            value = (GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("Max kills:");
            GameFlow.maxNumberOfKills = value.GetValue();

            // Number of AI Bots
            if (option.GetActiveOption() != "Survival" && option.GetActiveOption() != "Story Mode")
            {
                value = (GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("Bots:");
                GameFlow.numberOfBots = value.GetValue();
            }
            else
            {
                string difficultyLevel = ((GameMenuOption)gameSetup.GetMenu().GetMenuElement("Difficulty:")).GetActiveOption();
                if (difficultyLevel == "Lamer")
                {
                    GameFlow.numberOfBots = 3;
                }
                else if (difficultyLevel == "Average Joe")
                {
                    GameFlow.numberOfBots = 6;
                }
                else if (difficultyLevel == "Uber Mental")
                {
                    GameFlow.numberOfBots = 10;
                }
            }
            // Bot intelligence (1= dumb, 10= super smart)
            value = (GameMenuValueInput)gameSetup.GetMenu().GetMenuElement("Bot intelligence:");
            GameFlow.botIntelligence = value.GetValue();
        }

        public void LevelSetupCommit(ObjectLibrary objectLibrary)
        {
            objectLibrary.currentLevelXmlFile = XML.levelInfo[currentLevelIter].filepath;
        }

        private void PauseMenuCommit(ObjectLibrary objectLibrary, int playerIndex)
        {
            GameMenuOption option;      // Text Option

            // Player controller setup
            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Invert rotation");
            if (option.GetActiveOption() == "Yes")
            {
                objectLibrary.humans[playerIndex].controlsInverted = true;
            }
            else
            {
                objectLibrary.humans[playerIndex].controlsInverted = false;
            }

            // Player rumble
            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Rumble");
            if (option.GetActiveOption() == "Yes")
            {
                objectLibrary.humans[playerIndex].rumbleEnabled = true;
            }
            else
            {
                objectLibrary.humans[playerIndex].rumbleEnabled = false;
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("ShadowMap1");
            if (option.GetActiveOption() == "Yes")
            {
                XML.SystemSettings.enableShadowMap1 = true;
            }
            else
            {
                XML.SystemSettings.enableShadowMap1 = false;
                ShaderParameters.shadowTexture1.SetValue(whiteTexture);
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("ShadowMap2");
            if (option.GetActiveOption() == "Yes")
            {
                XML.SystemSettings.enableShadowMap2 = true;
            }
            else
            {
                XML.SystemSettings.enableShadowMap2 = false;
                ShaderParameters.shadowTexture2.SetValue(whiteTexture);
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Terrain Bump Mapping");
            if (option.GetActiveOption() == "Yes")
            {
                XML.SystemSettings.enableTerrainBumpMapping = true;
            }
            else
            {
                XML.SystemSettings.enableTerrainBumpMapping = false;
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Terrain Multi-Texturing");
            if (option.GetActiveOption() == "Yes")
            {
                XML.SystemSettings.enableTerrainMultiTexturing = true;
            }
            else
            {
                XML.SystemSettings.enableTerrainMultiTexturing = false;
            }

            //option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Number Of Terrain Textures");
            //if (option.GetActiveOption() == "4")
            //{
            //    ElementalGame.numberOfTerrainTextures = 4;
            //}
            //else if (option.GetActiveOption() == "3")
            //{
            //    ElementalGame.numberOfTerrainTextures = 3;
            //}
            //else
            //{
            //    ElementalGame.numberOfTerrainTextures = 2;
            //}

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Light Sources");
            if (option.GetActiveOption() == "1")
            {
                XML.SystemSettings.singleLightSource = true;
                option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("ShadowMap2");
                option.NextOption();
                //ElementalGame.enableShadowMap2 = false;
            }
            else
            {
                XML.SystemSettings.singleLightSource = false;
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Music");
            if (option.GetActiveOption() == "On")
            {
                XML.SystemSettings.music = true;
            }
            else
            {
                XML.SystemSettings.music = false;
            }

            option = (GameMenuOption)pauseScreen.GetPlayerPauseMenu().GetMenuElement("Sound Effects");
            if (option.GetActiveOption() == "On")
            {
                XML.SystemSettings.soundFX = true;
            }
            else
            {
                XML.SystemSettings.soundFX = false;
            }
        }

        private void PlayerSetupCommit(ObjectLibrary objectLibrary, int playerIndex)
        {
            switch (playerIndex)
            {
                case 0:
                    {
                        // Player 1 Color Select
                        objectLibrary.humans[0].SetDiffuseRed(255);
                        objectLibrary.humans[0].SetDiffuseGreen(255);
                        objectLibrary.humans[0].SetDiffuseBlue(255);
                        objectLibrary.humans[0].SetDiffuseAlpha(255);
                        playerSetup.GetMenu().SetTitle("Player 2");
                        break;
                    }
                case 1:
                    {
                        // Player 2 Color Select
                        objectLibrary.humans[1].SetDiffuseRed(255);
                        objectLibrary.humans[1].SetDiffuseGreen(255);
                        objectLibrary.humans[1].SetDiffuseBlue(255);
                        objectLibrary.humans[1].SetDiffuseAlpha(255);
                        playerSetup.GetMenu().SetTitle("Player 3");
                        break;
                    }
                case 2:
                    {
                        // Player 3 Color Select
                        objectLibrary.humans[2].SetDiffuseRed(255);
                        objectLibrary.humans[2].SetDiffuseGreen(255);
                        objectLibrary.humans[2].SetDiffuseBlue(255);
                        objectLibrary.humans[2].SetDiffuseAlpha(255);
                        playerSetup.GetMenu().SetTitle("Player 4");
                        break;
                    }
                case 3:
                    {
                        // Player 4 Color Select
                        objectLibrary.humans[3].SetDiffuseRed(255);
                        objectLibrary.humans[3].SetDiffuseGreen(255);
                        objectLibrary.humans[3].SetDiffuseBlue(255);
                        objectLibrary.humans[3].SetDiffuseAlpha(255);
                        break;
                    }
            }

            // Player Character Select
            if (playerNumber < XML.SystemSettings.TOTAL_PLAYERS - 1)
            {
                playerNumber++;
                ElementalGame.currentPlayerIndex = playerNumber;
                playerSetup.GetPlayerSelection().SetCurrentIndex(0);
            }
            else
            {
                ElementalGame.gameState = ElementalGame.GameState.GAME_MODE;
                

                playerNumber = 0;
                ElementalGame.currentPlayerIndex = playerNumber;

                playerSetup.GetMenu().SetTitle("Player 1");
            }
        }
    }
}