// 访问接口入口：
ICloudSync.Instance;
ICloudMatchManager MatchManager = ICloudSync.Instance.MatchManager;

// 云同步初始化
ICloudSync.Instance.Init(...)

// 请求匹配： 
MatchManager.RequestMatch(...)

// 结束同玩：
MatchManager.EndMatchGame(...)

// 监听事件：玩家加入/离开
ICloudSync.Instance.OnSeatPlayerJoined
ICloudSync.Instance.OnSeatPlayerLeaving

// 监听事件：匹配到了其他用户
MatchManager.OnMatchUsers
// 监听事件：结束同玩了（返回单播）
MatchManager.OnEndMatchEvent

// 监听事件：云游戏即将销毁（Host主机关闭玩法、退出云游戏）
ICloudSync.Instance.OnWillDestroy

private async Task<bool> InitCloudGame(string appId)
{
    // 云同步初始化 Init
    // 传入实参：`new UDeviceFactory(viewProvider)` - 指定适配 UGUI 界面渲染。其中UDeviceFactory的构造函数传入实参：`viewProvider` - 引用当前场景中的`CloudViewProvider`。
    var initResult = await ICloudSync.Instance.Init(appId, new UDeviceFactory(viewProvider));
    if (!initResult.IsSuccess)
    {
        Debug.LogError($"Init 初始化失败，无法启动云游戏 {initResult.Message}");
        return false;
    }
    return true;
}

// 添加事件监听
private void InitEvents()
{
    // 监听事件：玩家加入/离开
    ICloudSync.Instance.OnSeatPlayerJoined += OnPlayerJoined;
    ICloudSync.Instance.OnSeatPlayerLeaving += OnPlayerLeaving;
    
    MatchManager = ICloudSync.Instance.MatchManager;
    // 可选：监听事件：匹配到了其他用户
    MatchManager.OnMatchUsers += OnMatchUsers;
    // 监听事件：结束同玩了（返回单播）
    MatchManager.OnEndMatchEvent += OnEndMatchEvent;
}

/// 开始匹配
private async void StartMatch()
{
    MatchManager = ICloudSync.Instance.MatchManager;
    
    // 匹配配置，选择一个系统自带提供的匹配池
    var matchConfig = new SimpleMatchConfig()
    {
        PoolType = SimpleMatchPoolType.P1v1, // 2人 1v1
        MatchTag = "Demo-test-1.0" // 匹配标签，区分开用户
    };
    
    // 开始匹配，传入匹配配置。 成功后进入系统自动进入多人同玩状态。
    var task = MatchManager.RequestMatch(matchConfig); 
    var result = await task; // 等待结果    
    // todo: 处理结果：OnMatchResult(result);
}

public class SimpleMatchConfig
{
    /// 选择匹配池，对应一套匹配规则
    public SimpleMatchPoolType PoolType;

    /// 匹配标签，区分开用户。 建议用不同值区分开测试环境"test"、线上环境"online"，也可以用于分开不同版本"1.0","2.0"。 Example: 例如："test-1.0", "online-2.0"
    public string MatchTag;
}

public enum SimpleMatchPoolType
{
    /// 2人 1v1
    P1v1,
    /// 4人 2v2
    P2v2,
    /// 4人各自1队
    P1x4,
    /// 3人各自1队
    P1x3,
}

// 取消用的 CancellationTokenSource
private CancellationTokenSource _matchCancel;

/// 开始匹配
private async void StartMatch()
{
    // 设置本地游戏状态，可自定义表现，例如：显示“匹配中”文字、Loading转圈、按钮置灰等等...
    SetState(State.Matching);

    // 创建取消用的 CancellationTokenSource，using使其自动Dispose
    using CancellationTokenSource cancel = _matchCancel = new CancellationTokenSource();
    
    // 匹配配置，选择一个系统自带提供的匹配池
    var matchConfig = new SimpleMatchConfig()
    {
        PoolType = SimpleMatchPoolType.P1v1, // 2人 1v1
        MatchTag = "Demo-test-1.0" // 匹配标签，区分开用户
    };
    
    // 开始匹配，传入匹配配置，传入可取消用的cancel.Token。 成功后进入系统自动进入多人同玩状态。
    var task = MatchManager.RequestMatch(matchConfig, cancel.Token); 
    var result = await task; // 等待结果    
    _matchCancel = null; // 已出结果，不再需要取消，应把 TokenSource 引用置null    
    
    // 处理匹配结果：
    OnMatchResult(result);
}

