using UnityEngine;
using Atavism;
using UnityEngine.EventSystems;

namespace FirstGenMods
{
    public class TargetingTweaks : MonoBehaviour
    {
        public bool EnableTargetingTweaks = true;
        [SerializeField]
        private float maxRetainTargetDistance = 100f;
        [SerializeField]
        private int targetableLayerNumber = 8;
        [SerializeField]
        private string targetTypePropertName = "targetType";
        [SerializeField]
        private string attackableStatePropertName = "attackable";
        [SerializeField]
        private string combatStatePropertName = "combatstate";
        [SerializeField]
        private string combatStateTimePropertyName = "combatstate_t";

        private bool isRegisterd = false;

        private void Start()
        {
        }

        private void Update()
        {
            if (EnableTargetingTweaks == true)
            {
                if (Input.GetKeyDown(KeyCode.Escape))
                {
                    SetCombatState(false);
                    ClientAPI.ClearTarget();
                }

                UpdateTargetFromClick();
                UntargetForDistance(ClientAPI.GetTargetObject());
            }
        }

        private void UpdateTargetFromClick()
        {
            if (Input.GetMouseButtonDown(0) == true || Input.GetMouseButtonDown(1) == true)
            {
                if (EventSystem.current.IsPointerOverGameObject() == false)
                {
                    AtavismNode target = GetTargetable();
                    if(target != null)
                    {
                        //LEFT CLICK - w/TARGET
                        if (Input.GetMouseButtonDown(0) == true)
                        {
                            SetCombatState(false);
                            ClientAPI.SetTarget(target.Oid);
                        }
                        //RIGHT CLICK w/TARGET
                        else if (Input.GetMouseButtonDown(1) == true)
                        {
                            if(GetAttackable(target) == true)
                            {
                                SetCombatState(true);
                            }
                            else
                            {
                                SetCombatState(false);
                            }
                            ClientAPI.SetTarget(target.Oid);
                        }
                    }
                    else
                    {
                        //LEFT CLICK - NO TARGET
                        if (Input.GetMouseButtonDown(0) == true)
                        {
                            SetCombatState(false);
                            ClientAPI.ClearTarget();
                        }
                        //RIGHT CLICK - NO TARGET
                        else if (Input.GetMouseButtonDown(1) == true)
                        {
                            //DONT CHANGE ANYTHING:
                            //Player camera movement
                        }
                    }
                }
            }
        }

        private AtavismNode GetTargetable()
        {
            AtavismNode outTargetable = null;

            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit[] hit = Physics.RaycastAll(ray, 100f);
            for (int i = 0; i < hit.Length; i++)
            {
                AtavismNode currentNode = hit[i].transform.gameObject.GetComponent<AtavismNode>();
                if (hit[i].transform.gameObject.layer == targetableLayerNumber)
                {
                    if (currentNode != null)
                    {
                        outTargetable = currentNode;
                        break;
                    }
                }
            }
            return outTargetable;
        }

        private bool GetAttackable(AtavismNode currentNode)
        {
            bool outBool = false;
            if(currentNode != null)
            {
                if (currentNode.PropertyExists(attackableStatePropertName) == true)
                {
                    if ((bool)currentNode.GetProperty(attackableStatePropertName) == true)
                    {
                        if (currentNode.PropertyExists(targetTypePropertName) == true)
                        {
                            if((int)currentNode.GetProperty(targetTypePropertName) < 1)
                            {
                                outBool = true;
                            }
                        }
                    }
                }
            }
            return outBool;
        }

        private void SetCombatState(bool state)
        {
            float timeToset = Time.time;
            AtavismPlayer player = ClientAPI.GetPlayerObject();
            if (player != null)
            {
                if(player.PropertyExists(combatStatePropertName) == true)
                {
                    player.SetProperty(combatStatePropertName, state);
                    player.SetProperty(combatStateTimePropertyName, timeToset);
                }

                if(state == false)
                {
                    NetworkAPI.SendAttackMessage(ClientAPI.GetTargetOid(), "strike", false);
                }
            }
        }

        private bool IsInCombat()
        {
            bool outBool = false;
            if (ClientAPI.GetPlayerObject().PropertyExists(combatStatePropertName) == true)
            {
                outBool = (bool)ClientAPI.GetPlayerObject().GetProperty(combatStatePropertName);
            }
            return outBool;
        }

        private void UntargetForDistance(AtavismMobNode inTarget)
        {
            if (inTarget != null)
            {
                if (GetTargetDistance(inTarget) > maxRetainTargetDistance)
                {
                    ClientAPI.ClearTarget();
                    ClientAPI.SetTarget(-1);
                    SetCombatState(false);
                }
            }
        }

        private float GetTargetDistance(AtavismMobNode inTarget)
        {
            float outDistance = 0f;
            if (inTarget != null)
            {
                outDistance = Vector3.Distance(ClientAPI.GetPlayerObject().GameObject.transform.position, inTarget.GameObject.transform.position);
            }
            return outDistance;
        }
    }
}