/*
 * Util.GameScreen.cs
 * Authors: Adam Nabinger
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace Util
{
	/// <summary>
	/// The root class for each minigame. A Screen is a DrawableGameComponent intended to be layed one on top of another generically.
	/// </summary>
	public abstract class GameScreen : DrawableGameComponent
	{
		#region Fields

		// The global directory for the loading content and file saving/loading
		private static readonly string globalRootDirectory;

		// The global directory for loading content from
		private static readonly string globalRootContentDirectory;

		// The global directory for storing any saved files
		private static readonly string globalRootStorageDirectory;

		// Directory to store any saved files within
		private const string storageDirectory = @"\Autism Collaborative\";

		// The current content manager
		private VariableContentManager mContent;

		// The current root directory for content loading and file saving/loading
		private string mRootDirectory;

		// The input handler used for processing any input on the game screen
		private InputHandler mInputHandler;

		// The logger used for recording event codes
		private Logger mLogger;

		// List of drawable game components
		private List<DrawableGameScreenComponent> mComponents;

		// The frame rate display object
		private FrameRateDisplayComponent frameRateDisplay;

		// Whether or not the mouse cursor is trapped within the gamescreen
		private bool trap;

		/// <summary>
		/// Reference to the main game screen
		/// </summary>
		internal MainGame mGame;

		#endregion

		#region Properties

		/// <summary>
		/// Gets/Sets the frame rate display component.
		/// </summary>
		protected FrameRateDisplayComponent FrameRateDisplay
		{
			get { return frameRateDisplay; }
			private set { frameRateDisplay = value; }
		}

		/// <summary>
		/// The fully qualified path of the directory from which the game is being run.
		/// </summary>
		public static string GlobalRootDirectory { get { return globalRootDirectory; } }

		/// <summary>
		/// The fully qualified path of the main content directory.
		/// </summary>
		public static string GlobalRootContentDirectory { get { return globalRootContentDirectory; } }

		/// <summary>
		/// The fully qualifed path of the primary storage directory.
		/// Currently a subdirectory under My Documents.
		/// </summary>
		public static string GlobalRootStorageDirectory { get { return globalRootStorageDirectory; } }

		/// <summary>
		/// Expose access to the components associated with this game screen.
		/// </summary>
		public ICollection<DrawableGameScreenComponent> Components { get { return mComponents; } }

		/// <summary>
		/// The root, main game, hosting this screen. This reference should be used sparingly, only when necessary (which isn't often).
		/// </summary>
		[Obsolete("This Game reference should be used sparingly, when absolutely necessary, and absolutely not for things like 'Game.Components.Contains(x)' or 'foreach(thing in Game.Components)'. That's bad coding practice and will kill your performance.")]
		public new MainGame Game { get { return mGame; } }

		/// <summary>
		/// The bounds of the window the game is inside.
		/// </summary>
		public Rectangle WindowBounds { get { return mGame.Window.ClientBounds; } }

		/// <summary>
		/// Gets the Current Content.ContentManager
		/// </summary>
		public VariableContentManager Content
		{
			get { return mContent; }
			internal set { mContent = value; }
		}

		/// <summary>
		/// Gets the Current GraphicsDeviceManager
		/// </summary>
		public GraphicsDeviceManager GraphicsDeviceManager { get { return mGame.gdm; } }

		/// <summary>
		/// The directory from which the assembly containing this GameScreen was loaded.
		/// </summary>
		public string RootDirectory
		{
			get { return mRootDirectory; }
			internal set
			{
				mRootDirectory = value;
				if (Content != null)
				{
					Content.RootDirectory = mRootDirectory + MainGame.ContentSubdirectory;
				}
			}
		}

		/// <summary>
		/// Gets/Sets whether the mouse pointer is visible or not
		/// </summary>
		public bool IsMouseVisible { 
			get { return mGame.IsMouseVisible; } 
			set { mGame.IsMouseVisible = value; } 
		}

		#endregion

		#region Creation

		protected GameScreen()
			: base(MainGame.TheGame)
		{ }

		static GameScreen()
		{
			string RootLoc = Assembly.GetEntryAssembly().Location;
			if (RootLoc != null) {
				int val = RootLoc.LastIndexOf('\\');
				globalRootDirectory = RootLoc.Substring(0, val);
			}
			globalRootContentDirectory = globalRootDirectory + MainGame.ContentSubdirectory;
			globalRootStorageDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + storageDirectory;

			if (!Directory.Exists(globalRootStorageDirectory))
			{
				Directory.CreateDirectory(globalRootStorageDirectory);
			}
		}

		#endregion

		#region Initialization

        /// <summary>
        /// Base initialize call.
        /// </summary>
        public override void Initialize()
        {
            // Set the texture size allowed for the game based on this computer's hardware
            VariableContentManager.SetMaxResolutionToHardwareCapabilities(mGame.gdm.GraphicsDevice);

            // Initialization
            base.Initialize();
        }

		/// <summary>
		/// Reinitialize will be called on the screen after a screen which was raised above it is done.
		/// </summary>
		public virtual void Reinitialize() { }

		#endregion

		#region Input Handler

		/// <summary>
		/// Get a new Input Handler.
		/// </summary>
		/// <returns>A new instance of Util.InputHandler</returns>
		protected InputHandler GetInputHandler()
		{
			if (mInputHandler == null)
			{
				mInputHandler = new InputHandler(mGame, UserProfileUtility.CurrentLogger);
			}
			return mInputHandler;
		}

		#endregion

		#region Logger

		/// <summary>
		/// Get a new Logger.
		/// </summary>
		/// <returns>The new logger</returns>
		protected Logger GetLogger()
		{
			if (mLogger == null)
			{
				mLogger = new Logger(UserProfileUtility.CurrentLogger);
			}
			return mLogger;
		}

		#endregion

		#region FPS

		/// <summary>
		/// Show the FPS of this screen with an overlay component.
		/// </summary>
		protected void ShowFPS()
		{
			if (FrameRateDisplay != null)
			{
				return;
			}
			FrameRateDisplay = new FrameRateDisplayComponent();
			AddComponent(FrameRateDisplay);
		}

		/// <summary>
		/// Show the FPS of this screen with an overlay component.
		/// </summary>
		/// <param name="fontName">Path name for the font to use</param>
		protected  void ShowFPS(string fontName)
		{
			if (FrameRateDisplay != null)
			{
				return;
			}
			FrameRateDisplay = new FrameRateDisplayComponent(fontName);
			AddComponent(FrameRateDisplay);
		}

		#endregion

		#region Auto Clear

		/// <summary>
		/// Adds a clear object that renders the default color over the entire screen at the given draw order position
		/// </summary>
		/// <param name="drawPosition">The draw order position for when to render</param>
		protected void AutoClear(int drawPosition)
		{
			Clear mClear = new Clear();
			mClear.DrawOrder = drawPosition;
			AddComponent(mClear);
		}

		/// <summary>
		/// Adds a clear object that renders the choosen color over the entire screen at the given draw order position
		/// </summary>
		/// <param name="drawPosition">The draw order position for when to render</param>
		/// <param name="color">The color to render</param>
		protected void AutoClear(int drawPosition, Color color)
		{
			Clear mClear = new Clear(color);
			mClear.DrawOrder = drawPosition;
			AddComponent(mClear);
		}

		#endregion

		#region Management

		/// <summary>
		/// Dispose of this screen and all components it was using.
		/// </summary>
		/// <param name="disposing">Whether or not this is currently being disposed</param>
		[DebuggerHidden]
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				if (trap)
				{
					MouseUtility.ReleaseTrap();
				}
				if (mInputHandler != null)
				{
					mInputHandler.Dispose();
				}
				if (mLogger != null)
				{
					mLogger.Dispose();
				}
				if (mComponents != null)
				{
					while (mComponents.Count > 0)
					{
						mComponents[0].Dispose();
					}
				}
				mContent.Unload();
				mContent.Dispose();
			}
			base.Dispose(disposing);
		}

		[Obsolete("This should never be used.")]
		public void PublicAddComponent(DrawableGameScreenComponent newComponent)
		{
#if DEBUG
			Console.WriteLine("This should never be used.");
#endif
			AddComponent(newComponent);
		}

		/// <summary>
		/// Add a drawable game screen component to the components list managed by this game screen.
		/// This component will automatically be initialized and loaded, and will be disposed when this screen is disposed.
		/// </summary>
		/// <param name="newComponent">The new component to be added</param>
		protected void AddComponent(DrawableGameScreenComponent newComponent)
		{
			if (newComponent.parent != null)
			{
				throw new ArgumentException("Component has already been added to a screen.");
			}
			newComponent.parent = this;
			if (mComponents == null)
			{
				mComponents = new List<DrawableGameScreenComponent>();
			}
			mComponents.Add(newComponent);
			mGame.Components.Add(newComponent);
			//newComponent.Disposed += Components_ComponentRemoved;
		}

		internal void RemoveComponent(DrawableGameScreenComponent oldComponent)
		{
			if (mComponents != null)
			{
				mComponents.Remove(oldComponent);
				// mGame's component list is already handled by XNA
			}
		}

		#endregion

		#region Activation

		/// <summary>
		/// Activates and reveals this gamescreen and all of its components 
		/// </summary>
		public virtual void Enable()
		{
			// Disable this
			Enabled = true;
			Visible = true;
			mInputHandler.Enable();

			// Do the same for all of our components
			if (mComponents == null)
			{
				return;
			}
			// Go through and get them all
			foreach (DrawableGameScreenComponent component in mComponents)
			{
				// Disable them
				component.Enabled = true;
				component.Visible = true;
			}
		}

		/// <summary>
		/// Deactivates and hides this gamescreen and all of its components 
		/// </summary>
		public virtual void Disable()
		{
			// Disable this
			Enabled = false;
			Visible = false;
			mInputHandler.Disable();

			// Do the same for all of our components
			if (mComponents == null)
			{
				return;
			}
			// Go through and get them all
			foreach (DrawableGameScreenComponent component in mComponents)
			{
				// Disable them
				component.Enabled = false;
				component.Visible = false;
			}
		}

		#endregion

		#region Screen State

		/// <summary>
		/// Remove the screen that is on the top of the stack.
		/// Dispose, and UnloadContent are called.
		/// Then, the screen below, which is now on top again, gets Reinitialized.
		/// </summary>
		protected void Done()
		{
			mGame.PopScreen();
		}

		/// <summary>
		/// Ask the game to exit, removing all screens and closing the program.
		/// </summary>
		protected void Exit()
		{
			mGame.Exit();
		}

		#endregion

		#region Modifiers

		/// <summary>
		/// Add a new screen to the stack, on top of the current one.
		/// Sets the DrawOrder and UpdateOrder of the new Screen to place it on top of the stack.
		/// Then, Initialize and LoadContent will be called on the newScreen.
		/// Finally, the new Screen will enter into the common Update+Draw loop.
		/// </summary>
		/// <param name="newScreen">The new game screen added to the top of the stack</param>
		protected void Raise(GameScreen newScreen)
		{
			if (newScreen.RootDirectory == null)
			{
				newScreen.RootDirectory = RootDirectory;
			}
			mGame.PushScreen(newScreen);
		}

		/// <summary>
		/// Swap the current top screen, with the given one.
		/// </summary>
		/// <param name="newScreen">The game screen to replace the current one</param>
		protected void Swap(GameScreen newScreen)
		{
			if (newScreen.RootDirectory == null)
			{
				newScreen.RootDirectory = RootDirectory;
			}
			mGame.SwapScreen(newScreen);
		}

		#endregion

		#region Mouse

		/// <summary>
		/// Sets the mouse cursor to be unable to leave the game screen
		/// </summary>
		protected void TrapMouse()
		{
			trap = true;
			MouseUtility.AutoTrap(mGame);
		}

		/// <summary>
		/// Gets the mouse cursor's location in the given viewpot
		/// </summary>
		/// <param name="mouseLoc">The location of the mouse cursor</param>
		/// <param name="view">The viewport to check</param>
		/// <returns>The mouse cursor's location in the given viewport</returns>
		public static Point MouseViewportLocation(Point mouseLoc, Viewport view)
		{
			Point ret = Point.Zero;

			ret.X = mouseLoc.X - view.X;
			ret.Y = mouseLoc.Y - view.Y;

			return ret;
		}

		#endregion
	}
}