/// 主动取消匹配
private void CancelMatch()
{
    if (_matchCancel != null)
    {
        // 主动取消。 若成功取消，`RequestMatch`返回结果的`IMatchResult.Code`会是`Cancelled`
        _matchCancel.Cancel();        
        // 取消后，应把 TokenSource 引用置null
        _matchCancel = null;
    }
}

// 监听事件
MatchManager.OnMatchUsers += OnMatchUsers;

private void OnMatchUsers(IMatchResult matchResult)
{
    var isHost = matchResult.IsHost;
    var myIndex = matchResult.MyIndex;
    var users = matchResult.AllUsers;
    var opponents = users.Where(s => s.RoomIndex != myIndex).ToList();
    var oppoNames = string.Join(", ", opponents.Select(s => s.Nickname).ToList());
    ShowHostNote($"匹配到了用户: {oppoNames}");
}

/// 处理匹配结果
private void OnMatchResult(IMatchResult result)
{
    _matchResult = result;
    // 处理失败情况
    if (!result.IsSuccess)
    {
        // 6.a 处理匹配失败
        OnMatchFail(result);
        return;
    }

    var isHost = result.IsHost;
    Debug.Log($"StartMatch 匹配成功 isHost: {isHost}");
    
    // 6.b 处理匹配成功
    OnMatchSuccess(isHost);
}

/// 6.a 处理匹配成功
private void OnMatchSuccess(bool isHost)
{
    var result = _matchResult;
    if (isHost)
    {
        // 匹配成功后，若我方是房主，应负责加载启动本局游戏（包括例如加载游戏资源、切换场景、显示界面UI等）。
        // 房主A 
        SetState(State.InGameHost);
        // 从result中，可以获取到匹配结果信息内容，例如：标识一场匹配的id`MatchId`，我的座位号`MyIndex`，房主用户`HostUser`；各个玩家用户的列表`AllUsers`，Team列表`Teams`
        var playersCount = result.AllUsers.Count;
        game.LoadGame(new GameInfo
        {
            isPk = true,
            playersCount = playersCount,
        });
    }
    else
    {
        // 若我方是要加入同玩的玩家，系统会切流加入到房主A的实例去同玩。 本地无需特殊处理，可以自定义显示，例如：显示“与...同玩中”、显示Loading。
        // 玩家B 
        SetState(State.InConnectOther);
    }
}

/// 6.b 处理匹配取消或失败
private void OnMatchFail(IMatchResult result)
{
    var debugMsg = $"code: {result.Code} ({(int)result.Code}), msg: {result.Message}";
    // 根据返回码：`result.Code`枚举判断
    switch (result.Code)
    {
        case MatchResultCode.Success:
            break;
        case MatchResultCode.Cancelled:
            Debug.Log($"StartMatch 取消 {debugMsg}");
            ShowHostNote("匹配已取消");
            break;
        case MatchResultCode.Timeout:
            Debug.LogWarning($"StartMatch 匹配超时 {debugMsg}");
            ShowHostNote("匹配超时，没有匹配到对手");
            break;
        case MatchResultCode.Error:
        default:
            Debug.LogError($"StartMatch 匹配失败 {debugMsg}");
            ShowHostNote($"匹配失败! {debugMsg}");
            break;
    }

    // 重置本地游戏状态、界面，并返回，允许后续操作。
    SetState(State.Ready);
}

// 监听事件：玩家加入/离开
ICloudSync.Instance.OnSeatPlayerJoined += OnPlayerJoined;
ICloudSync.Instance.OnSeatPlayerLeaving += OnPlayerLeaving;

