/*
 * EntitySpawnable.cs
 * Author: Mike DeMauro
 * 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 tAC_Engine.Graphics.Entities;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Random=Util.Random;

namespace StellarProspector
{

    /// <summary>
    /// An EntitySprite with states, times, and spawning limits.
    /// </summary>
    internal class EntitySpawnable : EntitySprite
    {
        /// <summary>
        /// Different states to label functionality of an EntitySpawnable
        /// </summary>
        public enum SpawnableState
        {
            /// <summary>
            /// The spawnable is currently dead
            /// </summary>
            Dead, 
            /// <summary>
            /// The spawnable is currently alive
            /// </summary>
            Alive, 
            /// <summary>
            /// The spawnable is currently waiting to spawn
            /// </summary>
            Waiting, 
            /// <summary>
            /// The spawnable is currently being collected/removed
            /// </summary>
            Suspended
        }

        #region Fields

        /// <summary>
        /// The current state of the EntitySpawnable.
        /// </summary>
        protected SpawnableState mState = SpawnableState.Dead;

        /// <summary>
        /// The origin of the spawning circle in SpriteBatch coordinates.
        /// </summary>
        protected Vector2 mOrigin = Vector2.Zero;

        /// <summary>
        /// The angle in degrees that this spawnable is located at
        /// </summary>
        protected double mTheta;

        /// <summary>
        /// The length of time to display
        /// </summary>
        protected double mLifeTime;

        /// <summary>
        /// The maximum length of time to display
        /// </summary>
        protected double mMaxLifeTime;

        /// <summary>
        /// The length of time to wait before spawning
        /// </summary>
        protected double mWaitTime;

        /// <summary>
        /// The maximum length of time to wait before spawning
        /// </summary>
        protected double mMaxWaitTime = double.PositiveInfinity;

        /// <summary>
        /// The minimum length of time to wait before spawning
        /// </summary>
        protected double mMinWaitTime;

        /// <summary>
        /// The angle of each sector
        /// </summary>
        protected double mSectorAngle = MathHelper.PiOver4;

        /// <summary>
        /// The sector the entity is currently in
        /// </summary>
        protected int mSector;

        /// <summary>
        /// The distance in pixels from the center this spawnable is located at
        /// </summary>
        protected int mRadialDistance;

        /// <summary>
        /// The minimum radius of the spawning circle
        /// </summary>
        protected int mMinSpawnRadius;

        /// <summary>
        /// The maximum radius of the spawning circle
        /// </summary>
        protected int mMaxSpawnRadius;

        /// <summary>
        /// The number of sectors in the spawning circle
        /// </summary>
        protected int mNumSectors;

        /// <summary>
        /// The score to collect
        /// </summary>
        protected int mProgressToCollect;

        #endregion

        #region Properties

        /// <summary>
        /// Gets the angle in degrees that this spawnable is located at
        /// </summary>
        public double Theta { get { return mTheta + (double)MathHelper.PiOver2; } }

        /// <summary>
        /// Gets the sector the entity is currently in
		/// </summary>
		public int Sector { get { return mSector; } }

        /// <summary>
        /// Gets the distance in pixels from the center this spawnable is located at
        /// </summary>
        public int RadialDistance { get { return mRadialDistance; } }

        /// <summary>
        /// Gets/Sets the current state of the EntitySpawnable.
        /// </summary>
        public SpawnableState State
        {
            get { return mState; }
            set { mState = value; }
        }

        /// <summary>
        /// Gets/Sets the origin of the spawning circle in SpriteBatch coordinates.
        /// </summary>
        public Vector2 Origin
        {
            get { return mOrigin; }
            set { mOrigin = value; }
        }

        /// <summary>
        /// Gets/Sets the length of time to display.
        /// </summary>
        public double LifeTime
        {
            get { return mLifeTime; }
            set { mLifeTime = value; }
        }

        /// <summary>
        /// Gets/Sets the maximum length of time to display.
        /// </summary>
        public double MaxLifeTime
        {
            get { return mMaxLifeTime; }
            set { mMaxLifeTime = value; }
        }

        /// <summary>
        /// Gets/Sets the length of time to wait before spawning.
        /// </summary>
        public double WaitTime
        {
            get { return mWaitTime; }
            set { mWaitTime = value; }
        }

        /// <summary>
        /// Gets/Sets the maximum length of time to wait before spawning.
        /// </summary>
        public double MaxWaitTime
        {
            get { return mMaxWaitTime; }
            set { mMaxWaitTime = value; }
        }

        /// <summary>
        /// Gets/Sets the minimum length of time to wait before spawning.
        /// </summary>
        public double MinWaitTime
        {
            get { return mMinWaitTime; }
            set { mMinWaitTime = value; }
        }

        /// <summary>
        /// Gets/Sets the angle of each sector.
        /// </summary>
        public double SectorAngle
        {
            get { return mSectorAngle; }
            set { mSectorAngle = value; }
        }

        /// <summary>
        /// Gets/Sets the minimum radius of the spawning circle.
        /// </summary>
        public int MinSpawnRadius
        {
            get { return mMinSpawnRadius; }
            set { mMinSpawnRadius = value; }
        }

        /// <summary>
        /// Gets/Sets the maximum radius of the spawning circle.
        /// </summary>
        public int MaxSpawnRadius
        {
            get { return mMaxSpawnRadius; }
            set { mMaxSpawnRadius = value; }
        }

        /// <summary>
        /// Gets/Sets the number of sectors in the spawning circle.
        /// </summary>
        public int NumSectors
        {
            get { return mNumSectors; }
            set { mNumSectors = value; }
        }

        /// <summary>
        /// Gets/Sets the score to collect.
        /// </summary>
        public int ProgressToCollect
        {
            get { return mProgressToCollect; }
            set { mProgressToCollect = value; }
        }

        #endregion

        #region Creation

        /// <summary>
        /// Creates a new EntitySpawnable
        /// </summary>
        /// <param name="content">The ContentManager used to load content.</param>
        /// <param name="textureName">The name of the texture to load.</param>
        public EntitySpawnable(ContentManager content, string textureName)
            : base(content, textureName) { }

        #endregion

        #region Update

        /// <summary>
        /// Updates the EntitySpawnable. This should be called by XNA.
        /// </summary>
        /// <param name="gameTime">Amount of time that has passed in game</param>
        public override void Update(GameTime gameTime)
        {
            if (mState == SpawnableState.Alive)
            {
				mLifeTime -= gameTime.ElapsedGameTime.TotalMilliseconds;
				if (mLifeTime <= 0)
				{
					Die();
				}
            }
            else if(mState == SpawnableState.Waiting)
            {
                mWaitTime -= gameTime.ElapsedGameTime.TotalMilliseconds;
            }
            base.Update(gameTime);
        }

        #endregion

        #region State Modifiers

        /// <summary>
        /// Sets the state to Alive
        /// </summary>
        /// <param name="sectorNum">The sector number to spawn in.</param>
		/// <param name="errorEnabled">If the stimulus can spawn outside the given sector</param>
		public virtual void Spawn(int sectorNum, bool errorEnabled)
        {
			mSector = sectorNum;
            mState = SpawnableState.Alive;
        }

        /// <summary>
        /// Sets the state to Dead
        /// </summary>
        public virtual void Die()
        {
            mState = SpawnableState.Dead;
        }

        /// <summary>
        /// Sets the state to Waiting. Remains in this state until a
        /// random amount of time between MinWaitTime and MaxWaitTime has elapsed
        /// </summary>
        public void Wait()
        {
            mState = SpawnableState.Waiting;
            mWaitTime = Random.NextDouble(mMinWaitTime, mMaxWaitTime);
        }

        #endregion

        #region Calculations

        /// <summary>
        /// The angle between the stimulus' position vector on screen and the distance of the player from the screen vector
        /// </summary>
        public double Rho(double resolution)
        {
            return Math.Atan(Math.Sqrt((Util.Settings.PhysicalScreenHeight * Util.Settings.PhysicalScreenHeight) +
                (Util.Settings.PhysicalScreenHeight * Util.Settings.PhysicalScreenHeight)) *
                (mRadialDistance / resolution) / Util.Settings.PhysicalScreenDistance);
        }

        /// <summary>
        /// Calculates the angle between the stimulus' x vector on screen and the distance of the player from the screen vector
        /// </summary>
        /// <param name="xResolution">The width of the screen in pixels</param>
        /// <param name="xOffset">The offset from the top of the screen to the origin</param>
        /// <returns>The angle between the stimulus' x vector on screen and the distance of the player from the screen vector</returns>
        public double AzimuthPhi(int xResolution, float xOffset)
        {
            return Math.Atan(Util.Settings.PhysicalScreenWidth * (X - xOffset) / Util.Settings.PhysicalScreenDistance);
        }

        /// <summary>
        /// Calculates the angle between the stimulus' y vector on screen and the distance of the player from the screen vector
        /// </summary>
        /// <param name="yResolution">The height of the screen in pixels</param>
        /// <param name="yOffset">The offset from the of the left edge of the screen to the origin</param>
        /// <returns>The angle between the stimulus' y vector on screen and the distance of the player from the screen vector</returns>
        public double ElevationLambda(int yResolution, float yOffset)
        {
            return Math.Atan(Util.Settings.PhysicalScreenHeight * (Y - yOffset) / Util.Settings.PhysicalScreenDistance);
        }

        #endregion
    }
}