using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using AppleHills.Core.Settings;
using Core;
using Core.Lifecycle;

namespace Input
{
    public enum InputMode
    {
        Game,
        UI,
        GameAndUI,
        InputDisabled
    } 
    
    /// <summary>
    /// Handles input events and dispatches them to the appropriate ITouchInputConsumer.
    /// Supports tap and hold/drag logic, with interactable delegation and debug logging.
    /// </summary>
    public class InputManager : ManagedBehaviour
    {
        private const string UiActions = "UI";
        private const string GameActions = "PlayerTouch";
        
        private static InputManager _instance;

        // Override consumer stack - using a list to support multiple overrides that can be removed in LIFO order
        private readonly List<ITouchInputConsumer> _overrideConsumers = new List<ITouchInputConsumer>();

        // Track which consumer is handling the current hold operation
        private ITouchInputConsumer _activeHoldConsumer;

        /// <summary>
        /// Singleton instance of the InputManager. No longer creates an instance if one doesn't exist.
        /// </summary>
        public static InputManager Instance => _instance;

        // Settings reference
        private IInteractionSettings _interactionSettings;
        
        private PlayerInput playerInput;
        private InputAction tapMoveAction;
        private InputAction holdMoveAction;
        private InputAction positionAction;
        private ITouchInputConsumer defaultConsumer;
        private bool isHoldActive;
        private LogVerbosity _logVerbosity = LogVerbosity.Warning;
        
        internal override void OnManagedAwake()
        {
            // Set instance immediately (early initialization)
            _instance = this;
            
            // Load verbosity settings early
            _logVerbosity = DeveloperSettingsProvider.Instance.GetSettings<DebugSettings>().inputLogVerbosity;
            
            // Initialize settings reference early (GameManager sets these up in its Awake)
            _interactionSettings = GameManager.GetSettingsObject<IInteractionSettings>();
            
            // Set up PlayerInput component and actions - critical for input to work
            playerInput = GetComponent<PlayerInput>();
            if (playerInput == null)
            {
                Debug.LogError("[InputManager] InputManager requires a PlayerInput component attached to the same GameObject.");
                return;
            }
            
            tapMoveAction = playerInput.actions.FindAction("TapMove", false);
            holdMoveAction = playerInput.actions.FindAction("HoldMove", false);
            positionAction = playerInput.actions.FindAction("TouchPosition", false);
            
            if (tapMoveAction != null)
                tapMoveAction.performed += OnTapMovePerformed;
            if (holdMoveAction != null)
            {
                holdMoveAction.performed += OnHoldMoveStarted;
                holdMoveAction.canceled += OnHoldMoveCanceled;
            }
            
            // Initialize input mode for current scene
            SwitchInputOnSceneLoaded(SceneManager.GetActiveScene().name);
        }
        
        internal override void OnManagedStart()
        {
            // Subscribe to scene load events from SceneManagerService
            // This must happen in ManagedStart because SceneManagerService instance needs to be set first
            if (SceneManagerService.Instance != null)
            {
                SceneManagerService.Instance.SceneLoadCompleted += OnSceneLoadCompleted;
            }
        }
        
        /// <summary>
        /// Called when any scene finishes loading. Restores input to GameAndUI mode.
        /// </summary>
        private void OnSceneLoadCompleted(string sceneName)
        {
            Logging.Debug($"Scene loaded: {sceneName}, restoring input mode");
            SwitchInputOnSceneLoaded(sceneName);
        }
        
        internal override void OnManagedDestroy()
        {
            // Unsubscribe from SceneManagerService events
            if (SceneManagerService.Instance != null)
            {
                SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
            }
            
            // Input action cleanup happens automatically
        }

        private void SwitchInputOnSceneLoaded(string sceneName)
        {
            if (sceneName.ToLower().Contains("mainmenu"))
            {
                SetInputMode(InputMode.GameAndUI);
            }
            else
            {
                SetInputMode(InputMode.GameAndUI);
            }
        }

        public void SetInputMode(InputMode inputMode)
        {
            switch (inputMode)
            {
                case InputMode.UI:
                    playerInput.actions.FindActionMap(UiActions).Enable();
                    playerInput.actions.FindActionMap(GameActions).Disable();
                    break;
                case InputMode.Game:
                    playerInput.actions.FindActionMap(UiActions).Disable();
                    playerInput.actions.FindActionMap(GameActions).Enable();
                    break;
                case InputMode.GameAndUI:
                    playerInput.actions.FindActionMap(UiActions).Enable();
                    playerInput.actions.FindActionMap(GameActions).Enable();
                    break;
                case InputMode.InputDisabled:
                    playerInput.actions.FindActionMap(UiActions).Disable();
                    playerInput.actions.FindActionMap(GameActions).Disable();
                    break;
            }
        }

