/*
 * EntitySprite.cs
 * Authors: Mike Dapiran
 * 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.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Util;

namespace tAC_Engine.Graphics.Entities
{
	/// <summary>
	/// This is the class which will be used to draw sprites to the screen.
	/// </summary>
	public class EntitySprite : DrawableGameScreenComponent
	{
		#region Fields

		/// <summary>
		/// Reference to the current content manager
		/// </summary>
		protected ContentManager Content;

		/// <summary>
		/// The destination rectangle of the sprite on the screen. 
		/// Defaults to Rectangle.Empty and is set to width and height 
		/// of the Texture upon load.
		/// </summary>
		protected Rectangle m_Destination = Rectangle.Empty;
		
		/// <summary>
		/// The center point of the EntitySprite's Texture.
		/// </summary>
		protected Vector2 m_TextureCenter = Vector2.Zero;

		/// <summary>
		/// The bounding sphere radius of the EntitySprite's Texture
		/// </summary>
		protected float m_Radius;

		/// <summary>
		/// The SpriteBatch object used to draw the sprite. Defaults to null. Will be ignored if the SpriteBatch is passed as a draw
		/// parameter.
		/// </summary>
		protected SpriteBatch m_SpriteBatch = null;

		/// <summary>
		/// The Texture that the sprite will use.
		/// </summary>
		protected Texture2D m_Texture;

		/// <summary>
		/// The name used to load the Texture, relative to the root directory.
		/// </summary>
		protected String m_TextureName;

		/// <summary>
		/// The Color to be applied to the sprite. Defaults to Color.White.
		/// </summary>
		protected Color m_Color = Color.White;

		/// <summary>
		/// The origin of rotation of the sprite. Default is Upper left (Vector.Zero).
		/// </summary>
		protected Vector2 m_RotationOrigin = Vector2.Zero;

		/// <summary>
		/// The amount of rotation to apply to the sprite. Defaults to 0
		/// </summary>
		protected float m_Rotation = 0;

		/// <summary>
		/// The SpriteEffect for the EntitySprite.
		/// </summary>
		protected SpriteEffects m_SpriteEffect = SpriteEffects.None;

		/// <summary>
		/// The Layer Depth of the sprite. This affects what is drawn in front of it. 0 = front, 1 = back.
		/// Defaults to 0
		/// </summary>
		protected float m_LayerDepth = 0;

		/// <summary>
		/// The blend mode to be used on the sprite. Can be either None, Additive, or AlphaBlend.
		/// Defaults to SpriteBlendMode.None
		/// </summary>
		protected SpriteBlendMode m_BlendMode = SpriteBlendMode.None;

		#endregion

		#region Properties

		/// <summary>
		/// Gets/Sets the position of the sprite on the screen. Defaults to Vecter2.Zero
		/// </summary>
		public Vector2 Position
		{
			get { return new Vector2(m_Destination.X, m_Destination.Y); }
			set
			{
				m_Destination.X = (int)value.X;
				m_Destination.Y = (int)value.Y;
			}
		}

		/// <summary>
		/// Gets/Sets the X position of the Entity.
		/// </summary>
		public int X
		{
			get { return m_Destination.X; }
			set { m_Destination.X = value; }
		}

		/// <summary>
		/// Gets/Sets the Y position of the Entity.
		/// </summary>
		public int Y
		{
			get { return m_Destination.Y; }
			set { m_Destination.Y = value; }
		}

		/// <summary>
		/// Gets/Sets the width of the Entity.
		/// </summary>
		public int Width
		{
			get { return m_Destination.Width; }
			set { m_Destination.Width = value; }
		}

		/// <summary>
		/// Gets/Sets the height of the Entity.
		/// </summary>
		public int Height
		{
			get { return m_Destination.Height; }
			set { m_Destination.Height = value; }
		}

		/// <summary>
		/// Gets the destination rectangle of the sprite on the screen. 
		/// Defaults to Rectangle.Empty and is set to width and height 
		/// of the Texture upon load.
		/// </summary>
        public Rectangle Destination { get { return m_Destination; } set { m_Destination = value; } }

		/// <summary>
		/// Gets/Sets the center point of the EntitySprite's Texture.
		/// </summary>
		public Vector2 TextureCenter
		{
			get { return m_TextureCenter; }
			set { m_TextureCenter = value; }
		}

		/// <summary>
		/// Gets/Sets the bounding sphere radius of the EntitySprite's Texture
		/// </summary>
		public float Radius
		{
			get { return m_Radius; }
			set { m_Radius = value; }
		}

		/// <summary>
		/// Gets/Sets the SpriteBatch object used to draw the sprite. Defaults to null. Will be ignored 
		/// if the SpriteBatch is passed as a draw parameter
		/// </summary>
		public virtual SpriteBatch SpriteBatch
		{
			get { return m_SpriteBatch; }
			set { m_SpriteBatch = value; }
		}

		/// <summary>
		/// Gets/Sets the Texture that the sprite will use
		/// </summary>
		public Texture2D Texture
		{
			get { return m_Texture; }
			set { m_Texture = value; }
		}

		/// <summary>
		/// Gets/Sets the name used to load the Texture, relative to the root directory
		/// </summary>
		public String TextureName
		{
			get { return m_TextureName; }
			set { m_TextureName = value; }
		}

		/// <summary>
		/// Gets/Sets the Color to be applied to the sprite. Defaults to Color.White
		/// </summary>
		public Color Color
		{
			get { return m_Color; }
			set { m_Color = value; }
		}

		/// <summary>
		/// Gets/Sets the origin of rotation of the sprite. Default is Upper left (Vector.Zero)
		/// </summary>
		public Vector2 RotationOrigin
		{
			get { return m_RotationOrigin; }
			set { m_RotationOrigin = value; }
		}

		/// <summary>
		/// Gets/Sets the amount of rotation to apply to the sprite. Defaults to 0
		/// </summary>
		public float Rotation
		{
			get { return m_Rotation; }
			set { m_Rotation = value; }
		}

		/// <summary>
		/// Gets/Sets the SpriteEffect for the EntitySprite
		/// </summary>
		public SpriteEffects SpriteEffect
		{
			get { return m_SpriteEffect; }
			set { m_SpriteEffect = value; }
		}

		/// <summary>
		/// Gets/Sets the Layer Depth of the sprite. This affects what is drawn in front of it. 0 = front, 1 = back.
		/// Defaults to 0
		/// </summary>
		public float LayerDepth
		{
			get { return m_LayerDepth; }
			set { m_LayerDepth = value; }
		}

		/// <summary>
		/// Gets/Sets the blend mode to be used on the sprite. Can be either None, Additive, or AlphaBlend.
		/// Defaults to SpriteBlendMode.None
		/// </summary>
		public SpriteBlendMode BlendMode
		{
			get { return m_BlendMode; }
			set { m_BlendMode = value; }
		}

		#endregion

		#region Creation

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="p_Content">Reference to the current content manager.</param>
		/// <param name="p_TextureName">The texture that the sprite will use.</param>
		public EntitySprite(ContentManager p_Content, String p_TextureName)
		{
			Content = p_Content;
			m_TextureName = p_TextureName;
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="p_Content">Reference to the current content manager.</param>
		/// <param name="p_TextureName">The Texture2D that the sprite will use.</param>
		/// <param name="p_Position">The Position of the sprite on the screen.</param>
		public EntitySprite(ContentManager p_Content, String p_TextureName, Vector2 p_Position)
		{
			Content = p_Content;
			m_TextureName = p_TextureName;
			Position = p_Position;
		}

		#endregion

		#region Management

		/// <summary>
		/// Loads necessary info for content dependent objects
		/// </summary>
		protected override void LoadContent()
		{
			m_Texture = Content.Load<Texture2D>(m_TextureName);
			m_TextureCenter = new Vector2(m_Texture.Width >> 1, m_Texture.Height >> 1);
			m_Radius = Vector2.Distance(Vector2.Zero, m_TextureCenter);
			m_Destination.Width = m_Texture.Width;
			m_Destination.Height = m_Texture.Height;
			base.LoadContent();
		}

		#endregion

		#region Render

		/// <summary>
		/// The draw method that will be called by XNA during the Draw cycle.
		/// </summary>
		/// <param name="gameTime">The current game time. Passed in by XNA.</param>
		public override void Draw(GameTime gameTime)
		{
			GraphicsDevice.RenderState.DepthBufferEnable = true;
			GraphicsDevice.RenderState.DepthBufferFunction = CompareFunction.Always;
			GraphicsDevice.RenderState.FillMode = FillMode.Solid;

			m_SpriteBatch.Begin(m_BlendMode);
			m_SpriteBatch.Draw(m_Texture, m_Destination, null, m_Color, m_Rotation, m_RotationOrigin, m_SpriteEffect, m_LayerDepth);
			m_SpriteBatch.End();
		}

		#endregion
	}
}