using AppleHills.Core.Interfaces;
using AppleHills.Core.Settings;
using AppleHillsCamera;
using Core;
using Input;
using UnityEngine;

namespace Minigames.DivingForPictures.Player 
{
    /// <summary>
    /// Handles endless descender movement in response to tap and hold input events.
    /// Moves the character horizontally to follow the finger or tap position.
    /// </summary>
    public class PlayerController : MonoBehaviour, ITouchInputConsumer, IPausable
    {
        
        [Tooltip("Reference to the edge anchor that this player should follow for Y position")]
        [SerializeField] private EdgeAnchor edgeAnchor;
        
        // Settings reference
        private IDivingMinigameSettings settings;
        
        private float targetFingerX;
        private bool isTouchActive;
        private float originY;
        
        // Tap impulse system variables
        private float tapImpulseStrength = 0f;
        private float tapDirection = 0f;
        
        // Initialization flag
        private bool isInitialized = false;

        void Awake()
        {
            originY = transform.position.y;
            
            // Get settings from GameManager
            settings = GameManager.GetSettingsObject<IDivingMinigameSettings>();
            if (settings == null)
            {
                Debug.LogError("[PlayerController] Failed to load diving minigame settings!");
            }
        }

        void OnEnable()
        {
            // Register as a pausable component with DivingGameManager
            DivingGameManager.Instance.RegisterPausableComponent(this);
        }
        
        void Start()
        {
            // Initialize target to current position
            targetFingerX = transform.position.x;
            isTouchActive = false;
            
            // Try to find edge anchor if not assigned
            if (edgeAnchor == null)
            {
                // First try to find edge anchor on the same object or parent
                edgeAnchor = GetComponentInParent<EdgeAnchor>();
                
                // If not found, find any edge anchor in the scene
                if (edgeAnchor == null)
                {
                    edgeAnchor = FindFirstObjectByType<EdgeAnchor>();
                    if (edgeAnchor == null)
                    {
                        Logging.Warning("[PlayerController] No EdgeAnchor found in scene. Origin Y position won't update with camera changes.");
                    }
                    else
                    {
                        Logging.Debug($"[PlayerController] Auto-connected to EdgeAnchor on {edgeAnchor.gameObject.name}");
                    }
                }
            }
            
            // Subscribe to edge anchor events if it exists
            if (edgeAnchor != null)
            {
                // Unsubscribe first to prevent duplicate subscriptions
                edgeAnchor.OnPositionUpdated -= UpdateOriginYFromAnchor;
                edgeAnchor.OnPositionUpdated += UpdateOriginYFromAnchor;
                
                // Update origin Y based on current anchor position
                UpdateOriginYFromAnchor();
            }
            
            DivingGameManager.Instance.OnGameInitialized += Initialize;
            
            // If game is already initialized, initialize immediately
            if (DivingGameManager.Instance.GetType().GetField("_isGameInitialized", 
                System.Reflection.BindingFlags.NonPublic | 
                System.Reflection.BindingFlags.Instance)?.GetValue(DivingGameManager.Instance) is bool isInitialized && isInitialized)
            {
                Initialize();
            }
        }
        
        /// <summary>
        /// Initializes the player controller when triggered by DivingGameManager
        /// </summary>
        private void Initialize()
        {
            if (isInitialized) return;
            
            // Register as default consumer for input
            InputManager.Instance?.SetDefaultConsumer(this);
            
            isInitialized = true;
            Logging.Debug("[PlayerController] Initialized");
        }
        
        private void OnDestroy()
        {
            DivingGameManager.Instance.OnGameInitialized -= Initialize;
            
            // Unregister as a pausable component
            DivingGameManager.Instance.UnregisterPausableComponent(this);
            
            // Unsubscribe from edge anchor events
            if (edgeAnchor != null)
            {
                edgeAnchor.OnPositionUpdated -= UpdateOriginYFromAnchor;
            }
        }

        /// <summary>
        /// Handles tap input. Applies an impulse in the tapped direction.
        /// </summary>
        public void OnTap(Vector2 worldPosition)
        {
            // Ignore input when paused
            if (isPaused) return;
            
            // Logging.Debug($"[EndlessDescenderController] OnTap at {worldPosition}");
            float targetX = Mathf.Clamp(worldPosition.x, settings.ClampXMin, settings.ClampXMax);
            
            // Calculate tap direction (+1 for right, -1 for left)
            tapDirection = Mathf.Sign(targetX - transform.position.x);
            
            // Set impulse strength to full
            tapImpulseStrength = 1.0f;
            
            // Store target X for animation purposes
            targetFingerX = targetX;
            
            // Do not set _isTouchActive for taps anymore
            // _isTouchActive = true; - Removed to prevent continuous movement
        }

        /// <summary>
        /// Handles the start of a hold input. Begins tracking the finger.
        /// </summary>
        public void OnHoldStart(Vector2 worldPosition)
        {
            // Ignore input when paused
            if (isPaused) return;
            
            // Logging.Debug($"[EndlessDescenderController] OnHoldStart at {worldPosition}");
            targetFingerX = Mathf.Clamp(worldPosition.x, settings.ClampXMin, settings.ClampXMax);
            isTouchActive = true;
        }

