using System.Threading.Tasks;
using asap.core;
using DataCenter;
using EventPartnerGather;
using game;
using GameCore;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UI.PartnerGather.Mining;
using UniRx;


public class EventPartnerGatherAct : AGameAct
{
    private const bool EnableTraceLogs = false;
    //
    private GameObject _miningScene;
    // 好友界面
    private GameObject _friendsUI;
    // Spin 相关界面
    private GameObject _drawUI;
    //
    private EventPartnerMiningSceneController _miningController;
    private EventPartnerGatherManager _gatherManager;
    private EventPartnerDrawMiningPanel _drawMiningPanel;
    
    private EventPartnerMiningPanel _friendPanel;
    //
    private CompositeDisposable _disposables = new();
    //
    public override async Task<bool> StartAsync()
    {
        Log("StartAsync event=LoadMiningScene");
        // 获取管理器
        _gatherManager = GContext.container.Resolve<EventPartnerGatherManager>();
        _gatherManager.SetGameAct(this);
        
        await ShowUI();
        // 加载挖矿场景
        await InitGatherScene();
        // 显示UI
        SubscribeEvent();
        return await base.StartAsync();
    }
    private async Task InitGatherScene()
    {
        _miningScene = await Addressables.InstantiateAsync("EventPartnerMiningScene").Task;
        // 初始化挖矿控制器
        InitializeMiningController();
        // 绑定UI与控制器关系
        BindUIAndControllers();
        // 初始化数据同步
        InitializeDataSync();
    }

    private void InitializeMiningController()
    {
        Trace($"InitMiningController eventId={_gatherManager?.EventId}");
        
        // 查找或添加挖矿场景控制器
        _miningController = _miningScene.GetComponentInChildren<EventPartnerMiningSceneController>();
        if (!_miningController)
        {
            var controllerObject = _miningScene.transform.Find("MiningController");
            if (!controllerObject)
            {
                controllerObject = new GameObject("MiningController").transform;
                controllerObject.SetParent(_miningScene.transform);
            }
            _miningController = controllerObject.gameObject.AddComponent<EventPartnerMiningSceneController>();
        }
        
        Trace($"InitMiningControllerDone controller={_miningController.name}");
    }
    
    /// <summary>
    /// 绑定UI与控制器的关系
    /// </summary>
    private void BindUIAndControllers()
    {
        Trace($"BindUIAndControllers eventId={_gatherManager?.EventId}");
        
        // 验证UI对象是否存在
        if (!_drawUI)
        {
            LogWarning("BindUIFailed reason=DrawUIObjectNull");
            return;
        }
        
        // 获取UI组件
        _drawMiningPanel = _drawUI.GetComponent<EventPartnerDrawMiningPanel>();
        if (!_drawMiningPanel)
        {
            LogWarning("BindUIFailed reason=DrawMiningPanelMissing");
            return;
        }
        
        _friendPanel = _friendsUI.GetComponent<EventPartnerMiningPanel>();
        if (!_friendPanel)
        {
            LogWarning("BindUIFailed reason=FriendPanelMissing");
        }
        
        // 1. 绑定采集场景与抽奖UI的关系
        if (_miningController)
        {
            try
            {
                _drawMiningPanel.SetMiningScene(_miningController);
                _miningController.SetUIPanel(_drawMiningPanel);
                Trace($"BindSceneSuccess eventId={_gatherManager?.EventId}");
            }
            catch (System.Exception ex)
            {
                LogError($"BindSceneException error={ex.Message}");
            }
        }
        else
        {
            LogWarning("BindUISkipped reason=MiningControllerNull");
        }
        
        // 3. 设置好友UI的事件绑定（如果需要）
        SetupFriendsUIEvents();
        // // 4. 验证所有关键组件是否正确绑定
        // ValidateComponentBindings();
        // Log("所有UI与控制器关系绑定完成");
    }
    
    /// <summary>
    /// 验证组件绑定是否正确
    /// </summary>
    private void ValidateComponentBindings()
    {
        bool allValid = true;
        
        if (!_drawMiningPanel)
        {
            LogWarning("ValidateBindingFailed component=DrawPanel");
            allValid = false;
        }
        
        if (!_miningController)
        {
            LogWarning("ValidateBindingFailed component=MiningController");
            allValid = false;
        }
        
        if (_gatherManager == null)
        {
            LogWarning("ValidateBindingFailed component=GatherManager");
            allValid = false;
        }
        
        if (allValid)
        {
            Trace($"ValidateBindingsSuccess eventId={_gatherManager?.EventId}");
        }
        else
        {
            LogWarning("ValidateBindingFailed result=PartialFailure");
        }
    }
    
