using Interactions;
using UnityEngine;
using Pathfinding;
using UnityEngine.SceneManagement;
using Utils;

/// <summary>
/// Controls the follower character, including following the player, handling pickups, and managing held items.
/// </summary>
public class FollowerController: MonoBehaviour
{
    [Header("Follower Settings")]
    public bool debugDrawTarget = true;
    /// <summary>
    /// How often to update follow logic.
    /// </summary>
    public float followUpdateInterval = 0.1f;
    /// <summary>
    /// Smoothing factor for manual movement.
    /// </summary>
    public float manualMoveSmooth = 8f;

    private Transform _playerTransform;
    private AIPath _playerAIPath;
    private AIPath _aiPath;
    private Vector3 _targetPoint;
    private float _timer;
    private bool _isManualFollowing = true;
    private Vector3 _lastMoveDir = Vector3.right;
    private float _currentSpeed = 0f;
    private Animator _animator;
    private Transform _artTransform;
    private SpriteRenderer _spriteRenderer;
    
    private PickupItemData _currentlyHeldItemData;
    public PickupItemData CurrentlyHeldItemData => _currentlyHeldItemData;
    private GameObject _cachedPickupObject = null;
    public bool justCombined = false;
    
    /// <summary>
    /// Renderer for the held item icon.
    /// </summary>
    public SpriteRenderer heldObjectRenderer;

    private bool _isReturningToPlayer = false;
    private float _playerMaxSpeed = 5f;
    private float _followerMaxSpeed = 6f;
    private float _defaultFollowerMaxSpeed = 6f;

    // Pickup events
    public delegate void FollowerPickupHandler();
    /// <summary>
    /// Event fired when the follower arrives at a pickup.
    /// </summary>
    public event FollowerPickupHandler OnPickupArrived;
    /// <summary>
    /// Event fired when the follower returns to the player after a pickup.
    /// </summary>
    public event FollowerPickupHandler OnPickupReturned;
    private Coroutine _pickupCoroutine;
    
    void Awake()
    {
        _aiPath = GetComponent<AIPath>();
        // Find art prefab and animator
        _artTransform = transform.Find("CharacterArt");
        if (_artTransform != null)
        {
            _animator = _artTransform.GetComponent<Animator>();
            _spriteRenderer = _artTransform.GetComponent<SpriteRenderer>();
        }
        else
        {
            _animator = GetComponentInChildren<Animator>(); // fallback
            _spriteRenderer = GetComponentInChildren<SpriteRenderer>();
        }
    }

    void OnEnable()
    {
        SceneManager.sceneLoaded += OnSceneLoaded;
        FindPlayerReference();
    }

    void OnDisable()
    {
        SceneManager.sceneLoaded -= OnSceneLoaded;
    }

    void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        FindPlayerReference();
    }
    
    void Update()
    {
        if (_playerTransform == null)
        {
            FindPlayerReference();
            if (_playerTransform == null)
                return;
        }

        _timer += Time.deltaTime;
        if (_timer >= GameManager.Instance.FollowUpdateInterval)
        {
            _timer = 0f;
            UpdateFollowTarget();
        }

        if (_isManualFollowing)
        {
            Vector2 current2D = new Vector2(transform.position.x, transform.position.y);
            Vector2 target2D = new Vector2(_targetPoint.x, _targetPoint.y);
            float dist = Vector2.Distance(current2D, target2D);
            float minSpeed = _followerMaxSpeed * 0.3f;
            float lerpFactor = GameManager.Instance.ManualMoveSmooth * Time.deltaTime;
            float targetSpeed = 0f;
            if (dist > GameManager.Instance.StopThreshold)
            {
                if (dist > GameManager.Instance.ThresholdFar)
                {
                    targetSpeed = _followerMaxSpeed;
                }
                else if (dist > GameManager.Instance.ThresholdNear && dist <= GameManager.Instance.ThresholdFar)
                {
                    targetSpeed = _followerMaxSpeed;
                }
                else if (dist > GameManager.Instance.StopThreshold && dist <= GameManager.Instance.ThresholdNear)
                {
                    targetSpeed = minSpeed;
                }
                _currentSpeed = Mathf.Lerp(_currentSpeed, targetSpeed, lerpFactor);
                if (dist > GameManager.Instance.StopThreshold && dist <= GameManager.Instance.ThresholdNear)
                {
                    _currentSpeed = Mathf.Max(_currentSpeed, minSpeed);
                }
                Vector3 dir = (_targetPoint - transform.position).normalized;
                // Sprite flipping based on movement direction
                if (_spriteRenderer != null && dir.sqrMagnitude > 0.001f)
                {
                    if (dir.x > 0.01f)
                        _spriteRenderer.flipX = false;
                    else if (dir.x < -0.01f)
                        _spriteRenderer.flipX = true;
                }
                transform.position += dir * _currentSpeed * Time.deltaTime;
            }
            else
            {
                _currentSpeed = 0f;
            }
        }
        if (_isReturningToPlayer && _aiPath != null && _aiPath.enabled && _playerTransform != null)
        {
            _aiPath.destination = _playerTransform.position;
        }
        if (_animator != null)
        {
            float normalizedSpeed = 0f;
            if (_isManualFollowing)
            {
                normalizedSpeed = _currentSpeed / _followerMaxSpeed;
            }
            else if (_aiPath != null)
            {
                normalizedSpeed = _aiPath.velocity.magnitude / _followerMaxSpeed;
                // Sprite flipping for pathfinding mode
                if (_spriteRenderer != null && _aiPath.velocity.sqrMagnitude > 0.001f)
                {
                    if (_aiPath.velocity.x > 0.01f)
                        _spriteRenderer.flipX = false;
                    else if (_aiPath.velocity.x < -0.01f)
                        _spriteRenderer.flipX = true;
                }
            }
            _animator.SetFloat("Speed", Mathf.Clamp01(normalizedSpeed));
        }
    }

    void FindPlayerReference()
    {
        GameObject playerObj = GameObject.FindGameObjectWithTag("Player");
        if (playerObj != null)
        {
            _playerTransform = playerObj.transform;
            _playerAIPath = playerObj.GetComponent<AIPath>();
            if (_playerAIPath != null)
            {
                _playerMaxSpeed = _playerAIPath.maxSpeed;
                _defaultFollowerMaxSpeed = _playerMaxSpeed;
                _followerMaxSpeed = _playerMaxSpeed * GameManager.Instance.FollowerSpeedMultiplier;
            }
        }
        else
        {
            _playerTransform = null;
            _playerAIPath = null;
        }
    }
    