        /// <summary>
        /// Handles hold move input. Updates the target X position as the finger moves.
        /// </summary>
        public void OnHoldMove(Vector2 worldPosition)
        {
            // Ignore input when paused
            if (isPaused) return;
            
            // Logging.Debug($"[EndlessDescenderController] OnHoldMove at {worldPosition}");
            targetFingerX = Mathf.Clamp(worldPosition.x, settings.ClampXMin, settings.ClampXMax);
        }

        /// <summary>
        /// Handles the end of a hold input. Stops tracking.
        /// </summary>
        public void OnHoldEnd(Vector2 worldPosition)
        {
            // Ignore input when paused
            if (isPaused) return;
            
            // Logging.Debug($"[EndlessDescenderController] OnHoldEnd at {worldPosition}");
            isTouchActive = false;
        }

        void Update()
        {
            // Skip movement processing if paused
            if (isPaused) return;
            
            // Handle hold movement
            if (isTouchActive) 
            {
                float currentX = transform.position.x;
                float lerpSpeed = settings.LerpSpeed;
                float maxOffset = settings.MaxOffset;
                float exponent = settings.SpeedExponent;
                float targetX = targetFingerX;
                float offset = targetX - currentX;
                offset = Mathf.Clamp(offset, -maxOffset, maxOffset);
                float absOffset = Mathf.Abs(offset);
                float t = Mathf.Pow(absOffset / maxOffset, exponent); // Non-linear drop-off
                float moveStep = Mathf.Sign(offset) * maxOffset * t * Time.deltaTime * lerpSpeed;
                // Prevent overshooting
                moveStep = Mathf.Clamp(moveStep, -absOffset, absOffset);
                float newX = currentX + moveStep;
                newX = Mathf.Clamp(newX, settings.ClampXMin, settings.ClampXMax);
                
                UpdatePosition(newX);
            }
            // Handle tap impulse movement
            else if (tapImpulseStrength > 0)
            {
                float currentX = transform.position.x;
                float maxOffset = settings.MaxOffset;
                float lerpSpeed = settings.LerpSpeed;
                
                // Calculate move distance based on impulse strength
                float moveDistance = maxOffset * tapImpulseStrength * Time.deltaTime * lerpSpeed;
                
                // Limit total movement from single tap
                moveDistance = Mathf.Min(moveDistance, settings.TapMaxDistance * tapImpulseStrength);
                
                // Apply movement in tap direction
                float newX = currentX + (moveDistance * tapDirection);
                newX = Mathf.Clamp(newX, settings.ClampXMin, settings.ClampXMax);
                
                // Reduce impulse strength over time
                tapImpulseStrength -= Time.deltaTime * settings.TapDecelerationRate;
                if (tapImpulseStrength < 0.01f)
                {
                    tapImpulseStrength = 0f;
                }
                
                UpdatePosition(newX);
            }
        }
        
        /// <summary>
        /// Updates the player's position with the given X coordinate
        /// </summary>
        private void UpdatePosition(float newX)
        {
            float newY = originY;
            // Add vertical offset from WobbleBehavior if present
            WobbleBehavior wobble = GetComponent<WobbleBehavior>();
            if (wobble != null)
            {
                newY += wobble.VerticalOffset;
            }
            transform.position = new Vector3(newX, newY, transform.position.z);
        }

        /// <summary>
        /// Updates the origin Y position based on camera adjustments
        /// </summary>
        public void UpdateOriginY(float newOriginY)
        {
            originY = newOriginY;
        }
        
        /// <summary>
        /// Updates the origin Y position based on the current position of the player
        /// This method is intended to be called by the camera adapter when the camera is adjusted.
        /// </summary>
        private void UpdateOriginYFromCurrentPosition()
        {
            originY = transform.position.y;
        }

        /// <summary>
        /// Updates the origin Y position based on the current position of the edge anchor
        /// This method is intended to be called by the edge anchor when its position is updated.
        /// </summary>
        private void UpdateOriginYFromAnchor()
        {
            originY = edgeAnchor.transform.position.y;
        }

        #region IPausable Implementation
        private bool isPaused = false;
        
        /// <summary>
        /// Pauses the player controller, blocking all input processing
        /// </summary>
        public void Pause()
        {
            if (isPaused) return;
            
            isPaused = true;
            
            // If we're being paused, stop any active touch and tap impulse
            isTouchActive = false;
            tapImpulseStrength = 0f;
            
            Logging.Debug("[PlayerController] Paused");
        }

        /// <summary>
        /// Resumes the player controller, allowing input processing again
        /// </summary>
        public void DoResume()
        {
            if (!isPaused) return;
            
            isPaused = false;
            Logging.Debug("[PlayerController] Resumed");
        }

        /// <summary>
        /// Returns whether the player controller is currently paused
        /// </summary>
        public bool IsPaused => isPaused;
        #endregion
    }
}