//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="Particle.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace DarkWynter.Engine.GameObjects
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    using Microsoft.Xna.Framework.Storage;
    using System.Diagnostics;
    using System.Xml;    
    #endregion

    using Globals;
    using Physics;
    using ObjectLib;
    using GameObjects;
    using DarkWynter.Engine.Init;
    using DarkWynter.Stream;

    /// <summary>
    /// Particle game object
    /// </summary>
    public class Particle : GameObject
    {
        #region Properties
        double angle = 0.0;

        /// <summary>
        /// Particle-type Enumeration
        /// </summary>
        public Enums_Engine.ParticleType particleType;

        /// <summary>
        /// Number of collisions
        /// </summary>
        public int hasCollided = -1;
        /// <summary>
        /// Time after last collision occured
        /// </summary>
        public Stopwatch hasCollidedTimer = new Stopwatch();

        /// <summary>
        /// ID of player who fired this particle
        /// </summary>
        public int ownerID = -1;
        /// <summary>
        /// Is the particle allowed to hurt the player who fired it
        /// </summary>
        public bool hurtOwner = false;
        private Stopwatch hurtOwnerTimer = new Stopwatch();

        private float waveRadius = 0.0f;

        List<Billboard> billboards = new List<Billboard>();
        int smokeCounter = 0;
        #endregion

        #region Construction Methods
        /// <summary>
        /// Constructor
        /// </summary>
        public Particle(Load gameObjectLoader):base(gameObjectLoader)
        {
            mass.objectType = Enums_Engine.ObjectType.PARTICLE;
            mass.gameObjectPointer = this;

            mass.boundingVolume = new BoundingVolume(new BoundingSphere(mass.currentPosition, 2.0f));
            mass.objectHeight = mass.boundingVolume.radius;

            mass.mass = Statics_Engine.ParticleSettings.Water.WATER_MASS;
            mass.COR = Statics_Engine.ParticleSettings.Water.WATER_COLD_COR;
            mass.dynamicFrictionCoefficient = Statics_Engine.ParticleSettings.Water.WATER_COLD_FRICTION;
            mass.energy = 1.0f;
            mass.isMoving = true;
            
            waveRadius = 1.0f;
            hasCollided = -1;
            hurtOwner = false;
            hurtOwnerTimer = Stopwatch.StartNew();

            collisionWithPlayerResponse = Enums_Engine.CollisionResponses.HEALTHLOSS;
        }

        /// <summary>
        /// Load particle info from XML
        /// </summary>
        /// <param name="node">Particle node</param>
        /// <param name="objectLibrary">ObjectLibrary</param>
        /// <returns>True if load was successful</returns>
        public override bool Load(ObjectLibrary objectLibrary)
        {
            // Set up Model
            bool success = LoadModel(load.node);

            // Return unsuccessfully if can't load user supplied XML data
            if (!success) 
            { return false; }

            draw.drawMethod = Enums_Stream.DrawMethod.BasicGameObject_Draw;
            drawBoundingVolume = draw;
            draw.technique = "BasicLightingShaderMain";
            drawBoundingVolume.technique = "ShieldShaderMain";

            // Start Type properties
            objectModelName = load.node.Attributes["name"].Value;

            // Add Sprite Textures
            draw.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/Fire"));
            draw.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/Wind"));
            drawBoundingVolume.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/whitesquare"));
            drawBoundingVolume.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>("Content/_textures/Wind"));

            mass.scale = new Vector3(float.Parse(load.node.Attributes["maxScale"].Value));
            mass.mass = float.Parse(load.node.Attributes["mass"].Value);
            mass.isMoving = false;

            isCollectable = bool.Parse(load.node.Attributes["isCollectable"].Value);
            isKey = bool.Parse(load.node.Attributes["isKey"].Value);

            if (isKey)
            {
                collisionWithPlayerResponse = Enums_Engine.CollisionResponses.HEALTHBONUS;
            }

            return true;
        }
        /// <summary>
        /// Prepare to fire the particle
        /// </summary>
        /// <param name="playerID">ID of player who fired this particle</param>
        /// <param name="type">Type of particle</param>
        /// <param name="initialPosition">Starting position</param>
        /// <param name="direction">Normal direction of particle</param>
        /// <param name="particleMassValue">Mass of particle</param>
        /// <param name="particleThermalValue">Themal value of particle</param>
        public void PrepAttack(int playerID, Enums_Engine.ParticleType type, Vector3 initialPosition, Vector3 direction, int particleMassValue, int particleThermalValue)
        {
            particleType = type;
            mass.AddForce(direction * Statics_Engine.PlayerSettings.DIRECT_ATTACK_FORCE);
            mass.SetPosition(initialPosition + (Statics_Engine.PlayerSettings.PARTICLE_START_DISTANCE * direction), 
                             initialPosition + ((Statics_Engine.PlayerSettings.PARTICLE_START_DISTANCE + 10) * direction));
            mass.lastPosition = Vector3.Zero + initialPosition;
            ownerID = playerID;

            direction.Normalize();
            mass.normalVector = Vector3.Zero + direction;

            // Scale size of particle; Apply DPad Values between 1 and 75
            mass.scale = new Vector3(particleMassValue / 2250.0f + 3);
            mass.boundingVolume.radius = mass.scale.Y;
            mass.boundingVolume.UpdateSphere(mass.currentPosition);

            // Change Engergy of particle; Shift from 0 to 100 to -1 to 1
            mass.energy = ((float)particleThermalValue * 2 - 75) / 75;
            if (mass.energy != 0.0f) { mass.isChanging = true; }
        }
        #endregion

        #region Update Methods
        /// <summary>
        /// Update our particle object
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        public override void Update(ref ObjectLibrary objectLibrary)
        {
            mass.Update();
            mass.boundingVolume.UpdateSphere(mass.currentPosition);

            //Update COR based on energy level
            mass.COR = Statics_Engine.ParticleSettings.Wind.WIND_COLD_COR - ((mass.energy / 2.0f) + 0.5f) * (Statics_Engine.ParticleSettings.Wind.WIND_COLD_COR - Statics_Engine.ParticleSettings.Wind.WIND_HOT_COR);
            mass.dynamicFrictionCoefficient = Statics_Engine.ParticleSettings.Wind.WIND_COLD_FRICTION - ((mass.energy / 2.0f) + 0.5f) * (Statics_Engine.ParticleSettings.Wind.WIND_COLD_FRICTION - Statics_Engine.ParticleSettings.Wind.WIND_HOT_FRICTION);
            mass.Rotate(0.0f, 0.2f);

            // Send properties and control signal to gpu
            Vector4 gpu_particleType = new Vector4(0);
            if (this.particleType == Enums_Engine.ParticleType.Earth) { gpu_particleType.Y = 0.0f; }      // Earth = x0xx
            if (this.particleType == Enums_Engine.ParticleType.Water) { gpu_particleType.Y = 1.0f; }      // Water = x1xx
            if (this.particleType == Enums_Engine.ParticleType.Air) { gpu_particleType.Y = 2.0f; }        // Gas   = x2xx
            gpu_particleType.Z = (mass.energy / 2.0f) + 0.5f;                                // Fire  = xxNx
            gpu_particleType.W = waveRadius;
        }
        #endregion

        #region Collision Responses
        /// <summary>
        /// Add Particle specific responses to an object to object collision involving this and collidedObject
        /// </summary>
        /// <param name="collidedObject">Object colliding with this object</param>
        /// <param name="resultantForce">Resultant force of collision</param>
        /// <param name="objectLibrary">ObjectLibrary</param>
        /// <returns>True = this object needs to be recycled</returns>
        public override bool ObjectCollisionResponse(GameObject collidedObject, Vector3 resultantForce, ObjectLibrary objectLibrary)
        {
            mass.AddForce(resultantForce);

            if (collidedObject.mass.objectType == Enums_Engine.ObjectType.PLAYER)
            {
                // Add Player specific responses to the collided player


                // Remove this object
                return true;
            }

            return false;
        }
        /// <summary>
        /// Add Particle specific responses to an object to terrain collision involving this
        /// </summary>
        /// <param name="terrain">Terrain</param>
        public override void TerrainCollisionResponse(Terrain terrain)
        {
            base.GetObjectHeight(terrain);

            // Add Gravity if terrain and player are touching
            if (heightDifference < 0.0f)
            {
                mass.AddForce(mass.mass * Statics_Engine.GameSettings.accelDueToGravity);
            }
            else if (heightDifference > 0.0f)
            {
                // Call base first
                base.TerrainCollisionResponse(terrain);

                if (combinedNormalForce.Y < 0.0f)
                {
                    mass.AddForce(-combinedNormalForce);
                }
                else
                {
                    mass.AddForce(-velocityNormalComponent);
                }

                mass.AddForce(heightDifference * surfaceNormal * terrain.particleSurfaceTension * mass.COR);

                if (combinedTangentialForce.Length() >= 0.5f)
                {
                    mass.AddForce(mass.mass * -gravityTangentialComponent);

                    mass.AddFriction(mass.dynamicFrictionCoefficient + terrain.mass.dynamicFrictionCoefficient,
                                     Vector3.Distance((mass.mass * gravityNormalComponent), totalForceNormalComponent),
                                     combinedTangentialForce);
                }
                else
                {
                    mass.AddForce(mass.mass * -velocityTangentialComponent / Statics_Engine.SystemSettings.dt);
                    mass.AddForce(-totalForceTangentialComponent);
                }
            }
        }
        #endregion

        #region Draw Methods
        /// <summary>
        /// Draw the particle object
        /// </summary>
        public override Draw Draw()
        {
            // Calculate ObjectSpace(Rotation) and WorldSpace(Translation) Transformation Matrix
            draw.matrix = draw.initialTransform * 
                          Matrix.CreateScale(mass.scale) *
                          Matrix.CreateFromQuaternion(mass.currentRotation) *
                          Matrix.CreateTranslation(mass.currentPosition);

            return draw;
        }
        /// <summary>
        /// Draw the particle's bounding sphere around it
        /// </summary>
        public void DrawBoundingSphere()
        {
            drawBoundingVolume.matrix = drawBoundingVolume.initialTransform * 
                                        Matrix.CreateScale(mass.boundingVolume.radius) *
                                        Matrix.CreateFromQuaternion(mass.currentRotation) *
                                        Matrix.CreateTranslation(mass.currentPosition);

            float[] color = { 1, 1, 1, 1 };
            ShaderParameters.DrawFX.materialDiffuse.SetValue(color);

            drawBoundingVolume.DoDraw();
        }
        /// <summary>
        /// Draw any billboard associated with this particle
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        /// <param name="gameObjectBillboards">List of Billboards</param>
        public override void Draw_Billboards(ObjectLibrary objectLibrary, BillboardList gameObjectBillboards)
        {
            float radius = 10.0f;
            
            // Trig Position Cycle
            angle += 0.1;
            if (angle > Math.PI * 2.0f) 
            { angle = 0.0f; }
 
            Random random = new Random();
            Vector3 offset = new Vector3(
                (float) (radius * Math.Cos(angle)), 
                0.0f, 
                (float) (radius * Math.Cos(angle))
                );

            if( billboards.Count < 10)
            {
                Billboard billboard = new Billboard(null);
                billboard.Load(mass.currentPosition + offset, Vector3.Zero, 15.0f, 15.0f, draw.textureList[0]);

                //billboard.Load(mass.currentPosition + offset, Vector3.Zero, 15.0f, 15.0f, Engine.DarkWynterEngine.video.CurrentTexture);
                
                billboards.Add(billboard);
            }
            else
            {
                // Remove next billboard
                Billboard billboard = billboards[smokeCounter];
                billboards.RemoveAt(smokeCounter);
                smokeCounter++;

                // Recycle counter
                if (smokeCounter == 5)
                    smokeCounter = 0;

                billboard.Position = mass.currentPosition + offset;
                billboard.Load(mass.currentPosition + offset, Vector3.Zero, 15.0f, 15.0f, draw.textureList[0]);
                //billboard.SetTexture(Engine.DarkWynterEngine.video.CurrentTexture);
                billboards.Add(billboard);
            }

            // Add a billboard texture above the particle
            gameObjectBillboards.AddRange(billboards); 
        }
        #endregion
    }
}