        void OnDisable()
        {
            if (tapMoveAction != null)
                tapMoveAction.performed -= OnTapMovePerformed;
            if (holdMoveAction != null)
            {
                holdMoveAction.performed -= OnHoldMoveStarted;
                holdMoveAction.canceled -= OnHoldMoveCanceled;
            }
        }
        
        /// <summary>
        /// Sets the default ITouchInputConsumer to receive input events.
        /// </summary>
        public void SetDefaultConsumer(ITouchInputConsumer consumer)
        {
            defaultConsumer = consumer;
        }

        /// <summary>
        /// Handles tap input, delegates to interactable if present, otherwise to default consumer.
        /// </summary>
        private void OnTapMovePerformed(InputAction.CallbackContext ctx)
        {
            Vector2 screenPos = positionAction.ReadValue<Vector2>();
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
            Vector2 worldPos2D = new Vector2(worldPos.x, worldPos.y);
            Logging.Debug($"TapMove performed at {worldPos2D}");

            // First try to delegate to an override consumer if available
            if (TryDelegateToOverrideConsumer(screenPos, worldPos2D))
            {
                Logging.Debug("Tap delegated to override consumer");
                return;
            }

            // Then try to delegate to any ITouchInputConsumer (UI or world interactable)
            if (!TryDelegateToAnyInputConsumer(screenPos, worldPos2D))
            {
                Logging.Debug("No input consumer found, forwarding tap to default consumer");
                defaultConsumer?.OnTap(worldPos2D);
            }
            else
            {
                Logging.Debug("Tap delegated to input consumer");
            }
        }

        /// <summary>
        /// Handles the start of a hold input.
        /// </summary>
        private void OnHoldMoveStarted(InputAction.CallbackContext ctx)
        {
            isHoldActive = true;
            Vector2 screenPos = positionAction.ReadValue<Vector2>();
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
            Vector2 worldPos2D = new Vector2(worldPos.x, worldPos.y);
            Logging.Debug($"HoldMove started at {worldPos2D}");
            
            // First check for override consumers
            if (_overrideConsumers.Count > 0)
            {
                _activeHoldConsumer = _overrideConsumers[_overrideConsumers.Count - 1];
                Logging.Debug($"Hold delegated to override consumer: {_activeHoldConsumer}");
                _activeHoldConsumer.OnHoldStart(worldPos2D);
                return;
            }
            
            // If no override consumers, use default consumer
            _activeHoldConsumer = defaultConsumer;
            defaultConsumer?.OnHoldStart(worldPos2D);
        }

        /// <summary>
        /// Handles the end of a hold input.
        /// </summary>
        private void OnHoldMoveCanceled(InputAction.CallbackContext ctx)
        {
            if (!isHoldActive) return;
            isHoldActive = false;
            Vector2 screenPos = positionAction.ReadValue<Vector2>();
            Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
            Vector2 worldPos2D = new Vector2(worldPos.x, worldPos.y);
            Logging.Debug($"HoldMove canceled at {worldPos2D}");
            
            // Notify the active hold consumer that the hold has ended
            _activeHoldConsumer?.OnHoldEnd(worldPos2D);
            _activeHoldConsumer = null;
        }

        /// <summary>
        /// Continuously updates hold move input while active.
        /// </summary>
        void Update()
        {
            if (isHoldActive && holdMoveAction != null && holdMoveAction.phase == InputActionPhase.Performed)
            {
                Vector2 screenPos = positionAction.ReadValue<Vector2>();
                Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
                Vector2 worldPos2D = new Vector2(worldPos.x, worldPos.y);
                // LogDebugMessage($"HoldMove update at {worldPos2D}");
                
                // Send hold move updates to the active hold consumer
                _activeHoldConsumer?.OnHoldMove(worldPos2D);
            }
        }

        /// <summary>
        /// Attempts to delegate a tap to any ITouchInputConsumer at the given position.
        /// Checks both UI elements and world interactables.
        /// </summary>
        private bool TryDelegateToAnyInputConsumer(Vector2 screenPos, Vector2 worldPos)
        {
            // First check if we hit a UI element implementing ITouchInputConsumer
            if (TryDelegateToUIInputConsumer(screenPos))
            {
                return true;
            }
            
            // If no UI element with ITouchInputConsumer, try world interactables
            return TryDelegateToInteractable(worldPos);
        }
        
