/*
 * Entity.cs
 * Authors: August Zinsser, Brian Chesbrough
 * 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 Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace MaritimeDefender
{
	/// <summary>
	/// Serves as the base class for almost every object or character in a game.
	/// It has many attributes that game objects are likely to have, as well as some standard behaviors
	/// like fading in and out.
	/// For 2D entities, just ignore the z position of any applicable variables or functions.
	/// Entities can also be sorted by texture for effecient sprite batching.
	/// </summary>
	public class Entity : Collidable, IComparable
	{
		#region Fields

		/// <summary>
		/// Checks if the entity is alive or not
		/// </summary>
		protected bool mAlive = true; 
		
		/// <summary>
		/// The path name of the texture file
		/// </summary>
		protected string mTexturePath;
		
		/// <summary>
		/// The sprite to use for this entity
		/// </summary>
		protected Animation mSprite;
		
		/// <summary>
		/// Allows for mirroring during rendering
		/// </summary>
		protected SpriteEffects mSpriteEffects;
		
		/// <summary>
		/// Velocity (can be ignored if the game updates position manually)
		/// </summary>
		protected Vector3 mVel;
		
		/// <summary>
		/// Display the entity or not
		/// </summary>
		protected bool mVisible = true;
		
		/// <summary>
		/// Rotation in radians
		/// </summary>
		protected float mRot;
		
		/// <summary>
		/// Angular velocity in radians
		/// </summary>
		protected float mAngVel;
		
		/// <summary>
		/// Blow up or shrink the entity
		/// </summary>
		protected float mScale = 1;
		
		/// <summary>
		/// Draw the entity with a color
		/// </summary>
		protected Color mTint = Color.White;
		
		/// <summary>
		/// Target for linear interpolation (overrides velocity)
		/// </summary>
		protected Vector3 mTargetPos;
		
		/// <summary>
		/// The size of the entity
		/// </summary>
		protected Vector3 mTargetSize;
		
		/// <summary>
		/// The degree of rotation in radians
		/// </summary>
		protected float mTargetRot;
		
		/// <summary>
		/// > 0 when the entity is lerping to mTargetPos
		/// </summary>
		protected float mLerpCounter;
		
		/// <summary>
		/// How long the fade in effect lasts
		/// </summary>
		protected float mFadeInLifeSpan;
		
		/// <summary>
		/// The counter for the fade in effect
		/// </summary>
		protected float mFadeInCounter;
		
		/// <summary>
		/// How long the fade out effect lasts
		/// </summary>
		protected float mFadeOutLifeSpan;
		
		/// <summary>
		/// The counter for the fade out effect
		/// </summary>
		protected float mFadeOutCounter;

		/// <summary>
		/// Whether or not this is currently fading out
		/// </summary>
		protected bool mFadeIn;

		/// <summary>
		/// Whether or not this is currently fading out
		/// </summary>
		protected bool mFadeOut;

		#endregion

		#region Properties

		/// <summary>
		/// Gets the texture representing the entity
		/// CAUTION: This is fast for repeated calls to static image entities, but slow 
		/// for animated entites and slow the first call to static iamge entities!
		/// </summary>
		public Texture2D Texture { get { return mSprite != null ? mSprite.CurrentFrameCopy : null; } }

		/// <summary>
		/// Gets/Sets the sprite effect to use when rendering
		/// </summary>
		public SpriteEffects SpriteEffects { 
			get { return mSpriteEffects; }
			set { mSpriteEffects = value; }
		}

		/// <summary>
		/// Gets/Sets the x velocity value
		/// </summary>
		public float dX { 
			get { return mVel.X; }
			set { mVel.X = value; } 
		}

		/// <summary>
		/// Gets/Sets the y velocity value
		/// </summary>
		public float dY { 
			get { return mVel.Y; }
			set { mVel.Y = value; } 
		}

		/// <summary>
		/// Gets/Sets the z velocity value
		/// </summary>
		public float dZ { 
			get { return mVel.Z; }
			set { mVel.Z = value; }
		}

		/// <summary>
		/// Gets/Sets whether or not this entity is visible
		/// </summary>
		public bool Visible { 
			get { return mVisible; }
			set { mVisible = value; }
		}

		/// <summary>
		/// Gets whether the entity is linearly interpolating to another transform. Velocity is ignored while lerping.
		/// </summary>
		public bool IsLerping { get { return mLerpCounter > 0; } }

		/// <summary>
		/// Gets, if Lerping, where the entity is going to. Otherwise, where the entity is now.
		/// </summary>
		public Vector3 TargetPosition { get { return mLerpCounter > 0 ? mTargetPos : mPos; } }
		
		/// <summary>
		/// Gets/Sets the current velocity
		/// </summary>
		public Vector3 Velocity { 
			get { return mVel; }
			set { mVel = value; }
		}
		
		/// <summary>
		/// Gets/Sets the current rotation
		/// </summary>
		public float Rotation {
			get { return mRot; }
			set { mRot = value; } 
		}
		
		/// <summary>
		/// Gets/Sets the current angular rotation
		/// </summary>
		public float AngularVelocity { 
			get { return mAngVel; }
			set { mAngVel = value; } 
		}

		/// <summary>
		/// Gets/Sets the current size scale
		/// </summary>
		public float Scale { 
			get { return mScale; }
			set { mScale = value; }
		}

		/// <summary>
		/// Gets/Sets the current color
		/// </summary>
		public Color Tint
		{
			get { return mTint; }
			set
			{
				// Preserve old functionality - remove if unneed
				mTint = new Color(value.R, value.G, value.B, mTint.A);
			}
		}

		/// <summary>
		/// Gets/Sets the current opacity
		/// </summary>
		public float Opacity { 
			get { return mTint.A / 255.0f; }
			set { mTint = new Color(mTint.R, mTint.G, mTint.B, (byte)(value * 255)); }
		}

		#endregion

		#region Predicates

		/// <summary>
		/// Notifies when this entity is no longer considered alive
		/// </summary>
		public static readonly Predicate<Entity> NotAlive = new Predicate<Entity>(delegate(Entity entity)
		{
			return !entity.mAlive;
		});

		#endregion

		#region Creation

		/*  Constructors:
		 *      Provide a constructor for each dimension (2D / 3D) as well as animated and non-animated.
		 *      To overload a constructor, call up to the 3D version (sticking to animated/vs non).
		 *          For animated constructors, call down to the non-animated 3D constructor
		 */

		/// <summary>
		/// Create a placeholder entity
		/// </summary>
		public Entity()
		{
			mVisible = false;
		}

		/// <summary>
		/// Create a non-animated entity with a cubic bounding box
		/// </summary>
		/// <param name="texturePath">Sprite image</param>
		public Entity(string texturePath)
			: this(texturePath, Vector3.Zero, Vector3.Zero)
		{ }

		/// <summary>
		/// Create a non-animated entity with a rectangular bounding box (with a depth of zero)
		/// </summary>
		/// <param name="texturePath">Single image</param>
		/// <param name="boundingWidth">Width of the bounding box as well as the display rectangle</param>
		/// <param name="boundingHeight">Height of the bounding box as well as the display rectangle</param>
		public Entity(string texturePath, float boundingWidth, float boundingHeight)
			: this(texturePath, Vector3.Zero, new Vector3(boundingWidth, boundingHeight, 0f))
		{ }

		/// <summary>
		/// Create a non-animated entity with a cubic bounding box.
		/// This is the "real" constructor for non-animated entities.
		/// </summary>
		/// <param name="texturePath">Sprite image.</param>
		/// <param name="position">Center coordinates.</param>
		/// <param name="size">Create a bounding cube with this length.</param>
		public Entity(string texturePath, Vector3 position, Vector3 size)
		{
			mPos = position;
			mSize = size;
            mTexturePath = texturePath;
		}

		#endregion

		#region Management

		/// <summary>
		/// Loads in all necessary information for all content dependent objects
		/// </summary>
		/// <param name="content">Reference to the content manager for loading</param>
		public virtual void LoadContent(ContentManager content)
		{
			if (mTexturePath != null)
			{
				Texture2D texture = content.Load<Texture2D>(mTexturePath);
                if (mSize.Equals(Vector3.Zero))
                {
                    mSize = new Vector3(texture.Width, texture.Height, 0f);
                }
				// Create an animation with just one clip of one frame
				Animation newAnim = new Animation(new Vector2(texture.Width, texture.Height));
				newAnim.AddClip("Default", texture, 1, 1f);
				mSprite = newAnim;
				mSprite.Play("Default");
			}
		}

		/// <summary>
		/// Unloads any needed information for content dependent
		/// TODO!
		/// </summary>
		public virtual void UnloadContent()
		{ }

		#endregion

		#region Update

		/// <summary>
		/// Updates necessary logic
		/// </summary>
		/// <param name="gameTime">Time passed in game</param>
		public virtual void Update(GameTime gameTime)
		{
			float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
			// Update any animations
			if (mSprite != null)
			{
				mSprite.Update(gameTime);
			}
			// Update physics if not lerping
			if (mLerpCounter <= 0f)
			{
				mPos += mVel * dt;
				mRot += mAngVel * dt;
			}
			// Update lerp
			else
			{
				// Position
				float distanceRemaining = (float)Math.Sqrt(Math.Pow((mPos.X - mTargetPos.X), 2) + Math.Pow((mPos.Y - mTargetPos.Y), 2) + Math.Pow((mPos.Z - mTargetPos.Z), 2));
				float speed = distanceRemaining / mLerpCounter;
				Vector3 direction = mTargetPos - mPos;
				direction.Normalize();
				mPos += Vector3.Multiply(direction, speed * dt);

				// Size
				Vector3 scaleStep = (mTargetSize - mSize) / mLerpCounter;
				mSize += Vector3.Multiply(scaleStep, dt);

				// Rotation
				float rotationRemaining = mTargetRot - mRot;
				float angularVelocity = (float)rotationRemaining / mLerpCounter;
				mRot += angularVelocity * dt;
				mLerpCounter -= dt;
				// Ensure that the entity makes it exactly to its target
				if (mLerpCounter < 0f)
				{
					mPos = mTargetPos;
					mSize = mTargetSize;
					mRot = mTargetRot;
				}
			}
			// Update fading
			if (mFadeIn)
			{
				if (mFadeInCounter > 0f)
				{
					mFadeInCounter -= dt;
					Opacity = 1.0f - (mFadeInCounter / mFadeInLifeSpan);
				}
				else
				{
					Opacity = 1.0f;
					mFadeIn = false;
				}
			}
			if (mFadeOut)
			{
				if (mFadeOutCounter > 0f)
				{
					mFadeOutCounter -= dt;
					Opacity = mFadeOutCounter / mFadeOutLifeSpan;
				}
				else
				{
					Opacity = 0f;
					mVisible = false;
					mFadeOut = false;
				}
			}
		}

		#endregion

		#region Render

		/// <summary>
		/// Draw the entity based on its Position and Size properties
		/// </summary>
		/// <param name="spriteBatch">Sprite Batch to draw to</param>
		public virtual void Draw(SpriteBatch spriteBatch)
		{
			Draw(spriteBatch, new Rectangle((int)(mPos.X), (int)(mPos.Y), (int)mSize.X, (int)mSize.Y), 
				MathHelper.Clamp(mPos.Z, 0f, 1f));
		}

		/// <summary>
		/// Draw the entity based on its Position and Size properties with an offset 
		/// </summary>
		/// <param name="spriteBatch">Sprite Batch to draw to</param>
		/// <param name="offset">Position offset</param>
		public virtual void Draw(SpriteBatch spriteBatch, Vector3 offset)
		{
			Draw(spriteBatch, new Rectangle((int)(mPos.X + offset.X), (int)(mPos.Y + offset.Y), 
				(int)mSize.X, (int)mSize.Y), MathHelper.Clamp(mPos.Z + offset.Z, 0f, 1f));
		}

		/// <summary>
		/// Draw the entity at the specified location (ignores internal position and size)
		/// </summary>
		/// <param name="spriteBatch">the sprite batch to draw to</param>
		/// <param name="destination">The position and dimension of the entity</param>
		/// <param name="layerDepth">The layer of which to render on for z ordering</param>
		public virtual void Draw(SpriteBatch spriteBatch, Rectangle destination, float layerDepth)
		{
			if (mVisible)
			{
				mSprite.Draw(spriteBatch, destination, mTint, (float)mRot, mSpriteEffects, layerDepth);
			}
		}

		#endregion

		#region Util

		/// <summary>
		/// Used to sort Entities by their texture (the current sprite sheet in use by the Entity's Animation)
		/// </summary>
		/// <param name="obj"></param>
		/// <returns>0 for if they are the same, otherwise 1 or -1 for whichever is "greater"</returns>
		public int CompareTo(object obj)
		{
			Entity that = obj as Entity;
			if (mSprite == null || that == null || that.mSprite == null)
			{
				return 0;
			}
			Texture2D thisTexture = mSprite.CurrentSpriteSheet;
			Texture2D thatTexture = that.mSprite.CurrentSpriteSheet;
			if (thisTexture == null || thatTexture == null)
			{
				return 0;
			}
			int thisHash = thisTexture.GetHashCode();
			int thatHash = thatTexture.GetHashCode();
			return thisHash.CompareTo(thatHash);
		}

		/// <summary>
		/// Lineraly interpolates from current position, size, and rotation to the targets over the period specified
		/// </summary>
		/// <param name="targetPosition">Final Position</param>
		/// <param name="targetSize">Final Size</param>
		/// <param name="targetRotation">Final Rotation</param>
		/// <param name="duration">Seconds before arriving at destination</param>
		public void Lerp(Vector3 targetPosition, Vector3 targetSize, float targetRotation, float duration)
		{
			mLerpCounter = duration;
			mTargetPos = targetPosition;
			mTargetSize = targetSize;
			mTargetRot = targetRotation;
			// See if this call was used to stop previous Lerping
			if (mLerpCounter == 0)
			{
				mPos = mTargetPos;
				mSize = mTargetSize;
				mRot = mTargetRot;
			}
		}

		/// <summary>
		/// Relays the play command to this entity's sprite
		/// </summary>
		/// <param name="clipName">Name of the clip to play</param>
		public void Play(string clipName)
		{
			mSprite.Play(clipName);
		}

		#endregion

		#region Fade

		/// <summary>
		/// Causes the entity to go from completely transparent to completely opaque over the specified period
		/// </summary>
		/// <param name="seconds">Time to go from 0 to 1 opacity</param>
		public void FadeIn(float seconds)
		{
			mVisible = true;
			Opacity = 0f;
			mFadeInCounter = seconds;
			mFadeInLifeSpan = seconds;
			mFadeOutCounter = 0;
			mFadeIn = true;
		}

		/// <summary>
		/// Causes the entity to go from completely opaque completely transparent over the specified period
		/// </summary>
		/// <param name="seconds">Time to go from 1 to 0 opacity</param>
		public void FadeOut(float seconds)
		{
			Opacity = 1f;
			mFadeOutCounter = seconds;
			mFadeOutLifeSpan = seconds;
			mFadeInCounter = 0;
			mFadeOut = true;
		}

		#endregion
	}
}