using System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;
using Sirenix.OdinInspector;
using Unity.Cinemachine;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UIElements;
using Vector2 = UnityEngine.Vector2;
using Vector3 = UnityEngine.Vector3;

public class LockOnManager : MonoBehaviour{
    class ReferencedTarget{
        public GameObject gameObject;
        public float targetWeight;
        public float refVelocity;
        public CinemachineTargetGroup.Target cinemachineTarget;
    }

    private CinemachineTargetGroup.Target playerTarget;

    // Lock On settings
    [Space(5)] public float lockOnRange = 40f;
    public float lockOnMaxAngle = 70f;
    [Range(0,1)] public float mainTargetWeight = .15f;
    [FormerlySerializedAs("smoothing")] public float smoothTime = 1f;

    // Lock On Tracking
    [Space(10)]
    public GameObject lockonGameObject; // Needed because nulling the Target below doesn't actually empty it out
    
    [ShowInInspector]
    ReferencedTarget mainTarget;
    
    [ShowInInspector]
    List<ReferencedTarget> activeTargets = new List<ReferencedTarget>();

    [ReadOnly] public CinemachineTargetGroup.Target lockonTarget;
    public CinemachineTargetGroup targetGroup;

    [FormerlySerializedAs("lockOnTargets")] [Space(5)]
    public List<GameObject> acceptedTargets = new List<GameObject>();

    // UI
    [ShowInInspector] public UIDocument lockOnDocument;
    private Label elementLabelName;
    private VisualElement elementRoot;

    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start(){
        // Save the player target object to track later
        playerTarget = targetGroup.Targets[0];

        // Quick check for things in lock-on target that aren't lock-onable
        if (lockonGameObject != null && lockonTarget.Object.GetComponent<ILockOnTarget>() == null) {
            Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
        }

        elementRoot = lockOnDocument.rootVisualElement.Query<VisualElement>("LockOnGroup");
        elementLabelName = lockOnDocument.rootVisualElement.Query<Label>("LockOnName").First();

        // Add all nearby game objects to lock-on eligible list
        GameObject[] allGameObjects = GameObject.FindObjectsByType<GameObject>(0, 0);

        foreach (GameObject thisObject in allGameObjects) {
            if (Vector3.Distance(transform.position, thisObject.transform.position) < lockOnRange) {
                if (thisObject.GetComponent<ILockOnTarget>() != null) {
                    acceptedTargets.Add(thisObject);
                }
            }
        }
    }

    void Update(){
        if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
            Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
        }

        // Find the current lock-on target and increase it's weight to the .15f max slowly
        // They start at 0 weight when the lock-on adds them to the group
        // if (mainTarget != null) {
        //     CinemachineTargetGroup.Target currentTarget = targetGroup.Targets.Find(target => target == lockonTarget);
        //     currentTarget.Weight = Mathf.MoveTowards(currentTarget.Weight, .15f, .5f * Time.deltaTime);
        // }

        for (int i = 0; i < activeTargets.Count; i++) {
            if (activeTargets[i].gameObject == this.gameObject) {
                continue;
            }

            activeTargets[i].cinemachineTarget.Weight =
                Mathf.SmoothDamp(
                    activeTargets[i].cinemachineTarget.Weight,
                    activeTargets[i].targetWeight,
                    ref activeTargets[i].refVelocity,
                    smoothTime * Time.deltaTime);
            
            if (activeTargets[i].cinemachineTarget.Weight < 0.0001f) {
                StartCoroutine(RemoveFromTargetAtFrameEnd(activeTargets[i]));
                continue;
            }
        }

        // If a target is not the current lock on target, lower their targeting weight. When low enough to not cause a sharp jitter, remove them.
        // for (int i = 1; i < targetGroup.Targets.Count; i++) {
        //     if (targetGroup.Targets[i] == lockonTarget || targetGroup.Targets[i] == playerTarget || extraTargets.ContainsKey(targetGroup.Targets[i].Object.gameObject)){
        //         continue;
        //     }
        //     
        //     if (targetGroup.Targets[i].Weight < 0.001f) {
        //         StartCoroutine(RemoveFromTargetAtFrameEnd(targetGroup.Targets[i]));
        //         continue;
        //     }
        //     
        //     targetGroup.Targets[i].Weight = Mathf.SmoothDamp(targetGroup.Targets[i].Weight, 0f, 1f * Time.deltaTime);
        // }
    }

    IEnumerator RemoveFromTargetAtFrameEnd(ReferencedTarget target){
        yield return new WaitForEndOfFrame();

        // if (target.targetWeight == 0) {
            activeTargets.Remove(target);
            targetGroup.Targets.Remove(target.cinemachineTarget);
        // }
        
        // activeTargets.Remove(target);
        // targetGroup.Targets.Remove(target.cinemachineTarget);
    }

    public void AddNewTarget(GameObject targetObject, float targetWeight, bool isMain = false){
        foreach (ReferencedTarget target in activeTargets) {
            if (target.gameObject == targetObject) {
                target.targetWeight = targetWeight;
                
                if (isMain) {
                    mainTarget = target;
                }
                
                return;
            }            
        }
        
        ReferencedTarget newTarget = new ReferencedTarget{
            gameObject = targetObject, 
            targetWeight = mainTargetWeight,
            cinemachineTarget = new CinemachineTargetGroup.Target{
                Object = targetObject.transform,
                Radius = 1f,
                Weight = 0f
            }
        };

        if (isMain) {
            mainTarget = newTarget;
        }

        activeTargets.Add(newTarget);
        targetGroup.Targets.Add(newTarget.cinemachineTarget);
    }

    public void QueueTargetRemoval(GameObject targetObject){
        activeTargets.Find(target => target.gameObject == targetObject).targetWeight = 0f;

        if (mainTarget == activeTargets.Find(target => target.gameObject == targetObject)) {
            mainTarget = null;
        }
        
        Debug.Log(activeTargets.Find(target => target.gameObject == targetObject).targetWeight);
    }

