using System;
using System.Collections.Generic;
using System.Linq;
using Adventurer.Runtime;
using Core.Runtime;
using EventSystem.Runtime;
using Player.Runtime;
using Quest.Runtime;
using Quests.Runtime;
using UnityEngine;
using UnityEngine.UI;

namespace TestFacts.Runtime
{
    /// <summary>
    /// Automation orientée "vidéo promo" qui ouvre et utilise les différents panels UI
    /// pour illustrer un flow complet:
    /// 1) Ouvrir le panel de recrutement et acheter un aventurier
    /// 2) Ouvrir le panneau du tableau des quêtes et accepter une quête
    /// 3) Ouvrir le panneau des quêtes acceptées, afficher la fiche (InfoQuestPanel)
    /// 4) Sélectionner un aventurier via l'UI et lancer la quête
    /// 5) (Option promo) Compléter immédiatement la quête pour montrer l'écran terminé
    /// 
    /// Placez ce composant sur un GameObject de la scène Marketing/Game avec les références UI assignées.
    /// </summary>
    public class PromoUIFlow : BaseMonoBehaviour
    {
        [Header("Références UI")]
        [SerializeField] UIManager _uiManager;
        [Tooltip("Panel boutique de recrutement (contenant RecruitementPanel)")]
        [SerializeField] GameObject _recruitementPanel;
        [Tooltip("Panel du tableau des quêtes disponibles (contenant QuestsBoardPanel)")]
        [SerializeField] GameObject _questsBoardPanel;
        [Tooltip("Panel des quêtes (liste des quêtes acceptées)")]
        [SerializeField] GameObject _questsPanel;
        [Tooltip("Panel Info d'une quête (contenant InfoQuestPanel)")]
        [SerializeField] GameObject _infoQuestPanel;

        [Header("Données (optionnelles)")]
        [SerializeField] AdventurerFactorySO _adventurerFactory;
        [SerializeField] QuestFactoryDatabase _questDatabase;

        [Header("Délais (s)")]
        [SerializeField] float _delayOpenRecruit = 0.6f;
        [SerializeField] float _delayBuy = 0.8f;
        [SerializeField] float _delayOpenBoard = 1.0f;
        [SerializeField] float _delayAcceptQuest = 0.8f;
        [SerializeField] float _delayOpenAcceptedPanel = 0.8f;
        [SerializeField] float _delayOpenInfo = 0.6f;
        [SerializeField] float _delaySelectAdventurer = 0.6f;
        [SerializeField] float _delayLaunch = 0.6f;
        [SerializeField] float _delayComplete = 0.8f;

        [Header("Options")]
        [SerializeField] int _fallbackGuildLevel = 1;
        [SerializeField] bool _autoCompleteForPromo = true;

        void Start()
        {
            EnsureBaselineFacts();
            Invoke(nameof(Step_OpenRecruitPanel), _delayOpenRecruit);
        }

        // 1) Ouvrir panel recrutement
        void Step_OpenRecruitPanel()
        {
            try
            {
                if (_uiManager != null && _recruitementPanel != null)
                {
                    _uiManager.HideAllPanels();
                    _uiManager.ShowPanel(_recruitementPanel);
                }
                Info("🎬 Ouverture panel Recrutement", Color.cyan);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] OpenRecruit error: {ex}");
            }
            Invoke(nameof(Step_BuyFirstAdventurer), _delayBuy);
        }

