using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class NormalAI : CraftAI
{

	private MapObject targetOccupier;

	// Use this for initialization
	override protected void Start ()
	{
		base.Start();
		checkTimeInterval = 1f;
	}
	
	// Update is called once per frame
	protected virtual void FixedUpdate ()
	{
		if(player.IsAI())
		{
			AICheck ();
		}
		else if(owner.IsCtrl())
		{
			ManualCheck ();
		}
	}



	private void ManualCheck()
	{
		if(owner.IsDead())
		{
			return;
		}

		if(battleController.isGameOver)
		{
			return;
		}

		if(CheckDead())
		{
			return;
		}

		if(owner.GetSwapManager().isPreparingSwap)
		{
			Debuger.Log("swap prapare time : "+owner.GetSwapManager().GetPreparingSwapTime());
			if(owner.GetSwapManager().IsReadySwap())
			{
				battleController.GetMessageManager().RequestSwap(owner.id, owner.GetSwapManager().GetTargetSwapId());
				owner.GetSwapManager().RequestedSwap();
			}
		}
		else if(GameTime.time-lastCheckTime >= checkTimeInterval)
		{
			lastCheckTime = GameTime.time;

			CheckAction();
		}
	}

	private void CheckAction()
	{
		if(owner.target != null)
		{
			float targetDis = NumberUtil.distanceVector3(owner.position, owner.target.position, true);
			Power attack = owner.GetPowerManager().GetAttack();

			if(!owner.target.CanShoot())
			{
				owner.target = null;
			}
			else if(targetDis > owner.viewRange)
			{
				owner.target = null;
			}
			else if(targetDis > attack.GetDistance())
			{
				if(!owner.isMoving)
				{
					Vector3 targetPos = owner.target.position;
					owner.MoveTo(targetPos.x, targetPos.z);
				}
			}
			else if(targetDis <= attack.GetDistance())
			{
				if(owner.isMoving && !owner.forceMove)
					owner.StopMove();

				owner.GetPowerManager().AttempUserPower(attack.GetId(), battleController);
			}
		}
		else
		{
			base.FindTarget ();
			if(owner.target == null)
			{
				CheckOccupy();
			}
		}
	}










	private void AICheck()
	{
		if(!CanSendMessage())
		{
			return;
		}

		if(CheckDead())
		{
			return;
		}

		if(GameTime.time-lastCheckTime >= checkTimeInterval)
		{
			lastCheckTime = GameTime.time;
		}
		else
		{
			return;
		}

		if(owner.holdAction)
			return;

		//clear target occupier if that is dead
		ClearOccupyTarget();
		ClearTarget();

		if(owner.target == null)
			FindTarget();
		else
			FindMaxThreatTarget();

		CheckStack();

		if(owner.target != null)
		{
			Action();
		}
		else if(targetOccupier != null)
		{
			Occupy();
		}
	}








	protected virtual void CheckStack()
	{
		List<BattleObject> battleObjList = battleController.GetMap().GetBattleObjectByRange(owner.position, 0.5f, TeamUtil.Team.None);
		for(int i=0; i<battleObjList.Count; i++)
		{
			if(battleObjList[i].id > owner.id)
			{
				float angle = owner.rotateTargetAngle + Random.Range(0, 2) > 0 ? 90f : -90f;
				float radian = NumberUtil.angleToRadian(angle);
				float x = 1.5f * Mathf.Cos(radian);
				float z = 1.5f * Mathf.Sin(radian);
				int col = Map.XToColumn(owner.position.x + x);
				int row = Map.ZToRow(owner.position.z + z);
				battleController.GetMessageManager().Move(owner, col, row);
				return;
			}
		}
	}


	protected void ClearOccupyTarget()
	{
		if(targetOccupier == null)
		{
			return;
		}

		if(map.HasFlag() && (map.GetFlag(TeamUtil.Team.Blue).IsOnGround() || map.GetFlag(TeamUtil.Team.Red).IsOnGround()))
		{
			if(targetOccupier is FlagItem)
			{
				FlagItem flagItem = targetOccupier as FlagItem;
				if(!flagItem.IsOnGround())
				{
					targetOccupier = null;
					return;
				}
			}
			else
			{
				targetOccupier = null;
				return;
			}
		}

		if(targetOccupier is BattleObject && (targetOccupier as BattleObject).IsDead())
		{
			targetOccupier = null;
		}
		else if(targetOccupier is FlagItem)
		{
			if(!map.HasFlag())
			{
				targetOccupier = null;
				return;
			}

			FlagItem flagItem = (targetOccupier as FlagItem);
			if(flagItem.linkedCraftId != -1)
			{
				targetOccupier = null;
			}
			else if(flagItem.team == owner.team && flagItem.IsInBase())
			{
				targetOccupier = null;
			}
		}
		else if(targetOccupier is MapItemPos)
		{
			if((targetOccupier as MapItemPos).item == null)
				targetOccupier = null;
		}
	}

	protected void ClearTarget()
	{
		if(owner.target == null)
		{
			return;
		}

		if(owner.target.IsDead())
		{
			owner.target = null;
		}
		else if(!owner.target.CanShoot())
		{
			owner.target = null;
		}
		else
		{
			if(IsTargetCarryFlag())
				return;

			float targetDistance = NumberUtil.distanceVector3(owner.position, owner.target.position);
			if(targetDistance > owner.viewRange)
			{
				owner.target = null;
			}
		}
	}

	private bool IsTargetCarryFlag()
	{
		if(map.HasFlag() && owner.target is Craft)
		{
			Craft craft = owner.target as Craft;
			FlagItem flagItem = map.GetFlag(owner.team);
			if(flagItem.linkedCraftId == craft.id)
				return true;
		}
		return false;
	}


	protected virtual void Action()
	{
		if(!CheckPowerUse())
		{
			Attack();
		}
	}

	protected bool CheckPowerUse()
	{
		PowerManager powerManager = owner.GetPowerManager();
		for(int i=1; i<powerManager.GetPowers().Length; i++)
		{
			Power power = powerManager.GetPowerByIndex(i);
			if(powerManager.AttempUserPower(power.GetId(), battleController))
				return true;
		}
		return false;
	}

	protected void Attack()
	{
		Power attack = owner.GetPowerManager().GetAttack();
		if(!attack.IsInRange(owner.target))
		{
			CloseToTarget(owner.target);
		}
		else
		{
			owner.StopMove();
			owner.GetPowerManager().AttempUserPower(attack.GetId(), battleController);
		}
	}

	protected void CloseToTarget(ITarget target)
	{
		if(target != null)
		{
			AStarNode node = map.GetAStarNodeByPosition(target.position);
			battleController.GetMessageManager().Move(owner, node.X, node.Y);
		}
	}

	protected override void FindTarget ()
	{
		FindMaxThreatTarget();

		if(owner.target == null)
		{
			base.FindTarget ();
		}

		if(owner.target == null)
		{
			FindOccupyTarget();
		}
	}

	protected void FindOccupyTarget()
	{
		if(targetOccupier is CrystalBase)
		{
			CrystalBase targetCrystal = targetOccupier as CrystalBase;
			if(targetCrystal != null && targetCrystal.GetStation() != null)
			{
				Station station = targetCrystal.GetStation();
//				if(station.team == owner.team && station.GetState() == Station.State.Idle && station.hp == station.maxHp && 
//				   NumberUtil.distanceVector3(owner.position, targetCrystal.position) < targetCrystal.range)
				if(station.team == owner.team && station.hp == station.maxHp && 
				   NumberUtil.distanceVector3(owner.position, targetCrystal.position) < targetCrystal.range)
				{
					targetOccupier = null;
				}
				else
				{
					return;
				}
			}
		}

		MapData.MapID mapId = battleController.GetMap().id;
		if(mapId == MapData.MapID.Flag)
			FindFlagOccupyTarget();
		else if(mapId == MapData.MapID.Challenge)
			FindChallengeOccupyTarget();
		else if(mapId == MapData.MapID.Defense)
			FindDefenceOccupyTarget();
	}










	protected virtual void Occupy()
	{
		if(!owner.isMoving)
		{
			float distance = 5f;
			if(targetOccupier is CrystalBase)
				distance = (targetOccupier as CrystalBase).range;
			else if(targetOccupier is MapItemPos || targetOccupier is FlagItem)
				distance = 0.5f;
			else if(targetOccupier is Door)
				distance = owner.GetPowerManager().GetAttack().GetDistance();
			
			if(NumberUtil.distanceVector3(owner.transform.position, targetOccupier.position) > distance)
			{
				AStarNode node = map.GetAStarNodeByPosition(targetOccupier.position);
				battleController.GetMessageManager().Move(owner, node.X, node.Y);
			}
			else if(CheckOccupy() && owner is Craft && targetOccupier != null)
			{
				battleController.GetMessageManager().OccupyStation(owner as Craft, targetOccupier as CrystalBase);
			}
		}
		else if(owner.isMoving)
		{
			
		}
	}


	protected override bool CheckOccupy ()
	{
		if (owner.IsCtrl ()) {
			if (!base.CheckOccupy ())
				return false;

			CrystalBase targetCrystal = battleController.GetMap ().GetInRangeCrystalBase (owner.position);

			if (targetCrystal == null || targetCrystal.GetStation () != null)
				return false;

			List<BattleObject> list = map.GetBattleObjectByRange (targetCrystal.position, targetCrystal.range, TeamUtil.GetOpponentTeam (owner.team));
			if (list.Count > 0)
				return false;

			if (owner != null && targetCrystal != null)
				battleController.GetMessageManager ().OccupyStation (owner, targetCrystal);
			return true;
		} 
		else 
		{
			if (!base.CheckOccupy ())
				return false;

			if (targetOccupier == null)
				return false;

			if (targetOccupier is CrystalBase) {
				CrystalBase crystalBase = targetOccupier as CrystalBase;
				if (crystalBase.GetStation () != null) {
					return false;
				}

				if (NumberUtil.distanceVector3 (owner.position, targetOccupier.position) > crystalBase.range)
					return false;

				int bigUserId = int.MinValue;
				List<BattleObject> list = map.GetBattleObjectByRange (crystalBase.position, crystalBase.range, TeamUtil.Team.None);
				for (int i = 0; i < list.Count; i++) {
					BattleObject battleObj = list [i];
					if (battleObj.team != owner.team) {
						continue;
					} else if (battleObj.userId > bigUserId) {
						bigUserId = battleObj.userId;
					}
				}

				if (bigUserId == owner.userId) {
					return true;
				}
			}
		}
		
		return false;
	}




	private void FindChallengeOccupyTarget()
	{
		if(targetOccupier == null)
		{
			List<MapObject> list = new List<MapObject>();
			
			List<CrystalBase> cbList = battleController.GetMap().GetCrystalBaseList();
			for(int i=0; i<cbList.Count; i++)
			{
				CrystalBase crystalBase = cbList[i];
				if(crystalBase.GetStation() == null || crystalBase.GetStation().team != owner.team)
				{
					list.Add(crystalBase);
				}
			}

			if(list.Count > 0)
			{
				int index = Random.Range(0, list.Count);
				targetOccupier = list[index];
			}
			else
			{
				FindTargetAllMap();
			}
		}
	}

	private void FindDefenceOccupyTarget()
	{
		if(targetOccupier != null)
			return;

		Map map = battleController.GetMap();

		List<MapItemPos> itemPosList = map.GetMapItemPosList();
		for(int i=0; i<itemPosList.Count; i++)
		{
			if(itemPosList[i].item != null)
			{
				targetOccupier = itemPosList[i];
				return;
			}
		}

		List<Door> targetDoorList = new List<Door>();
		List<Door> doorList = map.GetDoorList();
		for(int i=0; i<doorList.Count; i++)
		{
			Door door = doorList[i];
			if(door.team != owner.team)
				targetDoorList.Add(door);
		}

		if(targetDoorList.Count > 0)
		{
			int index = Random.Range(0, targetDoorList.Count);
			targetOccupier = targetDoorList[index];
			return;
		}

		List<CrystalBase> cbList = battleController.GetMap().GetCrystalBaseList();
		for(int i=0; i<cbList.Count; i++)
		{
			CrystalBase crystalBase = cbList[i];
			Station station = crystalBase.GetStation();
			if(station.team != owner.team)
				targetOccupier = crystalBase;
		}
	}


	private void FindFlagOccupyTarget()
	{
		Map map = battleController.GetMap();

		FlagItem oppFlag = map.GetFlag(TeamUtil.GetOpponentTeam(owner.team));
		FlagItem myFlag = map.GetFlag(owner.team);

		if(myFlag != null)
		{
			if(myFlag.linkedCraftId > 0)
			{
				BattleObject battleObject = map.GetBattleObject(myFlag.linkedCraftId);
				if(battleObject != null)
				{
					targetOccupier = battleObject;
					return;
				}
			}
			else if(myFlag.IsOnGround())
			{
				targetOccupier = myFlag;
				return;
			}
		}

		if(oppFlag != null)
		{
			if(oppFlag.IsOnGround() || oppFlag.IsInBase())
			{
				targetOccupier = oppFlag;
				return;
			}

			if(oppFlag.linkedCraftId == owner.id)
			{
				targetOccupier = myFlag;
				return;
			}
		}
	}

}