    /// <summary>
    /// 初始化数据同步
    /// </summary>
    private void InitializeDataSync()
    {
        Trace($"InitDataSync eventId={_gatherManager?.EventId}");
        // if (_gatherManager?.GatherData != null)
        // {
        //     // 同步初始数据到UI
        //     if (_drawPanelComponent != null)
        //     {
        //         var data = _gatherManager.GatherData;
        //         _drawPanelComponent.SetMiningProgress(data.CurrentMiningProgress);
        //     }
        // }
    }
    
    /// <summary>
    /// 设置好友UI的事件绑定
    /// </summary>
    private void SetupFriendsUIEvents()
    {
        // 如果好友UI有特殊事件需要绑定，在这里处理
        // 例如：点击进入挖矿按钮等
        if (_friendsUI)
        {
            // TODO: 如果好友UI有特定组件需要绑定事件，在这里处理
            Trace($"FriendUIEventsBound eventId={_gatherManager?.EventId}");
        }
    }
    
    private async Task ShowUI()
    {
        _friendsUI = await UIManager.Instance.ShowUI(new UIType("EventPartnerMiningPanel"));
        _drawUI = await UIManager.Instance.ShowUI(new UIType("EventPartnerDrawMiningPanel"));
        _drawUI.SetActive(false); // 先隐藏掉
        
    }
    public override async Task StopAsync()
    {
        Trace($"StopAsyncCleanup eventId={_gatherManager?.EventId}");
        
        UnSubScribeEvent();
        
        CleanupBindings();
        // 清理场景
        if (_miningScene)
        {
            Addressables.ReleaseInstance(_miningScene);
            Destroy(_miningScene);
        }
        // 清理UI
        UIManager.Instance.DestroyUI(new UIType("EventPartnerMiningPanel"));
        UIManager.Instance.DestroyUI(new UIType("EventPartnerDrawMiningPanel"));
        await Awaiters.NextFrame;
    }
    /// <summary>
    /// 清理组件之间的绑定关系
    /// </summary>
    private void CleanupBindings()
    {
        Trace($"CleanupBindings eventId={_gatherManager?.EventId}");
        
        // 清理抽奖UI关系
        if (_drawMiningPanel)
        {
            _drawMiningPanel.SetMiningScene(null);
        }
        
        // 清理挖矿控制器关系
        if (_miningController)
        {
            _miningController.SetUIPanel(null);
        }
    }
    protected override void OnDestroy()
    {
        Trace($"DestroyActCleanup eventId={_gatherManager?.EventId}");
        
        // 清理组件引用
        _miningScene = null;
        _miningController = null;
        _drawMiningPanel = null;
        // _friendsPanelComponent = null;
        
        // 清理管理器引用
        if (_gatherManager != null)
        {
            _gatherManager.SetGameAct(null);
            _gatherManager = null;
        }
    }

    /// <summary>
    /// 进入采集界面（从好友界面切换到抽奖界面）
    /// </summary>
    public async void  OnEnterGather()
    {
        Log($"EnterGatherScene eventId={_gatherManager?.EventId}");
        //
        var loadingUI = await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
        await Awaiters.Seconds(1f);
        _friendsUI?.SetActive(false);
        _drawUI?.SetActive(true);
        
        _miningScene.SetActive(true);
        _miningController?.OnEnter();
        GContext.Publish(new EventPartnerGatherSceneStart());
        loadingUI.GetComponent<CloudTransitionPanel>().EndTransition(new EndTransition());
    }

    public async void OnLeaveGather()
    {
        Log($"LeaveGatherScene eventId={_gatherManager?.EventId}");
        
        var loadingUI = await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
        await Awaiters.Seconds(1f);
        _miningController?.OnLeave();
        _miningScene?.SetActive(false);
        _drawUI?.SetActive(false);
        _friendsUI?.SetActive(true);
        GContext.Publish(new EventPartnerGatherSceneEnd());
        loadingUI.GetComponent<CloudTransitionPanel>().EndTransition(new EndTransition());
        // _friendPanel.RefreshUI();
        // _friendsUI?.gameObject.SetActive(true);
        
        
    }
    