        // 1b) Acheter le 1er aventurier via la carte UI
        void Step_BuyFirstAdventurer()
        {
            try
            {
                if (_recruitementPanel != null)
                {
                    var card = _recruitementPanel.GetComponentsInChildren<GameUI.Runtime.AdventurerCardUI>(true)
                        .FirstOrDefault(c => c.m_buyButton != null);
                    if (card == null)
                    {
                        // Forcer une génération si rien n'est présent (le panel devrait déjà le faire à OnEnable)
                        var rp = _recruitementPanel.GetComponentInChildren<GameUI.Runtime.RecruitementPanel>(true);
                        if (rp != null && _adventurerFactory != null)
                        {
                            rp.m_adventurersSO = _adventurerFactory;
                            rp.GenerateAdventurer(4);
                        }
                        card = _recruitementPanel.GetComponentsInChildren<GameUI.Runtime.AdventurerCardUI>(true)
                            .FirstOrDefault(c => c.m_buyButton != null);
                    }
                    if (card != null && card.m_buyButton != null)
                    {
                        card.m_buyButton.onClick?.Invoke();
                        Info($"🧙 Aventurier acheté: {card.Adventurer?.Name}", Color.green);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] Buy error: {ex}");
            }
            Invoke(nameof(Step_OpenQuestsBoard), _delayOpenBoard);
        }

        // 2) Ouvrir le tableau des quêtes et accepter la 1ère
        void Step_OpenQuestsBoard()
        {
            try
            {
                if (_uiManager != null && _questsBoardPanel != null)
                {
                    _uiManager.HideAllPanels();
                    _uiManager.ShowPanel(_questsBoardPanel);
                }
                Info("📋 Ouverture tableau des quêtes", Color.cyan);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] OpenBoard error: {ex}");
            }
            Invoke(nameof(Step_AcceptFirstQuestOnBoard), _delayAcceptQuest);
        }

        void Step_AcceptFirstQuestOnBoard()
        {
            try
            {
                QuestManager.Instance.NotifyAvailableQuestsUpdated(EnsurePlayerFact().GuildLevel);
                var card = _questsBoardPanel != null
                    ? _questsBoardPanel.GetComponentsInChildren<GameUI.Runtime.QuestCardUI>(true).FirstOrDefault()
                    : null;
                if (card == null)
                {
                    // Fallback: générer une quête à partir de la DB si possible
                    var templ = _questDatabase?.GetAll()?.FirstOrDefault()?.questTemplates?.FirstOrDefault();
                    if (templ != null)
                    {
                        var generated = templ.ToQuestClass(QuestStateEnum.Disponible);
                        var go = new GameObject("GeneratedQuestCardForPromo");
                        var qc = go.AddComponent<GameUI.Runtime.QuestCardUI>();
                        qc.Setup(generated);
                        card = qc;
                    }
                }
                if (card != null)
                {
                    card.AcceptQuest();
                    Info($"✅ Quête acceptée: {card.Quest?.Name}", Color.green);
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] Accept quest error: {ex}");
            }
            Invoke(nameof(Step_OpenAcceptedQuestsPanel), _delayOpenAcceptedPanel);
        }

