using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Sfs2X.Entities.Data;

public class Power
{
	public enum PowerType
	{
		Bullet = 0,
		Melee = 1,
		Chain = 2,
		Immediately = 3,
		Teleport = 4,
		Summon = 5,
		Nova = 6,
		Sector = 7,
		Dash = 8,
	}
	private static System.Array powerTypeArr = System.Enum.GetValues(typeof(PowerType));
	public static PowerType GetPowerTypeByCode(int code)
	{
		return (PowerType)powerTypeArr.GetValue(code);
	}


	public enum PowerEffect
	{
		Damage = 0,
		Heal = 1,
		None = 2,
	}
	private static System.Array powerEffectArr = System.Enum.GetValues(typeof(PowerEffect));
	public static PowerEffect GetPowerEffectByCode(int code)
	{
		return (PowerEffect)powerEffectArr.GetValue(code);
	}


	public enum TargetRange
	{
		SingleObject = 0,
		Self = 1,
		Chain = 2,
		Nova = 3,
		Sector = 4,
		FrontRect = 5,
	}
	private static System.Array targetRangeArr = System.Enum.GetValues(typeof(TargetRange));
	public static TargetRange GetTargetRangeByCode(int code)
	{
		return (TargetRange)targetRangeArr.GetValue(code);
	}


	public enum TargetSort
	{
		None = 0,
		HpLow2High = 1,
		HpHigh2Low = 2,
	}
	private static System.Array targetSortArr = System.Enum.GetValues(typeof(TargetSort));
	public static TargetSort GetTargetSortByCode(int code)
	{
		return (TargetSort)targetSortArr.GetValue(code);
	}


	public enum ValueType
	{
		Constant = 0,
		Percent = 1,
		CraftId = 2,
	}
	private static System.Array valueTypeArr = System.Enum.GetValues(typeof(ValueType));
	public static ValueType GetValueTypeByCode(int code)
	{
		return (ValueType)valueTypeArr.GetValue(code);
	}


	public int index;
	protected IPowerOwner owner;

	private float lastLaunchTime = float.MinValue;

	[System.NonSerialized]
	public bool isActivating = false;

	private Vector3 lastPosition;
	private uint _targetType;
	private TargetRange targetRange;
	private PowerType powerType;
	private int numBullets;
	private float bulletsInterval;
	private PowerEffect powerEffect;
	private TargetSort targetSort;
	private ValueType valueType;

	public bool isAttack;

	private PowerData data;
	public Power(PowerData data, IPowerOwner owner, bool isAttack=false)
	{
		this.owner = owner;
		this.data = data;
		this.isAttack = isAttack;

		InitTargetType();
		powerType = GetPowerTypeByCode(data.type);
		powerEffect = GetPowerEffectByCode(data.effect);

		numBullets = Mathf.Max(1, data.numBullets);

		targetRange = GetTargetRangeByCode(data.target);
		targetSort = GetTargetSortByCode(data.target_sort);
		valueType = GetValueTypeByCode(data.value_type);
	}

	public IPowerOwner GetOwner()
	{
		return owner;
	}

	public int GetId()
	{
		return data.id;
	}

	public string GetName()
	{
		return data.name;
	}

	public string GetDescription()
	{
		return data.description;
	}

	private void InitTargetType()
	{
		int[] valueArr = StringUtil.SplitToInt(data.target_type, '|');
		if(valueArr.Length == 0)
		{
			_targetType = TargetType.ENEMY;
		}
		else
		{
			for(int i=0; i<valueArr.Length; i++)
			{
				_targetType = _targetType | (uint)valueArr[i];
			}
		}
	}

	public uint targetType
	{
		get{return _targetType;}
	}

	public int crystalNeed
	{
		get{
			return 0;//data.crystal;
		}
	}

	public bool IsCoolDown()
	{
		if(GameTime.time - lastLaunchTime < data.cd)
		{
			return false;
		}
		return true;
	}

	public void SetLastLaunchTime(float value)
	{
		lastLaunchTime = value;
	}

