using CommonAI.RTS; using CommonLang.Vector;
using CommonAI.Zone.Helper;
using CommonAI.Zone.Formula;
using CommonLang;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CommonAI.Zone.Instance
{

    public class InstanceBuilding : InstanceUnit, ViewTrigger.ViewTriggerListener
    {
        private ViewTrigger mViewTrigger;
        private InstanceUnit mTracingTarget;
        public override bool IsNoneBlock { get { return true; } }
        public override bool Moveable { get { return false; } }
        public override bool SyncPos { get { return false; } }

        public InstanceBuilding(InstanceZone zone, UnitInfo info, string name, int force, int level)
            : base(zone, info, name, force, level, info.BodySize > 0)
        {
            mViewTrigger = new ViewTriggerRoundBody(zone, info.GuardRange);
            mViewTrigger.setListener(this);
            if (IsNoneSkill)
            {
                mViewTrigger.Enable = false;
            }
        }

        override protected void onResetAI()
        {
            mTracingTarget = null;
            doSomething();
        }


        override protected void onUpdate(bool slowRefresh)
        {
            base.onUpdate(slowRefresh);

            if (mTracingTarget != null)
            {
                if (!mTracingTarget.IsActive)
                {
                    mTracingTarget = null;
                    mViewTrigger.Enable = true;
                }
                else if (CMath.intersectRound(
                    this.X, this.Y, this.Info.GuardRange,
                    mTracingTarget.X,
                    mTracingTarget.Y,
                    mTracingTarget.BodyBlockSize))
                {
                    if (CurrentState is StateSkill)
                    {
                    }
                    else
                    {
                        Vector2 targetPos = new Vector2(mTracingTarget.X, mTracingTarget.Y);
                        faceTo(mTracingTarget.X, mTracingTarget.Y);
                        launchRandomSkill(SkillTemplate.CastTarget.Enemy, new InstanceUnit.LaunchSkillParam(mTracingTarget.ID, targetPos));
                    }
                }
                else
                {
                    mTracingTarget = null;
                    mViewTrigger.Enable = true;
                }
            }

            mViewTrigger.onLookUpdate(X, Y);
        }

        protected override void onStateChanged(State old_state, State state)
        {

        }

        protected override void onDamaged(InstanceUnit attacker, AttackSource attack, int reduceHP)
        {
        }

        void ViewTrigger.ViewTriggerListener.onObjectEnterView(ViewTrigger src, InstanceZoneObject obj)
        {
            InstanceUnit u = obj as InstanceUnit;
            // 攻击第一个目标
            if (mTracingTarget == null || (!mTracingTarget.IsActive))
            {
                mTracingTarget = u;
                mViewTrigger.Enable = false;
            }
        }

        public void SetTracingTarget(InstanceUnit unit)
        {
            this.mTracingTarget = unit;
        }

        void ViewTrigger.ViewTriggerListener.onObjectLeaveView(ViewTrigger src, InstanceZoneObject obj)
        {
        }
        bool ViewTrigger.ViewTriggerListener.select(ViewTrigger src, InstanceZoneObject obj)
        {
            if (obj == this)
            {
                return false;
            }
            else if ((obj is InstanceUnit))
            {
                var u = obj as InstanceUnit;
                if (u.Force != this.Force && Parent.IsAttackable(this, u, SkillTemplate.CastTarget.Enemy, AttackReason.Look, Info))
                {
                    return true;
                }
            }
            return false;
        }




    }

}