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

namespace DarkWynter.Engine.Menus
{
    #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

    using Audio;
    using Globals;
    using ObjectLib;
    using Controllers;
    using Utilities;
    using Menus;
    using DarkWynter.Stream;
    using DarkWynter.Engine.Menus.GameScreens;
    using DarkWynter.Stream.UIInterfacing;
    using System.ComponentModel;
    using System.Windows.Forms;

    /// <summary>
    /// Controls all of the menu screen and menu items
    /// </summary>
    public class MenuSystem
    {

        private Color _backColor = Color.TransparentBlack;
        public Color backColor { get { return _backColor; } set { _backColor = value; } }

        /// <summary>
        ///  Screen Saver Shader
        /// </summary>
        private ScreenSaver screenSaver;


        /// <summary>
        /// List of menu screens
        /// </summary>
        public List<GameScreen> gameScreens = new List<GameScreen>();
        public List<GameScreen> _gameScreens { get { return gameScreens; } set { gameScreens = value; } }
        /// <summary>
        /// Holds the menu state string for the menu system
        /// </summary>
        public static string menuState;

        /// <summary>
        /// Constructor
        /// </summary>
        public MenuSystem()
        {
            // ScreenSaver for menuSystem
            screenSaver = new ScreenSaver();

            //gameScreens.Add(new SorryScreen(Enums_Engine.EngineState.NOT_SUPPORTED));
            //gameScreens.Add(new OpeningCreditScreen(Enums_Engine.EngineState.CREDIT_SCREEN));
            //gameScreens.Add(new TitleScreen(Enums_Engine.EngineState.TITLE_SCREEN));
            //gameScreens.Add(new GameSetup(Enums_Engine.EngineState.GAME_SETUP));
            //gameScreens.Add(new Cera1(Enums_Engine.EngineState.INSTRUCT_1));
            //gameScreens.Add(new Cera2(Enums_Engine.EngineState.INSTRUCT_2));
            //gameScreens.Add(new Cera3(Enums_Engine.EngineState.INSTRUCT_3));
            //gameScreens.Add(new Cera4(Enums_Engine.EngineState.INSTRUCT_4));
            //gameScreens.Add(new Cera5(Enums_Engine.EngineState.INSTRUCT_5));
            //gameScreens.Add(new InstructionScreen(Enums_Engine.EngineState.INSTRUCTION_SCREEN));
            //gameScreens.Add(new GameSetup(Enums_Engine.EngineState.GAME_SETUP));
            //gameScreens.Add(new LoadingScreen(Enums_Engine.EngineState.LOAD_LEVEL));
            //gameScreens.Add(new PauseScreen(Enums_Engine.EngineState.GAME_PAUSE));
            //gameScreens.Add(new GameOverScreen(Enums_Engine.EngineState.FINALIZE_G2LSTUFF));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="node">XML Node for loading</param>
        public virtual void Load(XmlNode node)
        {
            try
            {
                for (int x = 0; x < node.ChildNodes.Count; x++)
                {
                    if (node.ChildNodes[x].Name == "menu")
                    {
                        gameScreens.Add(CreateGameScreen(node.ChildNodes[x].Attributes["name"].Value,
                            new object[]{
                            Enum.Parse(typeof(Enums_Engine.EngineState), node.ChildNodes[x].Attributes["menuState"].Value)
                        }
                             ));
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
                DarkWynterEngine.ContentInstall_WarningMessage();
            }
            
        }
        /// <summary>
        /// Creates an instance of a GameObject using GameObject constructor parameters.
        /// </summary>
        /// <param name="objectName">The string-literal class name of the GameObject. EG- "Terrain"</param>
        /// <param name="parameters">Constructor parameters, usually empty or using the Load object.</param>
        /// <returns></returns>
        public static GameScreen CreateGameScreen(string objectName, object[] parameters)
        {
            GameScreen gameScreen = new GameScreen();
            for (int i = 0; i < ObjectLibrary.types.Count; i++)
            {
                if (ObjectLibrary.types[i].Name == objectName)
                {
                    try
                    {
                        gameScreen = (GameScreen)Activator.CreateInstance(ObjectLibrary.types[i], parameters);
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.Message);
                        DarkWynterEngine.ContentInstall_WarningMessage();
                        throw new Exception("Error Loading GameScreen");
                    }
                }
            }

            return gameScreen;
        }
        /// <summary>
        /// Updates the controller and then the current active screen
        /// </summary>
        public virtual void Update(ObjectLibrary objectLibrary)
        {
            for (int i = 0; i < gameScreens.Count; i++)
            {
                // Update appropriate menu screen
                if (Statics_Engine.SystemSettings.gameState == gameScreens[i].GetEngineState())
                {
                    gameScreens[i].Update(objectLibrary);
                    break;
                }
            }
        }

        /// <summary>
        /// Draws the appropriate screen
        /// </summary>
        /// <param name="spriteBatch">SpriteBatch used to draw</param>
        /// <param name="screenSaver">Current ScreenSaver</param>
        public virtual void Draw(SpriteBatch spriteBatch)
        {
            Statics_Stream.RenderSettings.graphics.GraphicsDevice.Clear(this.backColor);
            Statics_Stream.RenderSettings.graphics.GraphicsDevice.Viewport = Statics_Stream.RenderSettings.defaultViewport;
            //if (spriteBatch.GraphicsDevice.IsDisposed)
            //{
            //    spriteBatch.Dispose();
            //    spriteBatch = new SpriteBatch(Statics_Stream.RenderSettings.graphics.GraphicsDevice);
            //}

            // Begin Sprite Batching for Menusystem
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.BackToFront, SaveStateMode.None);

            for (int i = 0; i < gameScreens.Count; i++)
            {
                // Update appropriate menu screen
                if (Statics_Engine.SystemSettings.gameState == gameScreens[i].GetEngineState())
                {
                    gameScreens[i].Draw(spriteBatch);
                    break;
                }
            }

             spriteBatch.End();
        }
    }
}