#region Movement
    /// <summary>
    /// Updates the follower's target point to follow the player at a specified distance,
    /// using the player's current movement direction if available. Disables pathfinding
    /// when in manual following mode.
    /// </summary>
    void UpdateFollowTarget()
    {
        if (_playerTransform == null)
        {
            FindPlayerReference();
            if (_playerTransform == null)
                return;
        }
        if (_isManualFollowing)
        {
            Vector3 playerPos = _playerTransform.position;
            Vector3 moveDir = Vector3.zero;
            if (_playerAIPath != null && _playerAIPath.velocity.magnitude > 0.01f)
            {
                moveDir = _playerAIPath.velocity.normalized;
                _lastMoveDir = moveDir;
            }
            else
            {
                moveDir = _lastMoveDir;
            }
            // Use GameSettings for followDistance
            _targetPoint = playerPos - moveDir * GameManager.Instance.FollowDistance;
            _targetPoint.z = 0;
            if (_aiPath != null)
            {
                _aiPath.enabled = false;
            }
        }
    }
    
    // Command follower to go to a specific point (pathfinding mode)
    /// <summary>
    /// Command follower to go to a specific point (pathfinding mode).
    /// </summary>
    /// <param name="worldPosition">The world position to move to.</param>
    public void GoToPoint(Vector2 worldPosition)
    {
        _isManualFollowing = false;
        if (_aiPath != null)
        {
            _aiPath.enabled = true;
            _aiPath.maxSpeed = _followerMaxSpeed;
            _aiPath.destination = new Vector3(worldPosition.x, worldPosition.y, 0);
        }
    }

    // Command follower to go to a specific point and return to player
    /// <summary>
    /// Command follower to go to a specific point and return to player.
    /// </summary>
    /// <param name="itemPosition">The position of the item to pick up.</param>
    /// <param name="playerTransform">The transform of the player.</param>
    public void GoToPointAndReturn(Vector2 itemPosition, Transform playerTransform)
    {
        if (_pickupCoroutine != null)
            StopCoroutine(_pickupCoroutine);
        if (_aiPath != null)
            _aiPath.maxSpeed = _followerMaxSpeed;
        _pickupCoroutine = StartCoroutine(PickupSequence(itemPosition, playerTransform));
    }
    
    private System.Collections.IEnumerator PickupSequence(Vector2 itemPosition, Transform playerTransform)
    {
        _isManualFollowing = false;
        _isReturningToPlayer = false;
        if (_aiPath != null)
        {
            _aiPath.enabled = true;
            _aiPath.maxSpeed = _followerMaxSpeed;
            _aiPath.destination = new Vector3(itemPosition.x, itemPosition.y, 0);
        }
        // Wait until follower reaches item (2D distance)
        while (Vector2.Distance(new Vector2(transform.position.x, transform.position.y), new Vector2(itemPosition.x, itemPosition.y)) > GameManager.Instance.StopThreshold)
        {
            yield return null;
        }
        OnPickupArrived?.Invoke();
        
        // Wait briefly, then return to player
        yield return new WaitForSeconds(0.2f);
        if (_aiPath != null && playerTransform != null)
        {
            _aiPath.maxSpeed = _followerMaxSpeed;
            _aiPath.destination = playerTransform.position;
        }
        _isReturningToPlayer = true;
        // Wait until follower returns to player (2D distance)
        while (playerTransform != null && Vector2.Distance(new Vector2(transform.position.x, transform.position.y), new Vector2(playerTransform.position.x, playerTransform.position.y)) > GameManager.Instance.StopThreshold)
        {
            yield return null;
        }
        _isReturningToPlayer = false;
        OnPickupReturned?.Invoke();
        // Reset follower speed to normal after pickup
        _followerMaxSpeed = _defaultFollowerMaxSpeed;
        if (_aiPath != null)
            _aiPath.maxSpeed = _followerMaxSpeed;
        _isManualFollowing = true;
        if (_aiPath != null)
            _aiPath.enabled = false;
        _pickupCoroutine = null;
    }