// 匹配成功
private void OnMatchSuccess(bool isHost)
{
    if (isHost)
    {
        LoadGame(...);
    }
}

// 记录要参与本局的玩家座位列表
private List<ICloudSeat> _seats;

// 2.加载游戏
public void LoadGame(...)
{
    State = GameState.Loaded;
    
    // 记录要参与本局的玩家座位列表
    _seats = GetSeatsForGame(_gameInfo);
    
    // todo: 自定义实现：加载游戏资源、切换场景、显示界面UI等...
    
    // 检查确认
    CheckStartGame();
}

// 示例：按来自gameInfo的玩家数量，记录对应玩家座位列表
private List<ICloudSeat> GetSeatsForGame(GameInfo gameInfo)
{
    var userIndexes = new List<int> { 0 };
    if (gameInfo.isPk)
        userIndexes = Enumerable.Range(0, gameInfo.playersCount).ToList();
    var seatManager = ICloudSync.Instance.SeatManager;
    var seats = userIndexes.Select(u => seatManager.GetSeat((SeatIndex)u)).ToList();
    return seats;
}

// 3.检查确认开始游戏
private void CheckStartGame()
{
    if (State != GameState.Loaded)
        return;
    // 检查玩家加入到齐、确认OK后，开始正式一局游戏玩法。
    if (ArePlayersJoined(seats))
    {
        InitPlayerInfos(seats);
        // 开始正式一局游戏玩法
        StartGame();
    }
}

private bool ArePlayersJoined(List<ICloudSeat> seats)
{
    var ret = seats.All(s => s is { State: SeatState.InUse });
    Debug.Log($"Game ArePlayersJoined: {ret}");
    return ret;
}

// 4.a 收到事件：玩家加入
private void OnPlayerJoined(ICloudSeat seat)
{
    Debug.Log($"Game OnPlayerJoin seat index: {seat.Index}");
    if (State == GameState.Loaded)
        CheckStartGame();
}

/// 4.b 收到事件：玩家离开
private void OnPlayerLeaving(ICloudSeat seat)
{
    if (State != GameState.Started)
        return;
    if (!_gameInfo.isPk)
        return;
    CheckGameEnd();
}

private ICloudSeat _seat;

/// 显示结算
public void ShowGameResult(UserCloudView view, GameResult result)
{
    // 记录当前视图对象
    _view = view;
    // 记录是哪个用户座位
    _seat = view.Seat;
    // 记录本局游戏结果数据
    _result = result;
}

// 当点击【退出】
private async void OnClickExit()
{
    // 要传递的结束信息
    var resultJson = JsonUtility.ToJson(_result);
    // 结束同玩
    var result = await EndMatchGame(_seat.IsHost(), _seat.Index, resultJson);

    if (!result.IsSuccess)
    {
        // 结束同玩 result 失败
        OnEndMatchFail(result);
        return;
    }
    
    // 结束同玩 result 成功
    OnConfirmEnd();
}

// 区分是否房主，结束同玩
private async Task<IEndResult> EndMatchGame(bool isHost, SeatIndex seatIndex, string endInfo)
{
    Debug.Log($"GameResult EndMatchGame isHost: {isHost}, seatIndex: {seatIndex}");
    IEndResult result;
    if (isHost)
    {
        // 若是房主A点击【退出】，调用EndMatchGame 且不指定座位号，并传入结束信息
        // 逻辑其实是踢所有人，这时我们需要把结算结果透传给另一个主播
        // 让另一个主播在回到原实例后仍可继续看结算结果（收到OnEndMatchEvent事件）
        result = await ICloudSync.Instance.MatchManager.EndMatchGame(endInfo);
    }
    else
    {
        // 若是玩家B点击【退出】，调用EndMatchGame 且指定座位号 index1，并传入结束信息
        // [可选] endInfo 传入自定义结束信息，因为他是自己主动退了， 他已经看到了结算信息，所以可按需要自定义透传什么结束信息。
        result = await ICloudSync.Instance.MatchManager.EndMatchGame(seatIndex, endInfo);
    }
    return result;
}

