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;
using Microsoft.Xna.Framework.Input;

namespace CarFire
{
    public class Human : IPlayer
    {
        public enum State
        {
            left,
            right,
            up,
            down
        };
        //The number of frames between each square movements
        const int moveCoolDown = 15;
        //The number of frames between each projectile is spawned.
        const int shootCoolDown = 10;
        State state;
        String CharName;
        Map theMap;
        int gridX;
        int gridY;
        Texture2D charModel;
        Texture2D projectileModel;
        int health;
        int damage;
        int range;
        int score;
        
        //Used to smooth animations
        bool isMoving;
        float pixelX;
        float pixelY;
        int movementSteps;
        int movementCoolDown;
        float changeX;
        float changeY;

        bool visible;
        Display theDisplay;

        //Used to draw projectiles
        int projectileSpeed;
        int projectileCoolDown;
        

        public Human(Map _theMap, String Name, Texture2D model, Texture2D projectile, Display mDisplay)
        {
            theMap = _theMap;
            CharName = Name;
            theDisplay = mDisplay;
            health = 100;
            score = 0;
            visible = false;
            //default state
            state = State.up;
            charModel = model;
            projectileModel = projectile;
            projectileSpeed = 30;
            //The number of animation steps between each square movement.
            movementSteps = moveCoolDown -2;
            
        }

        public void LoadContent(ContentManager contentManager)
        {
            charModel = contentManager.Load<Texture2D>("deselectBox"); //change to charModel when designed
            projectileModel = contentManager.Load<Texture2D>("emptySelectBox"); //change to a projectile model later

        }

        public void UnloadContent()
        {

        }

        public long Update(GameTime gameTime, NetworkManager networkGame)
        {
            return 0;

        }
        /// <summary>
        /// This method will draw a character to the screen.
        /// </summary>
        /// <param name="spriteBatch"></param>
        /// <returns></returns>
        public long Draw(SpriteBatch spriteBatch)
        {
            //If the sprite is moving there are still movement animations to do.
            if (isMoving && movementSteps > 0)
            {
                movementSteps--;
                pixelX = pixelX + changeX;
                pixelY = pixelY + changeY;
                Rectangle position3 = theMap.GetRectangleFromCoordinates(new Vector2(pixelX / Map.PixelsToUnitSquares, pixelY / Map.PixelsToUnitSquares));
                spriteBatch.Draw(charModel, position3, Color.White);
            }
            // If the sprite is not moving then just draw it.
            else
            {
                pixelX = gridX * Map.PixelsToUnitSquares;
                pixelY = gridY * Map.PixelsToUnitSquares;
                changeX = 0;
                changeY = 0;
                isMoving = false;
                movementSteps = moveCoolDown - 2;
                spriteBatch.Draw(charModel, theMap.GetRectangleFromCoordinates(gridX, gridY), Color.White);
            }
            return 0;
        }

        public int GridX { get { return gridX; } set { gridX = value; } }
        public int GridY { get { return gridY; } set { gridY = value; } }
        public float PixelX { get { return pixelX; } }
        public float PixelY { get { return pixelY; } }
        public int Health { get { return health; } }
        public bool IsMoving { get { return isMoving; } }
        public int Score { get { return score; } }
        public bool alive { get { return health > 0; } }

        public void causeDamageTo(int amount)
        {
            health -= amount;
        }

