/*
 * PointEmitter.cs
 * Authors: Brian Murphy
 * 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 Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Random=Util.Random;

namespace TACParticleEngine.Emitters
{
    /// <summary>
    /// This class is an emitter that performs a "burst" effect from a single emitter point
    /// </summary>
    public class PointEmitter : Emitter
	{
		#region Fields

        // Temporary vector used in setting the velocity of the next particle
        private Vector3 mTempVel;

        // Temporary int used for storing how many particles were created every cycle
        private int mTempAmount;

        // Temporary integer for use in iterating over the particle heap
        private int mTempIndex;

        // Current index of the next available spot in the head for adding a particle to
        private int mCurrentIndex;

        // Float used for determining
        private float mTotalElapsedTime;

		#endregion

		#region Form Fields

		// Current position of the emitter
		private Vector3 mEmitterPosition;

		#endregion

		#region Properties

		/// <summary>
		/// Sets the direction of the emitter, does nothing for this emitter
		/// </summary>
		public override Vector3 Direction { get { return Vector3.Zero; } set { } }

		#endregion

		#region Form Properties

		/// <summary>
		/// Gets/Sets the current position of the emitter
		/// </summary>
		public override Vector3 EmitterPosition
		{
			get { return mEmitterPosition; }
			set { mEmitterPosition = value; }
		}

		#endregion

		#region Creation

		/// <summary>
		/// Default constructor for use in the Particle Editor
		/// </summary>
		public PointEmitter()
			: base(SpriteBlendMode.AlphaBlend, "", 100, 1000, -1, 1, Vector2.One, Vector2.One, Vector2.One,
			new Vector2(500, 500), 0, 0, 0, 0, Vector4.One, Vector4.One, Vector4.Zero, Vector4.Zero)
		{
			mCurrentIndex = 0;
			mEmitterPosition = Vector3.Zero;
			mTotalElapsedTime = 0;
		}

		/// <summary>
        /// Constructor
        /// </summary>
        /// <param name="position">Initial position to start at</param>
        /// <param name="blendEffect">SpriteBlendMode to use</param>
        /// <param name="textureName">Name of the texture to draw with</param>
        /// <param name="particlesPerSec">How many particles per second are made</param>
        /// <param name="particleAmount">The max amount of particles available at one time</param>
        /// <param name="emitLifetime">How long the emitter stays active for</param>
        /// <param name="particleLifetime">How long the patrticle stays active for</param>
        /// <param name="minStartSize">How small a particle can start</param>
        /// <param name="maxStartSize">How large a particle can start</param>
        /// <param name="minEndSize">How small a particle can end</param>
        /// <param name="maxEndSize">How large a particle can end</param>
        /// <param name="minStartSpeed">How slow a particle can start</param>
        /// <param name="maxStartSpeed">How fast a particle can start</param>
        /// <param name="minEndSpeed">How slow a particle can end</param>
        /// <param name="maxEndSpeed">How fast a particle can end</param>
        /// <param name="minStartColor">Minimum values for color to start with</param>
        /// <param name="maxStartColor">Maximum values for color to start with</param>
        /// <param name="minEndColor">Minimum values for color to end with</param>
        /// <param name="maxEndColor">Maximum values for color to end with</param>
        public PointEmitter(Vector3 position, SpriteBlendMode blendEffect, string textureName,
			float particlesPerSec, int particleAmount, float emitLifetime, float particleLifetime, 
            Vector2 minStartSize, Vector2 maxStartSize, Vector2 minEndSize, Vector2 maxEndSize,
            float minStartSpeed, float maxStartSpeed, float minEndSpeed, float maxEndSpeed,
            Vector4 minStartColor, Vector4 maxStartColor, Vector4 minEndColor, Vector4 maxEndColor)
            : base(blendEffect, textureName, particlesPerSec, particleAmount, emitLifetime,
            particleLifetime, minStartSize, maxStartSize, minEndSize, maxEndSize, minStartSpeed, maxStartSpeed, 
			minEndSpeed, maxEndSpeed, minStartColor, maxStartColor, minEndColor, maxEndColor)
        {
            mCurrentIndex = 0;
            mEmitterPosition = position;
            mTotalElapsedTime = 0;
        }

		/// <summary>
		/// Returns a copy of the point emitter
		/// </summary>
		/// <returns>A cloned copy of this point emitter</returns>
		public override object Clone()
		{
			PointEmitter retVal = new PointEmitter(Vector3.Zero, base.mBlendEffect, base.mTextureName, base.mParticlesPerSec,
				base.mParticleAmount, base.mEmitLifetime, base.mParticleLifetime, base.mMinStartSize,
				base.mMaxStartSize, base.mMinEndSize, base.mMaxEndSize, base.mMinStartSpeed, base.mMaxStartSpeed,
				base.mMinEndSpeed, base.mMaxEndSpeed, base.mMinStartColor, base.mMaxStartColor, base.mMinEndColor,
				base.mMaxEndColor);
			retVal.mTexture = mTexture;
			return retVal;
		}

		#endregion

		#region Update

		/// <summary>
        /// Updates point emitter
        /// </summary>
        /// <param name="elapsedTime">The time elapsed since last tick in milliseconds</param>
        public override void Update(float elapsedTime)
        {
			if (base.mParticles != null)
			{
				base.Update(elapsedTime);
                if (base.Alive && base.IsActive)
				{
					mTotalElapsedTime += elapsedTime;

					mTempAmount = (int)(mTotalElapsedTime * base.mParticlesPerSec);
					if (mTempAmount > 0)
					{
						mTempIndex = (mCurrentIndex + mTempAmount) % base.mParticles.Length;
						if (mCurrentIndex + mTempAmount < base.mParticles.Length)
						{
							for (; mCurrentIndex < mTempIndex; mCurrentIndex++)
							{
								CalcDirection();
								base.InitializeParticle(mEmitterPosition, mTempVel, mCurrentIndex);
							}
						}
						else
						{
							for (; mCurrentIndex < base.mParticles.Length; mCurrentIndex++)
							{
								CalcDirection();
								base.InitializeParticle(mEmitterPosition, mTempVel, mCurrentIndex);
							}
							mCurrentIndex = 0;
							for (; mCurrentIndex < mTempIndex; mCurrentIndex++)
							{
								CalcDirection();
								base.InitializeParticle(mEmitterPosition, mTempVel, mCurrentIndex);
							}
						}
						mTotalElapsedTime = 0;
					}
				}
			}
		}

		#endregion

		#region Util

		/// <summary>
        /// Determines a random direction the next particle will go in
        /// </summary>
		private void CalcDirection()
		{
			mTempVel.X = Random.NextFloat(-1, 1);
			mTempVel.Y = Random.NextFloat(-1, 1);
			mTempVel.Z = Random.NextFloat(-1, 1);
			mTempVel.Normalize();
		}

		#endregion
	}
}