using Core;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using UI.Core;
using Minigames.FortFight.Core;
using Minigames.FortFight.Data;
using Pixelplacement;

namespace Minigames.FortFight.UI
{
    /// <summary>
    /// Main gameplay UI page for Fort Fight minigame.
    /// Displays turn info and allows player to take actions (stubbed for Phase 1).
    /// </summary>
    public class GameplayPage : UIPage
    {
        [Header("UI Elements")]
        [SerializeField] private TextMeshProUGUI turnIndicatorText;
        [SerializeField] private TextMeshProUGUI currentPlayerText;
        [SerializeField] private Button takeActionButton;
        [SerializeField] private TextMeshProUGUI actionButtonText;
        
        [Header("Optional Visual Elements")]
        [SerializeField] private CanvasGroup canvasGroup;
        [SerializeField] private GameObject playerActionPanel;
        [SerializeField] private GameObject aiTurnPanel;
        
        private TurnManager turnManager;
        
        #region Initialization
        
        internal override void OnManagedAwake()
        {
            base.OnManagedAwake();
            
            // Validate references
            ValidateReferences();
            
            // Set up button
            if (takeActionButton != null)
            {
                takeActionButton.onClick.AddListener(OnTakeActionClicked);
            }
            
            // Set up canvas group
            if (canvasGroup == null)
            {
                canvasGroup = GetComponent<CanvasGroup>();
            }
        }
        
        internal override void OnManagedStart()
        {
            base.OnManagedStart();
            
            // Get turn manager reference
            turnManager = FindObjectOfType<TurnManager>();
            
            if (turnManager != null)
            {
                turnManager.OnTurnStarted += OnTurnStarted;
                turnManager.OnTurnEnded += OnTurnEnded;
            }
            else
            {
                Logging.Error("[GameplayPage] TurnManager not found!");
            }
        }
        
        private void ValidateReferences()
        {
            if (turnIndicatorText == null)
            {
                Logging.Warning("[GameplayPage] Turn indicator text not assigned!");
            }
            
            if (currentPlayerText == null)
            {
                Logging.Warning("[GameplayPage] Current player text not assigned!");
            }
            
            if (takeActionButton == null)
            {
                Logging.Error("[GameplayPage] Take action button not assigned!");
            }
            
            if (actionButtonText == null)
            {
                Logging.Warning("[GameplayPage] Action button text not assigned!");
            }
        }
        
        #endregion

        #region Turn Events
        
        /// <summary>
        /// Called when a new turn starts
        /// </summary>
        private void OnTurnStarted(PlayerData currentPlayer, TurnState turnState)
        {
            Logging.Debug($"[GameplayPage] Turn started - Player: {currentPlayer.PlayerName}, State: {turnState}");
            
            UpdateTurnUI(currentPlayer, turnState);
        }
        
        /// <summary>
        /// Called when the current turn ends
        /// </summary>
        private void OnTurnEnded(PlayerData player)
        {
            Logging.Debug($"[GameplayPage] Turn ended for {player.PlayerName}");
        }
        
        #endregion

        #region UI Updates
        
        /// <summary>
        /// Update the UI to reflect current turn state
        /// </summary>
        private void UpdateTurnUI(PlayerData currentPlayer, TurnState turnState)
        {
            // Update turn counter
            if (turnIndicatorText != null && turnManager != null)
            {
                turnIndicatorText.text = $"Turn {turnManager.TurnCount + 1}";
            }
            
            // Update current player display
            if (currentPlayerText != null)
            {
                currentPlayerText.text = $"{currentPlayer.PlayerName}'s Turn";
            }
            
            // Show/hide appropriate panels based on turn state
            if (turnState == TurnState.AITurn)
            {
                // AI turn - hide player controls
                if (playerActionPanel != null)
                {
                    playerActionPanel.SetActive(false);
                }
                
                if (aiTurnPanel != null)
                {
                    aiTurnPanel.SetActive(true);
                }
                
                if (takeActionButton != null)
                {
                    takeActionButton.gameObject.SetActive(false);
                }
            }
            else if (turnState == TurnState.PlayerOneTurn || turnState == TurnState.PlayerTwoTurn)
            {
                // Player turn - show controls
                if (playerActionPanel != null)
                {
                    playerActionPanel.SetActive(true);
                }
                
                if (aiTurnPanel != null)
                {
                    aiTurnPanel.SetActive(false);
                }
                
                if (takeActionButton != null)
                {
                    takeActionButton.gameObject.SetActive(true);
                }
                
                if (actionButtonText != null)
                {
                    actionButtonText.text = "Take Action (Stubbed)";
                }
            }
        }
        
        #endregion

        #region Button Callbacks
        
        /// <summary>
        /// Called when player clicks the "Take Action" button
        /// STUBBED for Phase 1 - just logs and ends turn
        /// </summary>
        private void OnTakeActionClicked()
        {
            if (turnManager == null)
            {
                Logging.Error("[GameplayPage] Cannot take action - TurnManager not found!");
                return;
            }
            
            PlayerData currentPlayer = turnManager.CurrentPlayer;
            
            // STUBBED: Log the action
            Logging.Debug($"[GameplayPage] {currentPlayer.PlayerName} takes action! (STUBBED - no actual combat yet)");
            
            // TODO Phase 3: Replace with actual slingshot/shooting interface
            
            // End the turn
            turnManager.EndTurn();
        }
        
        #endregion

        #region Transitions
        
        protected override void DoTransitionIn(System.Action onComplete)
        {
            // Simple fade in if canvas group is available
            if (canvasGroup != null)
            {
                canvasGroup.alpha = 0f;
                Tween.CanvasGroupAlpha(canvasGroup, 1f, transitionDuration, 0f, Tween.EaseOut, 
                    completeCallback: () => onComplete?.Invoke());
            }
            else
            {
                onComplete?.Invoke();
            }
        }
        
        protected override void DoTransitionOut(System.Action onComplete)
        {
            // Simple fade out if canvas group is available
            if (canvasGroup != null)
            {
                Tween.CanvasGroupAlpha(canvasGroup, 0f, transitionDuration, 0f, Tween.EaseIn, 
                    completeCallback: () => onComplete?.Invoke());
            }
            else
            {
                onComplete?.Invoke();
            }
        }
        
        #endregion

        #region Cleanup
        
        internal override void OnManagedDestroy()
        {
            base.OnManagedDestroy();
            
            // Unsubscribe from turn manager events
            if (turnManager != null)
            {
                turnManager.OnTurnStarted -= OnTurnStarted;
                turnManager.OnTurnEnded -= OnTurnEnded;
            }
            
            // Unsubscribe from button
            if (takeActionButton != null)
            {
                takeActionButton.onClick.RemoveListener(OnTakeActionClicked);
            }
        }
        
        #endregion
    }
}