        /// <summary>
        /// Attempts to delegate a tap to a UI element implementing ITouchInputConsumer.
        /// </summary>
        private bool TryDelegateToUIInputConsumer(Vector2 screenPos)
        {
            // Check for UI elements under the pointer
            var eventData = new PointerEventData(EventSystem.current)
            {
                position = screenPos
            };
            
            var results = new System.Collections.Generic.List<RaycastResult>();
            EventSystem.current.RaycastAll(eventData, results);
            
            foreach (var result in results)
            {
                // Try to get ITouchInputConsumer component
                var consumer = result.gameObject.GetComponent<ITouchInputConsumer>();
                if (consumer == null)
                {
                    consumer = result.gameObject.GetComponentInParent<ITouchInputConsumer>();
                }
                if (consumer != null)
                {
                    Logging.Debug($"Delegating tap to UI consumer at {screenPos} (GameObject: {result.gameObject.name})");
                    consumer.OnTap(screenPos);
                    return true;
                }
            }
            
            return false;
        }

        /// <summary>
        /// Attempts to delegate a tap to an interactable at the given world position.
        /// Traces on the "Interactable" channel and logs detailed info.
        /// </summary>
        private bool TryDelegateToInteractable(Vector2 worldPos)
        {
            // First try with the interaction layer mask if available
            if (_interactionSettings != null)
            {
                LayerMask mask = _interactionSettings.InteractableLayerMask;
                Collider2D hitWithMask = Physics2D.OverlapPoint(worldPos, mask);
                if (hitWithMask != null)
                {
                    var consumer = hitWithMask.GetComponent<ITouchInputConsumer>();
                    if (consumer == null)
                    {
                        consumer = hitWithMask.GetComponentInParent<ITouchInputConsumer>();
                    }
                    if (consumer != null)
                    {
                        Logging.Debug($"Delegating tap to consumer at {worldPos} (GameObject: {hitWithMask.gameObject.name})");
                        consumer.OnTap(worldPos);
                        return true;
                    }
                }
            }
            
            // If no hit with the mask or no settings available, try with all colliders
            Collider2D hit = Physics2D.OverlapPoint(worldPos);
            if (hit != null)
            {
                var consumer = hit.GetComponent<ITouchInputConsumer>();
                if (consumer != null)
                {
                    Logging.Debug($"Delegating tap to consumer at {worldPos} (GameObject: {hit.gameObject.name})");
                    consumer.OnTap(worldPos);
                    return true;
                }
                Logging.Debug($"Collider2D hit at {worldPos} (GameObject: {hit.gameObject.name}), but no ITouchInputConsumer found.");
            }
            else
            {
                Logging.Debug($"No Collider2D found at {worldPos} for interactable delegation.");
            }
            return false;
        }

        /// <summary>
        /// Registers an override consumer to receive input events.
        /// The most recently registered consumer will receive input first.
        /// </summary>
        public void RegisterOverrideConsumer(ITouchInputConsumer consumer)
        {
            if (consumer == null || _overrideConsumers.Contains(consumer))
                return;

            _overrideConsumers.Add(consumer);
            Logging.Debug($"Override consumer registered: {consumer}");
        }

        /// <summary>
        /// Unregisters an override consumer, removing it from the input event delegation.
        /// </summary>
        public void UnregisterOverrideConsumer(ITouchInputConsumer consumer)
        {
            if (consumer == null || !_overrideConsumers.Contains(consumer))
                return;

            // If this is the active hold consumer, reset it
            if (_activeHoldConsumer == consumer)
            {
                _activeHoldConsumer = null;
            }
            
            _overrideConsumers.Remove(consumer);
            Logging.Debug($"Override consumer unregistered: {consumer}");
        }

        /// <summary>
        /// Clears all registered override consumers.
        /// </summary>
        public void ClearOverrideConsumers()
        {
            _activeHoldConsumer = null;
            _overrideConsumers.Clear();
            Logging.Debug("All override consumers cleared.");
        }

        /// <summary>
        /// Attempts to delegate a tap to the topmost registered override consumer, if any.
        /// </summary>
        private bool TryDelegateToOverrideConsumer(Vector2 screenPos, Vector2 worldPos)
        {
            if (_overrideConsumers.Count == 0)
                return false;

            // Get the topmost override consumer (last registered)
            var consumer = _overrideConsumers[_overrideConsumers.Count - 1];
            Logging.Debug($"Delegating tap to override consumer at {worldPos} (GameObject: {consumer})");
            consumer.OnTap(worldPos);
            return true;
        }
    }
}