using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace CarFire
{
    /*
    /// <summary>
    /// A type for the states of an artificually intelligent entity.
    /// </summary>
    public enum AiState
    {
        Standing,
        Pacing,
        Chasing,
        Dazed,
        Fighting,
        Retreating
    }
    */

    /// <summary>
    /// An example monster.  This can serve as a starting place for
    /// creating other monsters.  This one just follows a path.
    /// </summary>
    public class SaberMonster : IMonster
    {
        //starting health
        int health = 100;
        /// <summary>
        /// Construct this type of monster.  This constructor is called
        /// by the map when the game requests entities.
        /// </summary>
        /// <param name="identifier">The single character ID.</param>
        /// <param name="position">The initial position on the map.</param>
        /// <param name="info">More parameters.</param>
        /// <param name="game">The game object reference.</param>
        public SaberMonster(char identifier, Point position, Dictionary<string, string> info, Game game)
        {
            mId = identifier;
            mMotion = new MovementManager(position);
            mRetryInterval = 2 + (position.X * 25789 + position.Y * 259) % 30;

            // We need to keep the game reference in order to get the grid when we
            // need to find paths.
            mGame = game;

            // Get the speed of the monster.  If not set in the map, it defaults to
            // whatever the default of MovementManager is... 1 I think.
            string speedString;
            if (info.TryGetValue("speed", out speedString))
            {
                int? speed = Parse.Integer(speedString);
                if (speed != null) mMotion.Speed = speed.Value;
            }

            // Get the "idle path" coordinates loaded from the map.
            string idlePath;
            if (info.TryGetValue("path", out idlePath))
            {
                string[] idlePathPoints = Parse.List(idlePath);
                foreach (string pathPoint in idlePathPoints)
                {
                    Point? point = Parse.Coordinates(pathPoint);
                    if (point != null) mWaypoints.Add(point.Value);
                }
            }
            mPath = new List<Point>();

            // Start doing something...
            StartPacing();
        }
        public void DefaultAction()
        {

        }
        public void Chasing(Point Chase)
        {

        }

        /// <summary>
        /// Call this to switch the monster AI state to pacing and set up
        /// the initial paths.  The monster will start following the path it
        /// was defined with in the map file.
        /// </summary>
        public void StartPacing()
        {
            if (mWaypoints.Count == 0) return;

            mState = AiState.Pacing;

            // Determine the best (closest) waypoint to start at.
            // We may not be on the path, so we have to walk to get on it.
            mWaypointIndex = 0;
            int closest = int.MaxValue;
            for (int i = 0; i < mWaypoints.Count; i++)
            {
                int distance = PathFinder.GetManhattanDistance(Coordinates, mWaypoints[i]);
                if (distance < closest)
                {
                    mWaypointIndex = i;
                    closest = distance;
                }
            }

            // Find the path to get to the closest waypoint.
            ChartPath();
        }

        Direction GetDirectionToNextCell()
        {
            if (mPath != null)
            {
                if (mPathIndex >= mPath.Count)
                {
                    // We're done with the current path, so find the path to
                    // the next waypoint... forever.
                    mWaypointIndex++;
                    ChartPath();
                }

                // We need to make sure our direction is set to the next cell
                // we want to be.  If our current coordinates match that, we need
                // to change our direction to get to the next cell.
                else if (mPath[mPathIndex] == mMotion.Coordinates)
                {
                    mPathIndex++;
                    mPathDirection = MovementManager.GetDirection(mMotion.Coordinates, mPath[mPathIndex % mPath.Count]);
                }

                return mPathDirection;
            }
            else return Direction.None;
        }

        void ChartPath()
        {
            if (mPathSearch == null)
            {
                Point waypoint = mWaypoints[mWaypointIndex % mWaypoints.Count];
                PathFinder pathFinder = new PathFinder(mGame.Grid);
                Point? nearby = pathFinder.GetNearbyOpenCell(waypoint);
                if (nearby != null) mPathSearch = pathFinder.GetPathAsync(mMotion.Coordinates, nearby.Value);

                mPathIndex = 0;
                mPath = null;
            }
            else if (mPathSearch.IsCompleted)
            {
                mPath = (List<Point>)mPathSearch.Path;
                mPathSearch = null;

                if (mPath != null) mPathDirection = MovementManager.GetDirection(mMotion.Coordinates, mPath[0]);
            }
        }


        #region IMonster Members

        /// <summary>
        /// I don't know what this is for.
        /// </summary>
        public bool visible
        {
            get { throw new NotImplementedException(); }
        }

        #endregion


        #region ICharacter Members

        /// <summary>
        /// Load the monster's content.  This is called by the map when
        /// the game requests the entities.
        /// </summary>
        /// <param name="contentManager">The zaphnod.</param>
        public void LoadContent(ContentManager contentManager)
        {
            mTexture = contentManager.Load<Texture2D>("default");
        }

        /// <summary>
        /// Update the monster's state.  This should be called by the game
        /// every "frame" (whenever the game is updating its state).  In this
        /// simple monster, all we need to do is update the motion manager.
        /// </summary>
        /// <param name="timeSpan"></param>
        public void Update(TimeSpan timeSpan)
        {
            switch (mState)
            {
                case AiState.Pacing:

                    Direction direction = GetDirectionToNextCell();
                    Point destination = MovementManager.GetNeighbor(Coordinates, direction);

                    if (mGame.IsCellOpen(destination))
                    {
                        mMotion.Update(timeSpan, direction);
                    }
                    else
                    {
                        if (mGame.CurrentFrameNumber % mRetryInterval == 0) ChartPath();
                        mMotion.Update(timeSpan);
                    }

                    break;

                case AiState.Standing:

                    mMotion.Update(timeSpan);
                    break;
            }
        }

        /// <summary>
        /// Draw the monster.  We just ask the map for our screen position,
        /// passing it the position which the motion manager keeps track of.
        /// </summary>
        /// <param name="spriteBatch">The </param>
        public void Draw(SpriteBatch spriteBatch)
        {
            Rectangle position = mGame.State.Map.GetRectangleFromCoordinates(mMotion.Position);
            spriteBatch.Draw(mTexture, position, Color.White);
        }

        /// <summary>
        /// A monster should keep track of its health.  This one doesn't.
        /// </summary>
        public int Health
        {
            get { return this.health; }
            
        }

        /// <summary>
        /// This monster is invincible.
        /// </summary>
        /// <param name="amount"></param>
        public void causeDamageTo(int amount)
        {
            this.health -= amount;
        }

        public bool IsCollidable { get { return true; } }

        /// <summary>
        /// Get the smoothed position.
        /// </summary>
        public Vector2 Position { get { return mMotion.Position; } }

        /// <summary>
        /// Get the grid coordinates.
        /// </summary>
        public Point Coordinates {
            get { return mMotion.Coordinates; }
            set { mMotion = new MovementManager(value, mMotion.Speed); }
        }

        /// <summary>
        /// Get the entity identifier.
        /// </summary>
        public char Identifier { get { return mId; } }

        #endregion


        #region Private Variables

        Game mGame;

        char mId;
        MovementManager mMotion;

        List<Point> mWaypoints = new List<Point>();      // List of waypoints that we got from the map.
        int mWaypointIndex;                              // Index to the waypoint we're heading for.

        List<Point> mPath;                  // List of cells in the path between the position between where
                                            // we started and the waypoint we're heading for.
        int mPathIndex;                     // Index to the cell we're heading for.
        Direction mPathDirection;           // The direction between our current position and the place we're going.
        int mRetryInterval;
        PathFinder.AsyncTask mPathSearch;   // If a path search is in progress, this is the task object.

        AiState mState;                     // What is the monster doing?

        Texture2D mTexture;                 // Obvious.

        #endregion
    }
}