using Core;
using UnityEngine;
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. Turn actions now handled via slingshot input system.
    /// </summary>
    public class GameplayPage : UIPage
    {
        [Header("UI Elements")]
        [SerializeField] private TextMeshProUGUI turnIndicatorText;
        [SerializeField] private TextMeshProUGUI currentPlayerText;
        
        [Header("Optional Visual Elements")]
        [SerializeField] private CanvasGroup canvasGroup;
        [SerializeField] private GameObject playerActionPanel;
        
        private TurnManager turnManager;
        
        #region Initialization
        
        internal override void OnManagedAwake()
        {
            base.OnManagedAwake();
            
            // Validate references
            ValidateReferences();
            
            // Note: takeActionButton is no longer used - turns handled via slingshot input
            
            // Set up canvas group
            if (canvasGroup == null)
            {
                canvasGroup = GetComponent<CanvasGroup>();
            }
        }
        
        internal override void OnManagedStart()
        {
            base.OnManagedStart();
            
            // Get turn manager reference via singleton
            turnManager = TurnManager.Instance;
            
            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!");
            }
            
            // Note: takeActionButton and actionButtonText are no longer used
            // Turns are now handled automatically via slingshot input system
        }
        
        #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);
                }
            }
            else if (turnState == TurnState.PlayerOneTurn || turnState == TurnState.PlayerTwoTurn)
            {
                // Player turn - show controls
                if (playerActionPanel != null)
                {
                    playerActionPanel.SetActive(true);
                }
            }
        }
        
        #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;
            }
        }
        
        #endregion
    }
}