/*
 * Animation.cs
 * Authors: August Zinsser, 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.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace MaritimeDefender
{
    /// <summary>
    /// Used to store and manage the frames of multiple animations.
    /// All frames must be the same size and are assumed to go left to right, top to bottom.
    /// Objects that use this class can get the appropriate texture2D at any time. They also must update this class regularly.
    /// </summary>
    public class Animation
    {
        /// <summary>
        /// Stores all information needed for one specific animation
        /// </summary>
        private class Clip
		{
			#region Fields

			/// <summary>
			/// Stores a sprite sheet containing all the frames of this animation. 
			/// Sheets are read left to right, top to bottom like a book. 
			/// There must also be no holes.
			/// </summary>
            public Texture2D SpriteSheet; 
            
			/// <summary>
			/// Number of frames of this animation.
			/// </summary>
			public int Frames; 
            
			/// <summary>
			/// Which frame to start on
			/// </summary>
			public int FrameOffset;
            
			/// <summary>
			/// Delay in seconds between each frame.
			/// </summary>
			public float Delay; 
			
			/// <summary>
			/// Frame currently being displayed.
			/// </summary>
			public int CurrentFrame;

			#endregion

			#region IncrementFrame

			/// <summary>
            /// Increments the current frame and automatically wraps around to 0 as necessary
            /// </summary>
            public void IncrementFrame()
            {
				if (++CurrentFrame >= Frames)
				{
					CurrentFrame = FrameOffset;
				}
			}

			#endregion
		}

		#region Fields

		// Stores all particular animations, keyed by their names
        private readonly Dictionary<string, Clip> mClips = new Dictionary<string, Clip>();

		// The clip currently being displayed  
        private Clip mCurrentClip;

		// Size of every frame (in source image pixels)
        private Vector2 mSize;

		// Stops the cycling of animations
        private bool mPaused;

		// Used to keep track of when to update a frame
        private float mFrameUpdateCounter;

		#endregion

		#region Properties

		/// <summary>
		/// Whether or not the animation is currently paused
		/// </summary>
        public bool Paused { set { mPaused = value; } get { return mPaused; } }

        /// <summary>
        /// Returns a new Texture2D with the current frame's image if the current clip is only 1 frame, else null.
        /// </summary>
        public Texture2D CurrentFrameCopy
        {
            get
            {
				if (mCurrentClip != null /*&& (int)mSize.X > 1*/)
				{
					// Check if the clip has multiple frames
					if (mCurrentClip.Frames == 1)
					{
						// This is a still clip, so just return the whole sheet
						return mCurrentClip.SpriteSheet;
					}
				}
            	return null;
            }
        }
        /// <summary>
        /// Returns a reference to the sprite sheet of the current frame.
        /// </summary>
        public Texture2D CurrentSpriteSheet { get { return mCurrentClip != null ? mCurrentClip.SpriteSheet : null; } }

        /// <summary>
        /// Returns the width of each frame
        /// </summary>
        public float Width { get { return mSize.X; } }

        /// <summary>
        /// Returns the height of each frame
        /// </summary>
        public float Height { get { return mSize.Y; } }

		#endregion

		#region Creation

		/// <summary>
        /// Default Constructor
        /// </summary>
        private Animation()
        {
        }

        /// <summary>
        /// Initialize the animation and set the size of each frame
        /// </summary>
        /// <param name="frameSize">Size of each frame in source pixels</param>
        public Animation(Vector2 frameSize)
            : this()
        {
            mSize = frameSize;
        }

        /// <summary>
        /// Initialize the animation and set the size of each frame
        /// </summary>
        /// <param name="frameHeight">Height of each frame</param>
        /// <param name="frameWidth">Width of each frame</param>
        public Animation(float frameWidth, float frameHeight)
            : this (new Vector2(frameWidth, frameHeight))
        { }

		#endregion

		#region Update

		/// <summary>
		/// Cycles through frames as appropriate
		/// </summary>
        /// <param name="gameTime">Time that has passed in game</param>
        public void Update(GameTime gameTime)
        {
        	if (mCurrentClip == null || mPaused || mCurrentClip.Delay == 0)
        	{
        		return;
        	}
        	// See if it is time to transition to the next frame
        	mFrameUpdateCounter -= (float)gameTime.ElapsedGameTime.TotalSeconds;
        	while (mFrameUpdateCounter <= 0)
        	{
        		// Update to the next frame
        		mCurrentClip.IncrementFrame();
        		mFrameUpdateCounter += mCurrentClip.Delay;
        	}
		}

		#endregion

		#region Render

		/// <summary>
		/// Draws the current frame to the given sprite batch using alpha blending
		/// </summary>
        /// <param name="spriteBatch">The sprite batch used for rendering textures</param>
        /// <param name="destination">The position and dimensions of the texture to draw</param>
        /// <param name="tint">The color to render the texture in</param>
        /// <param name="rotation">The degree of rotation to apply to the texture</param>
        /// <param name="spriteEffects">What effects, if any, to use when rendering the texture</param>
        /// <param name="layerDepth">Its layer of depth for z-ordering</param>
        public void Draw(SpriteBatch spriteBatch, Rectangle destination, Color tint, float rotation, 
			SpriteEffects spriteEffects, float layerDepth)
        {
            if (mCurrentClip.SpriteSheet == null)
                return;
            Rectangle slice = GetSourceRectangle();
            spriteBatch.Draw(
                mCurrentClip.SpriteSheet,
                destination,
                slice,
                tint,
                rotation,
                new Vector2(slice.Width >> 1, slice.Height >> 1),
                spriteEffects,
                layerDepth
            );
		}

		#endregion

		#region AddClip

		/// <summary>
		/// Creates a new clip that can be used for animation
		/// </summary>
		/// <param name="name">Identifier of the clip</param>
		/// <param name="spriteSheet">Spritesheet containing the frames of the clip</param>
		/// <param name="frames">Number of frames for this clip</param>
		/// <param name="frameDelay">Seconds to wait before advancing to the next frame</param>
		public void AddClip(string name, Texture2D spriteSheet, int frames, float frameDelay)
		{
			AddClip(name, spriteSheet, frames, 0, frameDelay);
		}

		/// <summary>
		/// Creates a new clip that can be used for animation
		/// </summary>
		/// <param name="name">Identifier of the clip</param>
		/// <param name="spriteSheet">Spritesheet containing the frames of the clip</param>
		/// <param name="frames">Number of frames for this clip</param>
		/// <param name="frameOffset">First frame of this clip (0-indexed)</param>
		/// <param name="frameDelay">Seconds to wait before advancing to the next frame</param>
		public void AddClip(string name, Texture2D spriteSheet, int frames, int frameOffset, float frameDelay)
		{
			Clip newClip = new Clip();
			newClip.Frames = frames;
			newClip.Delay = frameDelay;
			newClip.SpriteSheet = spriteSheet;
			newClip.FrameOffset = frameOffset;
			newClip.CurrentFrame = frameOffset;
			mClips.Add(name, newClip);
		}

		#endregion

		#region Play

		/// <summary>
		/// Changes the selected animation. Does not affect the Paused state of this animation.
		/// </summary>
		/// <param name="clipName">Path name for the clip file</param>
		public void Play(string clipName)
		{
			if (mClips.ContainsKey(clipName))
			{
				mCurrentClip = mClips[clipName];
			}
		}

		#endregion

		#region Getters

		/// <summary>
        /// Generates a rectangle with the location and size of the current frame
        /// </summary>
		/// <returns>A rectangle with the location and size of the current frame</returns>
        private Rectangle GetSourceRectangle()
        {
            int col = mCurrentClip.CurrentFrame;
            int row = 0;
            // See if the frame index has wrapped past the first row
            while (col * mSize.X >= mCurrentClip.SpriteSheet.Width)
            {
                col -= (int)(mCurrentClip.SpriteSheet.Width / mSize.X);
                ++row;
            }
            return new Rectangle(col * (int)mSize.X, row * (int)mSize.Y, (int)mSize.X, (int)mSize.Y);
		}

		#endregion
	}
}