    private static void Log(string message)
    {
        Debug.Log($"<color=cyan>EventPartnerGatherMiningAct => {message}</color>");
    }
    private static void ELog(string message)
    {
#if UNITY_EDITOR
        Debug.Log($"<color=cyan>EventPartnerGatherMiningAct => {message}</color>");
#endif
    }
    private static void LogWarning(string message)
    {
        Debug.LogWarning($"<color=yellow>EventPartnerGatherMiningAct => {message}</color>");
    }
    private static void LogError(string message)
    {
        Debug.LogError($"<color=red>EventPartnerGatherMiningAct => {message}</color>");
    }
    [System.Diagnostics.Conditional("UNITY_EDITOR")]
    private static void Trace(string message)
    {
        if (!EnableTraceLogs) return;
        Log(message);
    }

    /// <summary>
    /// 关闭事件，退出到上一个Act
    /// </summary>
    public void OnCloseEvent()
    {
        Log($"CloseEvent eventId={_gatherManager?.EventId}");
        // 发送退出事件
        GContext.Publish(new UnloadActToNextAct());
    }
    
    public void SubscribeEvent()
    {
        _disposables?.Dispose();
        var rtService = GContext.container.Resolve<IRTService>();
        _disposables = new CompositeDisposable()
        {
            rtService.OnEvent<EventPartnerGatherRequests.EventPartnerGatherPartnerEvt>(OnPartnerChange),
            rtService.OnEvent<EventPartnerGatherRequests.EventPartnerGatherScoreEvt>(OnPartnerBuild)
        };
    }
    public void UnSubScribeEvent()
    {
        _disposables?.Dispose();
        _disposables = null;
    }
    private async void OnPartnerChange(EventPartnerGatherRequests.EventPartnerGatherPartnerEvt e)
    {
        //
        Trace($"PartnerChange eventId={_gatherManager?.EventId} evtType={e.EvtType} slotId={e.SlotId} partnerId={e.PartnerInfo?.PlayFabId}");
        await Awaiters.NextFrame;
        
        var partnerManager = _gatherManager.PartnerInfoManager;
        switch (e.EvtType)
        {
            case 0: //Invited
                partnerManager.AddRequestPartner(e.PartnerInfo);
                GContext.Publish(new EventPartnerRefreshPartnerUI());
                break;
            case 1: //Accepted
                partnerManager.RemoveInvitePartner(e.PartnerInfo?.PlayFabId);
                var bRet = partnerManager.AddBuildPartner(new BuildPartner
                {
                    SlotId = e.SlotId,
                    PartnerId = e.PartnerInfo?.PlayFabId,
                    AvatarUrl = e.PartnerInfo?.AvatarUrl,
                    DisplayName = e.PartnerInfo?.DisplayName,
                });
                if (bRet)
                {
                    GContext.Publish(new EventPartnerGatherAddPartner
                    {
                        SlotId = e.SlotId,
                    });
#if AGG 
                    var userService = GContext.container.Resolve<IUserService> ();
                    using (var gEvent = GEvent.GameEvent("event_partners_gather_invite"))
                    {
                        gEvent.AddContent("teammate_id", e.PartnerInfo?.PlayFabId)
                            .AddContent("position_id", e.SlotId)
                            .AddContent("inviter_id", userService.UserId);
                    }
#endif
                }

                break;
            case -1: //Refused
                
                partnerManager.AddRefusePartner(e.PartnerInfo.PlayFabId);
                partnerManager.RemoveInvitePartner(e.PartnerInfo.PlayFabId);
                partnerManager.OnNoLongerUsedPartner(e.PartnerInfo.PlayFabId);
                break;
        }
    }
    private async void OnPartnerBuild(EventPartnerGatherRequests.EventPartnerGatherScoreEvt e)
    {
        // 保证在主线程
        await Awaiters.NextFrame;
        var partnerManager = _gatherManager.PartnerInfoManager;
        var bRet = partnerManager.UpdatePartnerScore(e.PartnerId, e.Score);
        if (bRet)
        {
            GContext.Publish(new EventPartnerGatherPartnerAddScore
            {
                partnerId = e.PartnerId,
                score = e.Score
            });
            var buildPartner = partnerManager.GetPartnerById(e.PartnerId);
            ELog($"PartnerBuildScore eventId={_gatherManager?.EventId} slotId={buildPartner.SlotId} score={e.Score}");
        }
    }
}