// Use this for initialization
 void Awake()
 {
     body = gameObject.GetComponent<Rigidbody2D> ();
     player = GameObject.FindGameObjectWithTag("Player").transform;
     enemyState = EnemyState.Chase;
     spriteRenderer = gameObject.GetComponent<SpriteRenderer> ();
 }

    /*In here there is a switch-statement which handles which method that is going
        * to be updating, this is chosen by the currentState of the enemy.
         It is in here that you will add your own EnemyState.yourState-case and call for your own method below*/
    public virtual void Update()
    {
        playerPosition = (GameObject.Find ("Player").transform.position);
        distance = Vector3.Distance(playerPosition, transform.position);
        switch (currentState) {
        case EnemyState.initializing:
            /*filling in the player reference for easier access*/
            /*playerReference = GameObject.Find ("Player");*/
            currentState = EnemyState.idle;
            break;
        case EnemyState.idle:
            Idle();
            break;
        case EnemyState.sawPlayer:
            SawPlayer();
            break;
        case EnemyState.chasing:
            Chasing();

            break;
        case EnemyState.attacking:
            Attacking();

            currentState = EnemyState.idle;
            break;
        case EnemyState.fleeing:
            Fleeing();

            currentState = EnemyState.idle;
            break;
        default:
            break;
        }
    }

    void CheckState()
    {
        if( bKnockBack )
        {
            state = EnemyState.KnockBack;
        }
        else  if( !bKnockBack && state == EnemyState.KnockBack)
        {
            state = EnemyState.Idle;
        }

        if( fAttackCurrent > fAttackTime + (fAttackWait*2) )
        {
            fAttackCurrent = 0;
            state = EnemyState.Idle;
            attack.SetActive(false);
        }
        else if( bAttacked != true && (state == EnemyState.Attack || ( state != EnemyState.Attack && Vector3.Distance( transform.position , manager.GetActivePlayer().transform.position ) < fAttackDistance) ) )
        {
            state = EnemyState.Attack;
        }

        if( state != EnemyState.KnockBack && state != EnemyState.Dead && state != EnemyState.Attack)
        {
            state = EnemyState.Move;
        }
        else if( state == EnemyState.Dead)
        {
            Die();
        }
        //		else
        //		{
        //			state = EnemyState.Idle;
        //		}
    }

        void FixedUpdate()
        {
            GetComponent<Animator>().SetBool("IsAttacking", false);

            switch (State)
            {
                case EnemyState.Idle:
                    if (CanSeePlayer())
                    {
                        State = EnemyState.Detect;
                        GetComponent<Animator>().SetBool("IsMoving", true);
                    }
                    break;
                case EnemyState.Patrolling:
                    if (CanSeePlayer())
                    {
                        State = EnemyState.Detect;
                        GetComponent<Animator>().SetBool("IsMoving", true);
                    }
                    break;
                case EnemyState.Searching:
                    SearchState();
                    break;
                case EnemyState.Detect:
                    AlertState();
                    break;
            }
        }

    // Update is called once per frame
    void FixedUpdate()
    {
        if (Cutscene.current != null) return;
        if (state == EnemyState.Patrolling) {
            // Reverse direction if at destination
            if ((Vector2)transform.position == patrolEnd) {
                Vector3 temp = patrolEnd;
                patrolEnd = patrolStart;
                patrolStart = temp;
            }

            transform.position = Vector2.MoveTowards(transform.position, patrolEnd, runSpeed * Time.deltaTime);

            if (canFollow) {
                if (Vector2.Distance(Player.S.transform.position, transform.position) < sightRange)
                    state = EnemyState.Following;
            }
        } else if (state == EnemyState.Following) {
            transform.position = Vector2.MoveTowards(transform.position, Player.S.transform.position, followSpeed * Time.deltaTime);
            if (Vector2.Distance(Player.S.transform.position, transform.position) > sightRange)
                state = EnemyState.Patrolling;
        }
        if (Vector2.Distance(Player.S.transform.position, transform.position) < attackRange) {
            if (Time.time > nextAttackTime) {
                Player.S.TakeDamage(attackDamage);
                nextAttackTime = Time.time + attackSpeed;
            }
        }
    }

        /// <summary>
        /// Updates this enemy instance
        /// </summary>
        /// <param name="gameTime">The time elapsed since the last update</param>
        public override void Update(GameTime gameTime)
        {
            switch (_state)
            {
                case EnemyState.Entering:
                    if (Entering(gameTime))
                    {
                        _state = EnemyState.Attacking;
                        this.Velocity = (this.Position.X < ManicShooter.ScreenSize.Width / 2) ? new Vector2(_maxSpeed, 0) : new Vector2(-_maxSpeed, 0);
                    }
                    break;
                case EnemyState.Attacking:
                    if (HorizontalPasses(gameTime)) _state = EnemyState.Leaving;
                    break;
                case EnemyState.Leaving:
                    LeaveScreen(gameTime.ElapsedGameTime);

                    if (this.IsOffScreen()) this.Destroy();
                    break;
            }

            ApplyVelocity(gameTime.ElapsedGameTime);
            UpdateWeaponPositions();

            base.Update(gameTime);
        }

        private void Initialize(Vector2 entryPosition)
        {
            this.ScaleSize(0.5M);
            this.Visible = true;
            this.randomDropChance = 10;

            _maxSpeed = 150;

            _state = EnemyState.Entering;

            this.targetEntryPosition = entryPosition;
            this.exitPosition = new Vector2(-50, -50);

            this._maxShotTime = 1000;
            this._shotTimer = this._maxShotTime;
            this._shotCount = 0;

            this._lastPlayerPositions = new Queue<Vector2>();

            this._lifeTimer = 10000;

            this.Velocity = Vector2.Zero;

            _weapons = new List<IWeapon>();

            //Point pellet gun
            _weapons.Add(new PelletGun(this.centerPosition, new Vector2(0, this.Height / 2), new Vector2(0, 250), 300d));
        }

 public void Reset()
 {
     state = EnemyState.Idle;
     gs.Enemy.width = 100f;
     gs.Enemy.height = 160f;
     gs.Enemy.position = gs.startEnemyPos;
 }

	void Start () {
		player = GameManager.instance.Player;
		spiral = new SpiralMotionEnemyState(this, player);

		currentState = spiral;
		currentState.StartState();
	}

 public void Die()
 {
     currentState = EnemyState.DEAD;
     isDead = true;
     audio.PlayDie();
     StartCoroutine(DieCoroutine());
 }

	public void StopMoving(){
		Animation ani = gameObject.GetComponent<Animation> ();
		if(ani){
			//ani.Stop();
			STATE = EnemyState.Stop;
		}
	}

 public void SetState(EnemyState state)
 {
     this.state = state;
     switch (state)
     {
         case EnemyState.IDLE:
             GetComponent<Animator>().SetBool("isHit", false);
             GetComponent<Animator>().SetBool("isKnock", false);
             transform.localScale = new Vector3(1, 1, 1);
             break;
         case EnemyState.HIT:
             GetComponent<Animator>().SetBool("isHit", true);
             if (attack)
                 attack.Play();
             break;
         case EnemyState.KNOCK:
             GetComponent<Animator>().SetBool("isKnock", true);
             transform.localScale = new Vector3(-1, 1, 1);
             if (attack)
                 attack.Play();
             break;
         case EnemyState.DEAD:
             GetComponent<Animator>().SetBool("isDead", true);
             GetComponent<TargetState>().IsDead = true;
             if (die)
                 die.Play();
             break;
     }
 }

 public Enemy(Texture2D loadedTexture, Vector2 position, int frameCount, int framesPerSec, Action<Enemy, double> ai)
     : base(loadedTexture, position, 0f, 1f, 1f, frameCount, framesPerSec)
 {
     this.Ai = ai;
     this.State = EnemyState.Idle;
     this.Direction = Directions.Left;
 }

 public void Die()
 {
     ES = EnemyState.Dead;
     anim.CrossFade("Dead", 0.2f);
     //fade out and destroy?
     StartCoroutine("FadeOut");
 }

        private void InitializeDefaultEnemy(Vector2 TargetEntryPoint)
        {
            this.ScaleSize(0.5M);

            _screenPasses = 0;
            _maxPasses = 3;
            this.Visible = true;

            _maxSpeed = 150;

            _state = EnemyState.Entering;

            this.targetEntryPoint = TargetEntryPoint;

            this.Velocity = Vector2.Zero;

            _weapons = new List<IWeapon>();

            //Top Left pellet gun
            _weapons.Add(new PelletGun(this.centerPosition, new Vector2(-this.Width / 2, -this.Height / 2), new Vector2(-250, -250), 300d));
            //Top Right pellet gun
            _weapons.Add(new PelletGun(this.centerPosition, new Vector2(this.Width / 2, -this.Height / 2), new Vector2(250, -250), 300d));
            //Bottom Left pellet gun
            _weapons.Add(new PelletGun(this.centerPosition, new Vector2(-this.Width / 2, this.Height / 2), new Vector2(-250, 250), 300d));
            //Bottom Right pellet gun
            _weapons.Add(new PelletGun(this.centerPosition, new Vector2(this.Width / 2, this.Height / 2), new Vector2(250, 250), 300d));
        }

 /// <summary>
 /// Construct new Enemy from EnemyData structure, a texture for the enemy, and a texture for its cannon balls
 /// </summary>
 /// <param name="e">EnemyData structure that holds all initialization data.  Loaded from the main game using the ContentPipeline</param>
 /// <param name="tex">Texture representing this enemy</param>
 /// <param name="cBTex">Texture representing enemy cannon balls</param>
 public Enemy(EnemyData e, Texture2D tex, Texture2D cBTex)
     : base(e,tex,cBTex)
 {
     range = e.range;
     score = e.score;
     state = EnemyState.Chasing;
 }

    public void InCombat()
    {
        PatrolPath enemyPatrol = GetComponent<PatrolPath>() as PatrolPath;

        // Turn towards player
        if (enemyState == EnemyState.ENEMY_PATROLLING)
        {
            // Stop the enemy from Patrolling
            enemyPatrol.Disable();

            enemyState = EnemyState.ENEMY_AGGRO;
        }

        if (enemyState == EnemyState.ENEMY_AGGRO)
        {
            // Change direction towards player
            if (ChangeDirection(playerTransform.position))
            {
                // Walk towards the player
                Vector3 faceDirection = playerTransform.position - transform.position;
                transform.position = transform.position + (faceDirection * (MovementSpeed * Time.smoothDeltaTime));

                if (Vector3.Distance(transform.position, playerTransform.position) <= AttackRadius)
                {
                    enemyState = EnemyState.ENEMY_ATTACKING;
                }
            }
        }

        if (enemyState == EnemyState.ENEMY_ATTACKING)
        {
            if (Vector3.Distance(transform.position, playerTransform.position) >= AttackRadius)
            {
                enemyState = EnemyState.ENEMY_AGGRO;
            }
        }

        if (enemyState == EnemyState.ENEMY_EVADE)
        {
            // Move back towards the disabled position
            if (ChangeDirection(enemyPatrol.GetDisabledPosition()))
            {
                Vector3 faceDirection = enemyPatrol.GetDisabledPosition() - transform.position;
                transform.position = transform.position + (faceDirection * (MovementSpeed * Time.smoothDeltaTime));

                if (Vector3.Distance(transform.position, enemyPatrol.GetDisabledPosition()) < 0.01f)
                {
                    enemyState = EnemyState.ENEMY_PATROLLING;
                    enemyPatrol.Enable();
                    inCombat = false;
                }
            }
        }

        if (Vector3.Distance(transform.position, enemyPatrol.GetDisabledPosition()) >= PlayerChaseRadius)
        {
            enemyState = EnemyState.ENEMY_EVADE;
        }
    }

 public void Die()
 {
     state = EnemyState.Dying;
     timer = DYING_TIME;
     gs.Enemy.width = 160f;
     gs.Enemy.height = 120f;
     gameObject.audio.PlayOneShot ( gs.enemyDieSFX );
 }

 public void Attack()
 {
     state = EnemyState.Prepare;
     timer = PREPARE_TIME;
     gs.Enemy.width = 100f;
     gs.Enemy.height = 160f;
     gameObject.audio.PlayOneShot ( gs.attackSFX );
 }

 public Enemy(Vector2 center, string type)
 {
     Center = center;
     Width = WIDTH;
     Height = HEIGHT;
     Color = Color.Green;
     CurrentState = EnemyState.Patrol;
 }