#endregion Movement
    
#region ItemInteractions
    public void TryPickupItem(GameObject itemObject, PickupItemData itemData)
    {
        if (_currentlyHeldItemData != null && _cachedPickupObject != null)
        {
            // Drop the currently held item at the current position
            DropHeldItemAt(transform.position);
        }
        // Pick up the new item
        SetHeldItem(itemData, itemObject.GetComponent<SpriteRenderer>());
        _cachedPickupObject = itemObject;
        _cachedPickupObject.SetActive(false);
    }
    
    public enum CombinationResult
    {
        Successful,
        Unsuccessful,
        NotApplicable
    }

    public CombinationResult TryCombineItems(Pickup pickupA, out GameObject newItem)
    {
        newItem = null;
        if (_cachedPickupObject == null)
        {
            return CombinationResult.NotApplicable;
        }
        Pickup pickupB = _cachedPickupObject.GetComponent<Pickup>();
        if (pickupA == null || pickupB == null)
        {
            return CombinationResult.NotApplicable;
        }
        var rule = GameManager.Instance.GetCombinationRule(pickupA.itemData, pickupB.itemData);
        Vector3 spawnPos = pickupA.gameObject.transform.position;
        if (rule != null && rule.resultPrefab != null)
        {
            newItem = Instantiate(rule.resultPrefab, spawnPos, Quaternion.identity);
            PickupItemData itemData = newItem.GetComponent<Pickup>().itemData;
            Destroy(pickupA.gameObject);
            Destroy(pickupB.gameObject);
            TryPickupItem(newItem,itemData);
            return CombinationResult.Successful;
        }
        
        // If no combination found, return Unsuccessful
        return CombinationResult.Unsuccessful;
    }
    
    /// <summary>
    /// Set the item held by the follower, copying all visual properties from the Pickup's SpriteRenderer.
    /// </summary>
    /// <param name="itemData">The item data to set.</param>
    /// <param name="pickupRenderer">The SpriteRenderer from the Pickup to copy appearance from.</param>
    public void SetHeldItem(PickupItemData itemData, SpriteRenderer pickupRenderer = null)
    {
        _currentlyHeldItemData = itemData;
        if (heldObjectRenderer != null)
        {
            if (_currentlyHeldItemData != null && pickupRenderer != null)
            {
                AppleHillsUtils.CopySpriteRendererProperties(pickupRenderer, heldObjectRenderer);
            }
            else
            {
                heldObjectRenderer.sprite = null;
                heldObjectRenderer.enabled = false;
            }
        }
    }
    
    public GameObject GetHeldPickupObject()
    {
        return _cachedPickupObject;
    }

    public void SetHeldItemFromObject(GameObject obj)
    {
        if (obj == null)
        {
            ClearHeldItem();
            return;
        }
        var pickup = obj.GetComponent<Pickup>();
        if (pickup != null)
        {
            SetHeldItem(pickup.itemData, pickup.iconRenderer);
            _cachedPickupObject = obj;
        }
        else
        {
            ClearHeldItem();
        }
    }

    public void ClearHeldItem()
    {
        _cachedPickupObject = null;
        _currentlyHeldItemData = null;
        if (heldObjectRenderer != null)
        {
            heldObjectRenderer.sprite = null;
            heldObjectRenderer.enabled = false;
        }
    }

    public void DropItem(FollowerController follower, Vector3 position)
    {
        var item = follower.GetHeldPickupObject();
        if (item == null) return;
        item.transform.position = position;
        item.transform.SetParent(null);
        item.SetActive(true);
        follower.ClearHeldItem();
        // Optionally: fire event, update UI, etc.
    }
    
    public void DropHeldItemAt(Vector3 position)
    {
        DropItem(this, position);
    }

    
 #endregion ItemInteractions   
    
#if UNITY_EDITOR
    void OnDrawGizmos()
    {
        if (debugDrawTarget && Application.isPlaying)
        {
            Gizmos.color = Color.cyan;
            Gizmos.DrawSphere(_targetPoint, 0.2f);
            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(transform.position, _targetPoint);
        }
    }
#endif
}