	public void RenewLastLaunchTime()
	{
		lastLaunchTime = GameTime.time;
	}

	public float GetLastLaunchTime()
	{
		return lastLaunchTime;
	}

	public float GetCDTime()
	{
		float coolDown = GameTime.time - lastLaunchTime;
		if(coolDown > data.cd)
		{
			return data.cd;
		}
		return coolDown;
	}

	public float GetCDDuration()
	{
		return data.cd;
	}

	private Sprite icon;
	public Sprite GetIcon()
	{
		if(icon == null)
		{
			icon = GetIcon (data);
		}
		return icon;
	}

	public static Sprite GetIcon(PowerData powerData)
	{
		int iconId = StringUtil.ToInt(powerData.icon);
		if(iconId == 0)
			iconId = powerData.id;
		return Resources.Load<Sprite>("Textures/PowerIcon/"+iconId);
	}

	public TargetRange GetTargetRange()
	{
		return targetRange;
	}

	public PowerType GetPowerType()
	{
		return powerType;
	}

	public int GetNumBullets()
	{
		return numBullets;
	}

	public float GetButtetsInterval()
	{
		return data.bulletsInterval;
	}

	public PowerEffect GetPowerEffect()
	{
		return powerEffect;
	}

	public float GetDistance()
	{
		return data.distance;
	}

	public virtual bool IsInRange(ITarget target)
	{
		if(target != null)
		{
			if(powerType == PowerType.Teleport || powerType == PowerType.Immediately || powerType == PowerType.Summon)
			{
				return true;
			}
			else if(data.distance >= NumberUtil.distanceVector3(owner.position, target.position))
			{
				return true;
			}
		}
		return false;
	}

	public int GetTargetLimit()
	{
		if(data.target_limit == 0)
			return int.MaxValue;
		return data.target_limit;
	}

	public TargetSort GetTargetSort()
	{
		return targetSort;
	}

	public float modifyValue;

	public float GetOriginValue()
	{
		return data.value;
	}

	public float GetValue()
	{
		return data.value + modifyValue;
	}

	public ValueType GetValueType()
	{
		return valueType;
	}

	public int GetDecay()
	{
		return data.decay;
	}

	public float GetEffectValue()
	{
		if (owner.typeId == MapObjectUtil.TypeId.UAV.GetHashCode ()) {
			UAVehicle uav = owner as UAVehicle;
			Debuger.LogError ("GetEffectValue " + GetValue() * uav.GetDamage());
			return GetValue() * uav.GetDamage ();
		}
		return GetValue () * GetOwner ().GetPowerManager ().GetDamage ();
	}

	public int GetBuff()
	{
		return data.buff;
	}

	public string GetGraphicEffect()
	{
		return data.g_effect;
	}

	public void PlaySound(float duration=float.MaxValue)
	{
		if(!StringUtil.Empty(data.s_effect))
		{
			if(SoundUtils.IsSoundNear(owner.position))
			{
				SoundManager.GetInstatnce().effectSound.Play(data.s_effect, 0.3f, duration);
				if(data.shake > 0)
					BattleController.Shake(owner.position, data.shake);
			}
		}
	}

	public string GetHitEffect()
	{
		return data.g_hit;
	}

	public void PlayHitSound()
	{
		if(!StringUtil.Empty(data.s_hit))
		{
			if(SoundUtils.IsSoundNear(owner.position))
			{
				SoundManager.GetInstatnce().effectSound.Play(data.s_hit, 0.3f);
			}
		}
	}







	public virtual ISFSObject PackMessage(ITarget target, BattleController battleController)
	{
		return powerHandler.PackMessage(this, target, battleController);
	}

	public virtual void ParseMessage(ISFSObject msg, BattleController battleController)
	{
		PlaySound();
		powerHandler.ParseMessage(this, msg, battleController);
	}




	private static PowerHandler powerHandler = new PowerHandler();


	public override string ToString ()
	{
		return string.Format ("[Power: id[{0}], name[{1}]]", GetId(), GetName());
	}

}