        /// <summary>
        /// Moves the current player being controlled based on a given set of key presses.
        /// The player can only move one grid space per movePlayer call. Thus this method
        /// is made to be called ever update. The player will only move if the grid space
        /// that is being moved to is an open space.
        /// </summary>
        /// <param name="keysPressed">A general list of keys that are pressed. Other keys can be included but only direction keys will be used</param>
        public void MovePlayer(List<Keys> keysPressed)
        {
            if(movementCoolDown > 0)
                movementCoolDown--;
            else if (movementCoolDown == 0)
            {
                // move upleft
                keysPressed.Contains<Keys>(Keys.Left);
                if (keysPressed.Contains<Keys>(Keys.Up) && keysPressed.Contains<Keys>(Keys.Left) && theMap.IsCellOpen(gridX - 1, gridY - 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    gridX -= 1;
                    gridY -= 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                  
                    
                }
                // move upright
                else if (keysPressed.Contains<Keys>(Keys.Up) && keysPressed.Contains<Keys>(Keys.Right) && theMap.IsCellOpen(gridX + 1, gridY - 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    gridX += 1;
                    gridY -= 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    
                    
                }
                // move downleft
                else if (keysPressed.Contains<Keys>(Keys.Down) && keysPressed.Contains<Keys>(Keys.Left) && theMap.IsCellOpen(gridX - 1, gridY + 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    gridX -= 1;
                    gridY += 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    
                }
                // move downright
                else if (keysPressed.Contains<Keys>(Keys.Down) && keysPressed.Contains<Keys>(Keys.Right) && theMap.IsCellOpen(gridX + 1, gridY + 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    gridX += 1;
                    gridY += 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    
                }
                // move up
                else if (keysPressed.Contains<Keys>(Keys.Up) && theMap.IsCellOpen(gridX, gridY - 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    state = State.up;
                    gridY -= 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    changeY = (float)(-Map.PixelsToUnitSquares / moveCoolDown);
                }
                // move down
                else if (keysPressed.Contains<Keys>(Keys.Down) && theMap.IsCellOpen(gridX, gridY + 1))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    state = State.down;
                    gridY += 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    changeY = (float)(Map.PixelsToUnitSquares / moveCoolDown);
                }
                // move left
                else if (keysPressed.Contains<Keys>(Keys.Left) && theMap.IsCellOpen(gridX - 1, gridY))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    state = State.left;
                    gridX -= 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    changeX = (float)(-Map.PixelsToUnitSquares / moveCoolDown);
                }
                // move right
                else if (keysPressed.Contains<Keys>(Keys.Right) && theMap.IsCellOpen(gridX + 1, gridY))
                {
                    pixelX = (float)(gridX * Map.PixelsToUnitSquares);
                    pixelY = (float)(gridY * Map.PixelsToUnitSquares);
                    state = State.right;
                    gridX += 1;
                    movementCoolDown = moveCoolDown;
                    isMoving = true;
                    changeX = (float)(Map.PixelsToUnitSquares / moveCoolDown);
                }
            }
            if (projectileCoolDown > 0)
                projectileCoolDown--;
            else if (projectileCoolDown == 0)
            {
                if (keysPressed.Contains<Keys>(Keys.Space))
                {
                    //TODO spawn projectile... needs to be added to display though
                    if (state == State.up)
                    {
                        projectileCoolDown = shootCoolDown;
                        theDisplay.AddProjectiles(new Projectile(theMap, projectileModel, new Vector2(0, -projectileSpeed), GridX, GridY - 1));
                    }
                    if (state == State.down)
                    {
                        projectileCoolDown = shootCoolDown;
                        theDisplay.AddProjectiles(new Projectile(theMap, projectileModel, new Vector2(0, projectileSpeed), GridX, GridY + 1));
                    }
                    if (state == State.right)
                    {
                        projectileCoolDown = shootCoolDown;
                        theDisplay.AddProjectiles(new Projectile(theMap, projectileModel, new Vector2(projectileSpeed, 0), GridX + 1, GridY));
                    }
                    if (state == State.left)
                    {
                        projectileCoolDown = shootCoolDown;
                        theDisplay.AddProjectiles(new Projectile(theMap, projectileModel, new Vector2(-projectileSpeed, 0), GridX - 1, GridY));
                    }
                }
            }
        }


        public void powerUp(int amount)
        {
            health += amount;
        }

        public void Spawn(Vector2 spawn)
        {
            gridX = (int)spawn.X;
            gridY = (int)spawn.Y;
            visible = true;
        }


    }
}