// public void AddToExtraTargets(GameObject target, float weight){
    //     if (extraTargets.ContainsKey(target)) {
    //         return;
    //     }
    //     
    //     extraTargets.Add(target, weight);
    //
    //     targetGroup.Targets.Add(new CinemachineTargetGroup.Target(){ Object = target.transform, Weight = 0f });
    // }
    //
    // public void RemoveFromExtraTargets(GameObject target){
    //     if (extraTargets.ContainsKey(target)) {
    //         extraTargets.Remove(target);
    //     }
    // }

    public void ChangeLockOnTarget(){
        Transform cameraTransform = Camera.main.transform;
    
        // If there is no target, simply find the closest to the center of the camera
        GameObject closestTarget = null;
        float lowestDistanceToCenter = Mathf.Infinity;
        
        foreach (GameObject target in acceptedTargets) {
            // Skip the current target if one exists
            if (lockonGameObject != null && lockonTarget.Object.gameObject == target) {
                continue;
            }
            
            // Skip targets currently behind objects.
            Physics.Raycast(cameraTransform.position,
                cameraTransform.position.DirectionTo(target.transform.position), out RaycastHit hit);

            if (hit.transform != target.transform) {
                continue;
            }

            // Skip targets outside lock on angle 
            float angleFromCameraForward = Vector3.Angle(cameraTransform.forward, cameraTransform.position.DirectionTo(target.transform.position));
            if (angleFromCameraForward > lockOnMaxAngle) {
                continue;
            }                

            // Find how close this target is from the center of the screen
            Vector3 targetScreenPoint = Camera.main.WorldToScreenPoint(target.transform.position);
            float distanceFromScreenCenter = targetScreenPoint.Flatten(null, null, 0f).magnitude - new Vector3(Screen.width, Screen.height, 0f).magnitude / 2f;
            distanceFromScreenCenter = Mathf.Abs(distanceFromScreenCenter);

            // Debug.Log($"{target.name}: {distanceFromScreenCenter} pixels, {angleFromCameraForward} degrees");

            // Set the new target to closest to screen
            if (distanceFromScreenCenter < lowestDistanceToCenter) {
                lowestDistanceToCenter = distanceFromScreenCenter;
                closestTarget = target;
            }
        }

        // Catch exception from nothing being found
        if (!closestTarget) {
            Debug.LogWarning("Lock-on attempted, but no lock on target was found viable.");
            return;
        }
        
        // TODO: Recomment below

        if (mainTarget != null) {
            QueueTargetRemoval(mainTarget.gameObject);
            // mainTarget = null;
        }
        
        // Create a new Target for the Target Group
        var newCineTarget = new CinemachineTargetGroup.Target{
            Object = closestTarget.transform,
            Radius = 1f,
            Weight = 0f
        };
        
        // Set the new target variables
        lockonTarget = newCineTarget; // Old
        
        ReferencedTarget thisTarget = new ReferencedTarget{
            gameObject = closestTarget.gameObject, 
            targetWeight = mainTargetWeight,
            cinemachineTarget = newCineTarget
        };
        
        AddNewTarget(closestTarget.gameObject, mainTargetWeight, true);
        
        lockonGameObject = closestTarget.gameObject; // Old
        // targetGroup.Targets.Add(newCineTarget); // Old
    }

    public void RemoveLockOnTarget(){
        lockonTarget = null; // Old
        lockonGameObject = null; // Old

        QueueTargetRemoval(mainTarget.gameObject);
    }

    void LateUpdate(){
        if (mainTarget != null) {
            // This is just test logic to get an image above a lock on.
            // TODO: Replace with something less silly
            Vector2 screenPos = RuntimePanelUtils.CameraTransformWorldToPanel(
                lockOnDocument.rootVisualElement.panel,
                mainTarget.gameObject.GetComponent<ILockOnTarget>().GetReticlePosition(),
                Camera.main
            );

            // Set name
            elementLabelName.text = mainTarget.gameObject.name;

            // Set position (add the width/height of the element)
            elementRoot.style.top = new StyleLength(screenPos.y - 25f); // Was elementRoot.resolvedStyle.height * .7f
            elementRoot.style.left = new StyleLength(screenPos.x - elementRoot.resolvedStyle.width / 2f);

            // Set enabled
            elementRoot.style.display = new StyleEnum<DisplayStyle>(DisplayStyle.Flex);
        } else {
            elementRoot.style.display = new StyleEnum<DisplayStyle>(DisplayStyle.None);
        }
    }
}