/*
 * GUIComponent.cs
 * Authors: Bradley R. Blankenship
 * 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 Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Util;
using System;

namespace tAC_Engine.GUI
{
	/// <summary>
	/// Defines the base attributes of all GUI components
	/// </summary>
    public abstract class GUIComponent : IComparable
    {
        #region Fields

        /// <summary>
		/// The position of the component (in world space)
        /// </summary>
        protected Vector2 mPosition;

        /// <summary>
        /// Offsets the text when drawing
        /// </summary>
        protected Vector2 mTextOffset;

        /// <summary>
        /// Transforms the position of the component from world space to screen space (keep as (0,0) to keep object in screen space)
        /// </summary>
        protected Vector2 mScreenOffset;

        /// <summary>
		/// The size of the component on screen
        /// </summary>
        protected Vector2 mSize;

        /// <summary>
        /// The rotation to draw the component
        /// </summary>
        protected float mRotation;

        /// <summary>
        /// SpriteEffects to use when drawing the component
        /// </summary>
        protected SpriteEffects mSpriteEffects = SpriteEffects.None;

        /// <summary>
		/// The bounds of the component
        /// </summary>
        protected Rectangle mBounds;

        /// <summary>
        /// The parent screen of the component
        /// </summary>
        protected GUIScreen mParentScreen;

        /// <summary>
        /// The parent component of the component
        /// </summary>
        protected GUIComponent mParentComponent;

        /// <summary>
        /// The sprite batch for drawing to the screen
        /// </summary>
        protected SpriteBatchProxy mSpriteBatch;

		/// <summary>
		/// The color to add to the sprite.
		/// </summary>
		protected Color mAddColor = Color.White;

        /// <summary>
        /// Whether we are visible or not
        /// </summary>
        protected bool mIsVisible = false;

		/// <summary>
		/// Whether we are considered enabled or not.
		/// </summary>
		protected bool mIsEnabled = false;

        /// <summary>
        /// The text for a tool tip
        /// </summary>
        protected string mToolTipText;

		/// <summary>
		/// Whether this can be clicked through or not
		/// </summary>
		protected bool mClickThrough = false;

        /// <summary>
        /// Draw order of this component.
        /// </summary>
        protected float mLayerDepth;

        #endregion

        #region Properties

        /// <summary>
        /// Allows access to the position of the component.
        /// </summary>
        public virtual Vector2 Position
        {
            get { return mPosition; }
            set
            { 
                mPosition = value;
                calculateBounds();
            }
        }

        /// <summary>
        /// Access the X position of the component.
        /// </summary>
        public virtual float X
        {
            get { return mPosition.X; }
            set { Position = new Vector2(value, Position.Y); }
        }

        /// <summary>
        /// Access the Y position of the component.
        /// </summary>
        public virtual float Y
        {
            get { return mPosition.Y; }
            set { Position = new Vector2(Position.X, value); }
        }

        /// <summary>
        /// Displaces the component from the screen
        /// </summary>
        public virtual Vector2 ScreenOffset
        {
            get { return mScreenOffset; }
            set
            {
                mScreenOffset = value;
                calculateBounds();
            }
        }

        /// <summary>
        /// Allows access to the size of the component.
        /// </summary>
        public virtual Vector2 Size
        {
            get { return mSize; }
            set
            {
                mSize = value;
                calculateBounds();
            }
        }

        /// <summary>
        /// Allows access to the rotation of the component.
        /// </summary>
        public virtual float Rotation
        {
            get { return mRotation; }
            set { mRotation = value; }
        }

        /// <summary>
        /// Allows access to the sprite effects of the component.
        /// </summary>
        public virtual SpriteEffects SpriteEffects
        {
            get { return mSpriteEffects; }
            set { mSpriteEffects = value; }
        }

        /// <summary>
        /// Allows others to view the bounds of the component.
        /// </summary>
        public Rectangle Bounds
        {
            get { return mBounds; }
        }

        /// <summary>
        /// Allows internal access to the parent screen.
        /// </summary>
        public GUIScreen ParentScreen
        {
            get { return mParentScreen; }
            set { mParentScreen = value; }
        }

        /// <summary>
        /// Allows internal access to the parent component.
        /// </summary>
        public GUIComponent ParentComponent
        {
            get
            {
                // Do this if the parent is null
                if (mParentComponent == null)
                {
                    // Return ourselves
                    return this;
                }
                else
                {
                    // Return the real parent
                    return mParentComponent;
                }
            }
            set { mParentComponent = value; }
        }

        /// <summary>
        /// Allows public access to the sprite batch.
        /// </summary>
        public SpriteBatchProxy Batch
        {
            get { return mSpriteBatch; }
            set { mSpriteBatch = value; }
        }

		/// <summary>
		/// Allows access to the additive color for the sprites.
		/// </summary>
		public virtual Color AddColor
		{
			get { return mAddColor; }
			set { mAddColor = value; }
		}

        /// <summary>
        /// Allows access to the visibility of the component.
        /// </summary>
        public virtual bool Visible
        {
            get { return mIsVisible; }
            set { mIsVisible = value; }
        }

		/// <summary>
		/// Sets the enabled quality of a value.
		/// </summary>
		public virtual bool Enabled
		{
			get { return mIsEnabled; }
			set
			{
				mIsEnabled = value;
				if (mIsEnabled)
					mAddColor = Color.White;
				else
					mAddColor = new Color(new Vector3(0.25f, 0.25f, 0.25f));
			}
		}

        /// <summary>
        /// Allows access to the tool tip text.
        /// </summary>
        public string ToolTipText
        {
            get { return mToolTipText; }
            set { mToolTipText = value; }
        }

		/// <summary>
		/// Allow access to set whether the component can be clicked through
		/// or not.
		/// </summary>
		public bool ClickThrough
		{
			get { return mClickThrough; }
			set { mClickThrough = value; }
        }

        /// <summary>
        /// The draw order of this GUIComponent.
        /// </summary>
        [Obsolete("LayerDepth or DrawOrder should be determined by order in the Components list.")]
        public float LayerDepth
        {
            get { return mLayerDepth; }
            set { mLayerDepth = value; }
        }

        #endregion

        #region Constructs

        /// <summary>
        /// Create the intial values
        /// </summary>
        public GUIComponent()
        {
            // Initialize our other values
            Position = Vector2.Zero;
            Size = Vector2.Zero;

            // Initialize our bounds
            calculateBounds();
        }

        #endregion

        #region Initialization

        /// <summary>
        ///     Initializes the component. Override this method to load any non-graphics
        ///     resources and query for any required services.
        /// </summary>
        public abstract void Initialize();

        /// <summary>
        ///     Called when graphics resources need to be loaded. Override this method to
        ///     load any component-specific graphics resources.
        /// </summary>
        public virtual void LoadContent() { }

        /// <summary>
        /// Reinitializes the values of the component.
        /// </summary>
		public virtual void Resize() { }

		/// <summary>
		/// Reinitialize the values.
		/// </summary>
		public virtual void Reinitialize() { }

        #endregion

        #region Management

        /// <summary>
        /// Registers us with the given screen and allows the screen
        /// to add us to its list of components.
        /// </summary>
        /// <param name="screen">The parent screen.</param>
        public void Register(GUIScreen screen)
        {
            // Get the values for the GUI screen
            ParentScreen = screen;
        }

        /// <summary>
        /// Registers us with the given container and allows the
        /// container to add us to its list of components.
        /// </summary>
        /// <param name="container"></param>
        public void Register(GUIContainer container)
        {
            // Get the values for the GUI Container
            ParentComponent = container;
            ParentScreen = container.ParentScreen;
        }

        #endregion

        #region Update

        /// <summary>
        /// Update the component based on its needs.
        /// </summary>
        /// <param name="gameTime">The current game time.</param>
        public abstract void Update(GameTime gameTime);

        /// <summary>
        /// Recalculates the bounds based on size, position, and screen offset
        /// </summary>
        protected void calculateBounds()
        {
            mBounds = new Rectangle(
                    (int)(Position.X - mScreenOffset.X), (int)(Position.Y - mScreenOffset.Y),
                    (int)Size.X, (int)Size.Y);
        }

        #endregion

        #region Event Handling

		/// <summary>
		/// Determines if the given point is inside of any of the GUI elements.
		/// </summary>
		/// <param name="pPoint">The point to test.</param>
		/// <returns>Whether the point is inside the GUI or not.</returns>
		public virtual bool IsInside(Point pPoint)
		{
			// the return value
			bool retVal = false;

			// Get the initialize value
			bool test = !ClickThrough;

			// If test
			if(test && Visible)
			{
                if (mRotation == 0)
                {
                    // Do a global bounds check
                    retVal = Bounds.Contains(pPoint);
                }
                else
                {
                    // Rotate pPoint into local coordinates and check against that
                    Vector2 localOffset = new Vector2(pPoint.X - Bounds.Location.X, pPoint.Y - Bounds.Location.Y);
                    float localDiagonal = localOffset.Length();
                    double localRotation = Math.Atan2(localOffset.Y, localOffset.X) - mRotation;
                    Point localPoint = new Point((int)(Math.Cos(localRotation) * localDiagonal), (int)(Math.Sin(localRotation) * localDiagonal));
                    if (localPoint.X > 0 && localPoint.Y < Bounds.Width &&
                             localPoint.Y > 0 && localPoint.Y < Bounds.Height)
                        localRotation = 0;
                    retVal = localPoint.X > 0 && localPoint.Y < Bounds.Width &&
                             localPoint.Y > 0 && localPoint.Y < Bounds.Height;
                }
			}

			// Return
			return retVal;
		}

        /// <summary>
        /// Handle the given mouse event we've received.
        /// </summary>
        /// <param name="e">The mouse event to handle.</param>
        public abstract bool HandleMouseEvent(MouseInputEvent e);

        /// <summary>
        /// Handle the given key input event we've received.
        /// </summary>
        /// <param name="e">The key input event to handle.</param>
        public abstract bool HandleKeyEvent(KeyInputEvent e);

        /// <summary>
        /// Returns the component that will be used for the tool tip.
        /// </summary>
        /// <param name="p">The vector position.</param>
        /// <returns>The component for the tool tip.</returns>
        public virtual GUIComponent GetToolTipComponent(Point p)
        {
            // The return value
            GUIComponent retVal = null;

            // If we contain the vector
            if( this.Bounds.Contains(p) && this.Visible )
            {
                // Set the retval
                retVal = this;
            }

            // Return the value
            return retVal;
        }

        #endregion

        #region Draw

        /// <summary>
        /// Draw the component to the screen.
        /// </summary>
        /// <param name="gameTime">The current game time.</param>
        public abstract void Draw(GameTime gameTime);

        #endregion

        #region IComparable Members

        public int CompareTo(object obj)
        {
            if (obj is GUIComponent)
            {
                float diff = this.LayerDepth - ((GUIComponent)obj).LayerDepth;
                if (diff < 0)
                    return -1;
                else if (diff > 0)
                    return 1;
                else
                    return 0;
            }
            else
            {
                throw new ArgumentException("x and y are of different types.");
            }
        }

        #endregion
    }
}