/// <summary>
 /// Process shot will throw an exception in the case of AI error resulting in a square being hit twice
 /// </summary>
 /// <param name="result">The result of the shot</param>
 /// <param name="row">the row shot</param>
 /// <param name="col">the column shot</param>
 protected override void ProcessShot(int row, int col, AttackResult result)
 {
     if (result.Value == ResultOfAttack.ShotAlready)
     {
         throw new ApplicationException("Error in AI");
     }
 }

    /// <summary>
    /// ProcessShot will be called uppon when a ship is found.
    /// It will create a stack with targets it will try to hit. These targets
    /// will be around the tile that has been hit.
    /// </summary>
    /// <param name="row">the row it needs to process</param>
    /// <param name="col">the column it needs to process</param>
    /// <param name="result">the result og the last shot (should be hit)</param>
    protected override void ProcessShot(int row, int col, AttackResult result)
    {
        if (result.Value == ResultOfAttack.Hit) {
            _CurrentState = AIStates.Searching;

        } else if (result.Value == ResultOfAttack.ShotAlready) {
            throw new ApplicationException("Error in AI");
        }
    }

 /// <summary>
 /// ProcessShot will be called uppon when a ship is found.
 /// It will create a stack with targets it will try to hit. These targets
 /// will be around the tile that has been hit.
 /// </summary>
 /// <param name="row">the row it needs to process</param>
 /// <param name="col">the column it needs to process</param>
 /// <param name="result">the result og the last shot (should be hit)</param>
 protected override void ProcessShot(int row, int col, AttackResult result)
 {
     if (result.Value == ResultOfAttack.Hit) {
         _CurrentState = AIStates.TargetingShip;
         AddTarget(row - 1, col);
         AddTarget(row, col - 1);
         AddTarget(row + 1, col);
         AddTarget(row, col + 1);
     } else if (result.Value == ResultOfAttack.ShotAlready) {
         throw new ApplicationException("Error in AI");
     }
 }

	public void Show(AttackResult result)
	{
		gameObject.SetActive(true);

		labelNumber.color = result.IsCritical ? Color.red : Color.white;
        transform.localScale = Vector3.one * 4;
        tween.DORewind();
        tween.DOPlayForward();

		if (!result.IsDodge)
		{
			Show(result.Damage.ToString());
		}
		else
		{
			Show("Miss");
		}
	}

 public override void PlayerAttacked(BasePlayer player, Point from, Point to, GamePieceType piece, AttackResult result)
 {
     EstimatedState[from.x, from.y] = null;
     if (result == AttackResult.Win)
     {
         if (player != this)
         {
             EstimatedState[to.x, to.y] = GamePieceFactory.Create(piece, !this.IsRed);
         }
     }
     else if (result == AttackResult.Tie)
     {
         EstimatedState[to.x, to.y] = null;
     }
     else if (result == AttackResult.Lose)
     {
         if (player == this)
         {
             EstimatedState[to.x, to.y] = GamePieceFactory.Create(piece, !this.IsRed);
         }
     }
 }

 public Attack()
 {
     this.result = AttackResult.Unknown;
 }

 /// <summary>
 /// ProcessShot will be called uppon when a ship is found.
 /// </summary>
 /// <param name="row">the row it needs to process</param>
 /// <param name="col">the column it needs to process</param>
 /// <param name="result">the result og the last shot (should be hit)</param>
 protected override void ProcessShot(int row, int col, AttackResult result)
 {
     //easyAI does nothing with a shot
 }

        public void UpdateAttackResults(Coordinate lastAttack, AttackResult result, bool sunkShip)
        {
            if (uiState == UIState.Attacking)
            {
                uiState = UIState.WaitingToAttack;
                ShowNotification(string.Format("Waiting for {0} to attack...", opponent.PlayerName));
            }
            else { HandleBadUIState(); }

            // update attacks and ui elements
            Attacks[lastAttack.X, lastAttack.Y].Result = result;
        }

 private Uri GetImageForAttackResult(AttackResult result)
 {
     switch (result)
     {
         default:
         case AttackResult.Unknown:
             return new Uri("resources/images/attacks/attackResult_Unknown.png", UriKind.Relative);
         case AttackResult.Miss:
             return new Uri("resources/images/attacks/attackResult_Miss.png", UriKind.Relative);
         case AttackResult.Hit:
             return new Uri("resources/images/attacks/attackResult_Hit.png", UriKind.Relative);
     }
 }

	/// <summary>
	/// Listens for attacks to be completed.
	/// </summary>
	/// <param name="sender">the game</param>
	/// <param name="result">the result of the attack</param>
	/// <remarks>
	/// Displays a message, plays sound and redraws the screen
	/// </remarks>
	private static void AttackCompleted(object sender, AttackResult result)
	{
		bool isHuman = false;
		isHuman = object.ReferenceEquals(_theGame.Player, HumanPlayer);

		if (isHuman) {
			Message = "You " + result.ToString();
		} else {
			Message = "The AI " + result.ToString();
		}

		switch (result.Value) {
			case ResultOfAttack.Destroyed:
				PlayHitSequence(result.Row, result.Column, isHuman);
				Audio.PlaySoundEffect(GameSound("Sink"));

				break;
			case ResultOfAttack.GameOver:
				PlayHitSequence(result.Row, result.Column, isHuman);
				Audio.PlaySoundEffect(GameSound("Sink"));

				while (Audio.SoundEffectPlaying(GameSound("Sink"))) {
					SwinGame.Delay(10);
					SwinGame.RefreshScreen();
				}

				if (HumanPlayer.IsDestroyed) {
					Audio.PlaySoundEffect(GameSound("Lose"));
				} else {
					Audio.PlaySoundEffect(GameSound("Winner"));
				}

				break;
			case ResultOfAttack.Hit:
				PlayHitSequence(result.Row, result.Column, isHuman);
				break;
			case ResultOfAttack.Miss:
				PlayMissSequence(result.Row, result.Column, isHuman);
				break;
			case ResultOfAttack.ShotAlready:
				Audio.PlaySoundEffect(GameSound("Error"));
				break;
		}
	}

 public AttackInfo(Coordinate coord, AttackResult result, bool sunkShip)
 {
     this.coord = coord;
     this.result = result;
     this.sunkShip = sunkShip;
 }

 public void UpdateAttackResults(Coordinate lastAttack, AttackResult result, bool sunkShip)
 {
     ((MainWindow)wdw).Dispatcher.Invoke(new UpdateAttackResultsDelegate(wdw.UpdateAttackResults),
         lastAttack, result, sunkShip);
 }

        private static string CombatMessageFromResult(Unit source, Unit target, String skill, AttackResult attackResult, int damage)
        {
            var effectString = String.Empty;
            switch (attackResult) {
                case AttackResult.Hit:
                    effectString = String.Format("dealing {0} damage", damage);
                    break;
                case AttackResult.Miss:
                    effectString = String.Format("but misses, dealing no damage.");
                    break;
                case AttackResult.Critical:
                    effectString = String.Format("dealing a critical blow for {0} total damage!", damage);
                    break;
                case AttackResult.Glancing:
                    effectString = String.Format("dealing {0} damage with a glancing attack", damage);
                    break;
            }

            return String.Format("{0} fires off a {1} at {2}, {3}.",
                source.Name,
                skill,
                target.Name,
                effectString);
        }

	public static NumberItem Create(Vector3 worldPosition, AttackResult result)
	{
        NumberItem numberItem = DoCreate(worldPosition);
		numberItem.Show(result);
		return numberItem;
	}

        private static int TotalDamageFromResult(AttackResult attackResult, int damage)
        {
            switch (attackResult) {
                case AttackResult.Hit:
                    return damage;
                case AttackResult.Miss:
                    return 0;
                case AttackResult.Critical:
                    return damage * 2;
                case AttackResult.Glancing:
                    return damage / 2;
            }

            return 0;
        }

        public UnitStrike( Unit attacker, Unit attackee, MeleeWeapon weapon )
            : base("Strike", attacker)
        {
            this.attacker = attacker;
            this.attackee = attackee;
            this.weapon = weapon;

            result = attacker.relations.GetAttackResult( attackee );
        }

        public UnitShoot( Unit attacker, Unit attackee, Firearm weapon )
            : base("Shoot", attacker)
        {
            this.attacker = attacker;
            this.attackee = attackee;
            this.weapon = weapon;

            result = attacker.relations.GetAttackResult( attackee );
        }

        public UnitAttack( Unit attacker, Unit attackee )
            : base("Attack", attacker)
        {
            this.attacker = attacker;
            this.attackee = attackee;

            result = attacker.relations.GetAttackResult( attackee );
            weapon = attacker.currentWeapon;
        }

 public abstract void PlayerAttacked(BasePlayer player, Point from, Point to, GamePieceType piece, AttackResult result);

    /// <summary>
    /// Shoot will swap between players and check if a player has been killed.
    /// It also allows the current player to hit on the enemygrid.
    /// </summary>
    /// <param name="row">the row fired upon</param>
    /// <param name="col">the column fired upon</param>
    /// <returns>The result of the attack</returns>
    public AttackResult Shoot(int row, int col)
    {
        AttackResult newAttack = default(AttackResult);
        int otherPlayer = (_playerIndex + 1) % 2;

        newAttack = Player.Shoot(row, col);

        //Will exit the game when all players ships are destroyed
        if (_players[otherPlayer].IsDestroyed) {
            newAttack = new AttackResult(ResultOfAttack.GameOver, newAttack.Ship, newAttack.Text, row, col);
        }

        if (AttackCompleted != null) {
            AttackCompleted(this, newAttack);
        }

        //change player if the last hit was a miss
        if (newAttack.Value == ResultOfAttack.Miss) {
            _playerIndex = otherPlayer;
        }

        return newAttack;
    }