        // 3) Ouvrir la liste des quêtes acceptées
        void Step_OpenAcceptedQuestsPanel()
        {
            try
            {
                if (_uiManager != null && _questsPanel != null)
                {
                    _uiManager.HideAllPanels();
                    _uiManager.ShowPanel(_questsPanel);
                }
                QuestSignals.RaiseRefreshQuests();
                Info("📜 Ouverture panel Quêtes (acceptées)", Color.cyan);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] OpenAccepted error: {ex}");
            }
            Invoke(nameof(Step_OpenInfoForFirstQuest), _delayOpenInfo);
        }

        // 3b) Ouvrir la fiche info d'une quête via la carte d'interaction
        void Step_OpenInfoForFirstQuest()
        {
            try
            {
                var inter = _questsPanel != null
                    ? _questsPanel.GetComponentsInChildren<GameUI.Runtime.InteractionQuestCard>(true).FirstOrDefault()
                    : null;
                if (inter != null)
                {
                    inter.OnClick(); // ouvre InfoQuestPanel via le signal
                }
                else
                {
                    // Fallback: prendre la première quête acceptée et forcer l'ouverture
                    var accepted = GetFact<List<QuestClass>>("accepted_quests");
                    var quest = accepted?.FirstOrDefault();
                    if (quest != null)
                    {
                        QuestSignals.RaiseInfoQuestPanel(quest);
                    }
                }
                Info("ℹ️ Ouverture InfoQuestPanel", Color.cyan);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] OpenInfo error: {ex}");
            }
            Invoke(nameof(Step_SelectAdventurerInInfoPanel), _delaySelectAdventurer);
        }

        // 4) Sélectionner un aventurier sur l'UI et lancer la quête
        void Step_SelectAdventurerInInfoPanel()
        {
            try
            {
                if (_infoQuestPanel != null)
                {
                    // Tenter de cliquer sur une carte sélectionnable d'aventurier
                    var selectable = _infoQuestPanel.GetComponentsInChildren<GameUI.Runtime.AdventurerCardSelectionnable>(true)
                        .FirstOrDefault();
                    if (selectable == null)
                    {
                        // Parfois les cartes sont ailleurs (liste globale), on tente dans toute la scène
                        selectable = GameObject.FindObjectsOfType<GameUI.Runtime.AdventurerCardSelectionnable>(true).FirstOrDefault();
                    }
                    if (selectable != null)
                    {
                        selectable.OnClick(); // Envoie AdventurerSignals.OnAdventurerSelected
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] Select adventurer error: {ex}");
            }
            Invoke(nameof(Step_LaunchQuestFromInfoPanel), _delayLaunch);
        }

        void Step_LaunchQuestFromInfoPanel()
        {
            try
            {
                if (_infoQuestPanel != null)
                {
                    var info = _infoQuestPanel.GetComponent<GameUI.Runtime.InfoQuestPanel>();
                    if (info != null)
                    {
                        info.LaunchQuest();
                        Info("🚀 Quête lancée", Color.yellow);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] Launch quest error: {ex}");
            }
            if (_autoCompleteForPromo)
                Invoke(nameof(Step_CompleteQuestNow), _delayComplete);
        }

        // 5) Option promo: compléter immédiatement la quête pour montrer l'état terminé
        void Step_CompleteQuestNow()
        {
            try
            {
                var quest = QuestManager.Instance.CurrentQuest;
                if (quest == null)
                {
                    Warning("Aucune quête courante à compléter.");
                    return;
                }
                // Utiliser l'équipe d'un seul aventurier (le premier dispo)
                var team = EnsureMyAdventurersFact();
                if (team.Count == 0) return;
                var ids = QuestClass.GetIdFromAdventurers(new List<AdventurerClass> { team[0] });

                if (quest.State != QuestStateEnum.InProgress)
                {
                    // S'assure que l'état est correct pour compléter
                    var gameTime = GetFact<GameTime>("game_time");
                    QuestManager.Instance.StartQuest(quest, new List<AdventurerClass> { team[0] }, gameTime);
                }

                QuestManager.Instance.CompleteQuest(quest, ids);
                QuestManager.Instance.NotifyCompletedQuests();
                QuestSignals.RaiseRefreshQuests();
                Info($"🏁 Quête complétée (promo): {quest.Name}", Color.green);
            }
            catch (Exception ex)
            {
                Debug.LogError($"[PromoUIFlow] Complete quest error: {ex}");
            }
        }

        // --- Utils -----------------------------------------------------------
        void EnsureBaselineFacts()
        {
            var player = EnsurePlayerFact();
            player.Money = Mathf.Max(player.Money, 9999);
            player.AdventurersMax = Mathf.Max(player.AdventurersMax, 10);
            SaveFacts();
        }

        PlayerClass EnsurePlayerFact()
        {
            if (!FactExists<PlayerClass>(GameManager.Instance.Profile, out var player) || player == null)
            {
                player = new PlayerClass("Promo Guild", _fallbackGuildLevel, 9999, 10);
                SetFact(GameManager.Instance.Profile, player, FactPersistence.Persistent);
            }
            return player;
        }

        List<AdventurerClass> EnsureMyAdventurersFact()
        {
            if (!FactExists<List<AdventurerClass>>("my_adventurers", out var list) || list == null)
            {
                list = new List<AdventurerClass>();
                SetFact("my_adventurers", list, FactPersistence.Persistent);
            }
            return list;
        }
    }
}