// 示例：结束同玩失败时，做相关提示
private void OnEndMatchFail(IEndResult result)
{
    var debugMsg = $"code: {result.Code} ({(int)result.Code}), msg: {result.Message}";
    // 根据返回码：`result.Code`枚举判断
    switch (result.Code)
    {
        case EndResultCode.Success:
            break;
        case EndResultCode.Timeout:
            Debug.LogWarning($"EndMatchGame 结束同玩超时 {debugMsg}");
            ShowNote("结束同玩超时");
            break;
        case EndResultCode.Error:
        default:
            Debug.LogError($"EndMatchGame 结束同玩失败 {debugMsg}");
            ShowNote($"结束同玩失败! {debugMsg}");
            break;
    }
}

// 监听事件
MatchManager.OnEndMatchEvent += OnEndMatchEvent;

// 收到事件：结束同玩了（返回单播）
private void OnEndMatchEvent(IEndEvent endEvent)
{
    var endType = endEvent.EndType;
    var info = endEvent.EndInfo;
    Debug.Log($"OnEndMatchEvent, endType: {endType}, has info: {endEvent.HasEndInfo()}");

    // 重置本地游戏状态、界面，允许后续操作。
    ViewA.Clean();
    SetState(State.Ready);

    switch (endType)
    {
        case EndEventType.EndMatchGame:
            // 玩家B回流到自己实例
            ShowHostNote("回流了");
            try
            {
                // 回流的玩家，收到结算信息
                var gameResult = JsonUtility.FromJson<GameResult>(info);
                if (gameResult != null)
                    ViewA.ShowGameResult(gameResult, false);
            }
            catch (Exception)
            {
                ShowHostAlert("endInfo", info);
            }

            break;
        case EndEventType.EndHostState:
            // 房主自己结束同玩了
            ShowHostNote("结束同玩了");
            break;
        case EndEventType.ExitForJoinError:
        case EndEventType.ExitForGameExpired:
        default:
            ShowHostNote($"退出同玩了 ({endType})");
            break;
    }
}

private void OnPlayerLeaving(ICloudSeat seat)
{
    var playerText = seat.IsHost() ? "主播" : $"玩家{seat.IntIndex + 1}";
    ViewA.ShowNote($"{playerText}： {seat.PlayerInfo?.NickName} 离开了游戏");
    
    if (State != GameState.Started)
        return;
        
    CheckGameEnd();
}

private void CheckGameEnd()
{
    if (State != GameState.Started)
        return;

    if (AreOtherSeatsDisconnected())
    {
        // 其他玩家都已退出同玩。房主侧不强制退出，开发者可以在做好合适的展示后，自己调用`结束同玩`接口
        Debug.Log("其他玩家都已退出同玩");
        EndGame();
        return;
    }

    if (_liveBlockCount == 0)
    {
        Debug.Log("游戏关卡完成");
        EndGame();
    }
}

// 监听事件
ICloudSync.Instance.OnWillDestroy += OnWillDestroy;

// 事件回调：当Host主机关闭玩法、云游戏实例即将销毁，可以将非 Host 的玩家用户踢回去
public void OnWillDestroy(DestroyInfo destroyInfo)
{
    // 如果不在云同步游戏，表示主播自己在关闭玩法，无需处理
    if (!InMatchGame)
        return;
    // 以下内容，开发者可以自定义实现，`endInfo`可替换为传递自定义需要的信息
    var reason = destroyInfo.Reason;
    var gameInfo = Game.Instance.GameInfo;
    var result = new GameResult
    {
        gameInfo = gameInfo,
        endNotice = "房主已退出（或关闭了玩法）",
        players = gameInfo.players
    };
    Debug.Log($"OnWillDestroy reason: {reason}, endNotice: {result.endNotice}");
    var resultJson = JsonUtility.ToJson(result);
    // 单个用户结束同玩：使他退出、回到单播状态
    EndMatchGame(resultJson);
}