using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem.Processors;
using Random = UnityEngine.Random;

//Currently only moves around a set of defined points
//TODO: make it interact with the player. Like, at all.
public class Enemy_Sword : MovingEnemy
{       

    public float m_weaponRange;

    public Transform r_target;
    public float m_targetRefreshPeriod;
    private float m_targetRefreshTimer;
    
    public DynamicDamageSource m_damageSource;

    //not currently implemented
    public bool m_requireLineOfSightToEngage;

    protected override void Awake()
    {
        base.Awake();
        if(m_weaponRange < 0)
        {
            throw new ArgumentOutOfRangeException("Range can't be negative.");
        }
    }

    protected override void Start()
    {
        base.Start();
        m_targetRefreshTimer = 0f;
    }

    protected override void FixedUpdate()
    {
        UpdateCurrentTarget();
        if(r_target != null && m_weaponRange < GetDistanceToTarget())
        {
            m_currentMoveTarget = r_target.position;
        }
        else
        {
            m_currentMoveTarget = this.transform.position;
        }
        base.FixedUpdate();        
    }

    protected override void HandleWeapon()
    {
        if (r_target != null)
        {
            if (m_weaponRange >= GetDistanceToTarget())
            {
                if (m_attackTimer >= m_attackPeriod)
                {
                    m_attackTimer = 0f;
                    Attack();
                }
            }
        }
        m_attackTimer += Time.deltaTime;
    }


    private List<Tuple<Transform, float>> CheckForTargetsInRange()
    {
        List<Tuple<Transform, float>> targets = 
            new List<Tuple<Transform, float>>();
        foreach (PlayerAvatar p in PlayerAvatar.GetPlayerList())
        {
            //If in range
            float distance = (p.transform.position
                - this.transform.position).magnitude;
            if (distance < m_engagmentRange)
            {
                targets.Add(new Tuple<Transform, float>(p.transform, distance));
            }
        }
        return targets;
    }

    private void UpdateCurrentTarget()
    {
        m_targetRefreshTimer += Time.deltaTime;
        if (m_targetRefreshTimer > m_targetRefreshPeriod)
        {
            m_targetRefreshTimer = 0f;
            float currentTargetDistance;
            if (r_target != null)
            {
                currentTargetDistance = (r_target.position
                    - this.transform.position).magnitude;
            }
            else
            {
                currentTargetDistance = float.MaxValue;
            }
            foreach (Tuple<Transform, float> t in CheckForTargetsInRange())
            {
                if (t.Item2 < currentTargetDistance)
                {
                    r_target = t.Item1;
                    currentTargetDistance = GetDistanceToTarget();
                }
            }
        }
    }

    protected override void UpdateUIElements()
    {
        //throw new NotImplementedException();
    }

    protected override void DoAction()
    {
        //throw new NotImplementedException();
    }

    protected override void Attack()
    {
        r_animator.SetInteger("Weapon Animation ID", Random.Range(0, 4));
        r_animator.SetTrigger("Attack");
        m_damageSource.StartAttacking();
    }

    public override void SetIsAttacking(bool attacking)
    {
        if (attacking)
        {
            //do nothing
        }
        else
        {
            m_damageSource.StopAttacking();
        }
    }

    public float GetDistanceToTarget()
    {
        if (r_target != null)
        {
            return (r_target.position - this.transform.position).magnitude;
        }
        else
        {
            return float.NaN;
        }
    }
}