local CustomRoom_Model = {}
local EventSystem = require('Event/EventSystem')
local custom_room_opt_pb = require("Proto.custom_room_opt_pb")
local private = {}

local INVITE_AUTO_CANCEL_TIME = DataSheetManager.ConstData:GetDataByID("PK_Invite_Expiration").IntValue
local TeamListMax = DataSheetManager.ConstData:GetDataByID("TeamListMax").IntValue

local CUSTOMROOM_FORMATION_KEY = "CustomroomFormationKey"

CustomRoom_Model.RoomState = {
    Waiting = 0,
    InBattle = 1,
}

CustomRoom_Model.MemberState = {
    Waiting = 0,
    Ready = 1,
}

CustomRoom_Model.SettingOptType = {
    ChangeRoomName = 1,
    ChangeRoomAccessDan = 2,
    ChangeRoomShowInHall = 3,
    ChangeRoomPassword = 4,
}

CustomRoom_Model.MemberEnterType_Fighter = 0
CustomRoom_Model.MemberEnterType_Watcher = 1

function CustomRoom_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CChangeCustomRoomInfo, private.G2CChangeCustomRoomInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CMemberOptEXPosition, private.G2CMemberOptEXPosition)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CCustomRoomInfo, private.G2CCustomRoomInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CCustomRoomInvite, private.G2CCustomRoomInvite)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushEXPosition, private.G2CPushEXPosition)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CMemberChangeState, private.G2CMemberChangeState)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CRefusesEXPosition, private.G2CRefusesEXPosition)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CBeKickedOutCustomRoom, private.G2CBeKickedOutCustomRoom)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CEXPositionInterrupted, private.G2CEXPositionInterrupted)

    NetManager.RegisterMsgCB(MessageEnums.MessageCreateCustomRoom, private.CreateCustomRoomResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageQueryCustomRoom, private.QueryCustomRoomResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageEnterCustomRoom, private.EnterCustomRoomResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageKickOutMember, private.KickOutMemberResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageLeaveCustomRoom, private.LeaveCustomRoomResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageChangeCustomRoomInfo, private.ChangeCustomRoomInfoResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageMemberEXPosition, private.MemberEXPositionResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageMemberOptEXPosition, private.MemberOptEXPositionResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageCustomRoomInvite, private.CustomRoomInviteResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageRefuseCustomRoomInvite, private.RefuseCustomRoomInviteResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageMemberChangeState, private.MemberChangeStateResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageCustomRoomEnterBattle, private.CustomRoomEnterBattleResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageChangeLineup, private.ChangeLineupResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CCustomRoomDissolve, private.G2CCustomRoomDissolve)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CCustomHeroInfo, private.OnG2CCustomHeroInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushCustom1V1BattleResult, private.OnG2CPushCustom1V1BattleResult)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushCustom3V3BattleResult, private.OnG2CPushCustom3V3BattleResult)
    NetManager.RegisterMsgCB(MessageEnums.MessageCustomRoomAddRobot, nil)

    EventSystem.Regist(EventID.FunctionUnlockUpdate, private.RefreshByGMS)
    EventSystem.Regist(EventID.UI_FairPlay_SyncSoloSeasonInfoUpdate, CustomRoom_Model.CancelMemberReadyState)
    
    -- 交换时间的CD时间戳
    CustomRoom_Model.AbleExchangeTimestamp = UTL.Time.GetServerTimestamp()
    private.curActivityID = 0
    -- 上一次成功请求的缓存cache
    private.QueryParamCache = nil
    -- 上一次成功请求的结果缓存
    private.QueryResultCache = nil
    -- 房间内的设置缓存
    private.InRoomSetting = nil
    -- 进入房间操作锁
    private.enterRoomLock = nil

    -- {RoomInfo = {BriefInfo, SupplementInfo, MemberInfos}, MemberInfoDic = {[0] = CustomRoomMemberInfo}}
    -- {RoomInfo = {}, MemberInfoDic = {}}
    -- 房间的全量信息
    private.InRoomInfoCache = nil
    -- 交换位置队列
    CustomRoom_Model.InteractingQueue = {} -- {{roomID = 1, reqACID = 1, ACID = 1, timeStamp = 0}, {}}
    -- 待忽略邀请请求操作缓存队列
    private.RemoveInviteMsgCacheQueue = {}
    
    -- 初次进入场景
    private.firstInitScene = true
end

function CustomRoom_Model.SetRoomInfo(array)
    if IsProtoDataNotNil(array) then
        local curRoomId = CustomRoom_Model.GetCurRoomId()
        if curRoomId then
            local curActivityID = CustomRoom_Model.GetCurRoomActivityId()
            local activityID = array[1]
            local roomId = array[2]
            if curRoomId ~= roomId or activityID ~= curActivityID then
                --缓存的房间数据与服务器不一致，需要清理掉
                private.ClearRoomInfo()
            end
        end
    end
    if CustomRoom_Model.GetIsWatcher() then
        CustomRoom_Model.ManualLeaveRoom()
    end
end

--主动离开房间
function CustomRoom_Model.ManualLeaveRoom()
    if private.InRoomInfoCache then
        local roomData = private.InRoomInfoCache.RoomInfo
        CustomRoom_Model.LeaveCustomRoomReq(roomData.BriefInfo.ActivityID, roomData.BriefInfo.RoomID)
    end
end

function CustomRoom_Model.IsInRoom()
    return private.InRoomInfoCache ~= nil
end

function CustomRoom_Model.SetCurRoomActivity(activityID)
    private.curActivityID = activityID
end

function CustomRoom_Model.RemoveFirstSceneInitFlag()
    private.firstInitScene = false
end

function CustomRoom_Model.GetFirstSceneInitFlag()
    return private.firstInitScene
end

function CustomRoom_Model.SetEnterRoomLock()
    private.enterRoomLock = true
    TimerUtil.Interval(private.ReleaseEnterRoomLock, 0.7, 1)
end

function private.ReleaseEnterRoomLock()
    private.enterRoomLock = nil
end

-- 是否在进入房间的操作中
function CustomRoom_Model.IsEnteringRoom()
    return private.enterRoomLock == true
end

-- 无缓存成功查询参数时使用默认的
function CustomRoom_Model.GetDefaultQueryParam()
    return CustomRoom_Model.CreateParam(private.curActivityID, nil, nil, 1)
end

-- 上次成功的缓存参数
function CustomRoom_Model.GetQueryParamCache()
    return private.QueryParamCache or CustomRoom_Model.GetDefaultQueryParam()
end

function CustomRoom_Model.GetRoomData()
    return private.InRoomInfoCache.RoomInfo
end

function CustomRoom_Model.GetRoomPWD()
    if private.InRoomInfoCache then
        if private.InRoomInfoCache.RoomInfo.SupplementInfo.Password == -1 then
            return nil
        else
            return private.InRoomInfoCache.RoomInfo.SupplementInfo.Password
        end
    end
end

function CustomRoom_Model.IsRoomOwner(acid)
    local compareACID = acid or BattleDataGetter.GetAcID()
    if private.InRoomInfoCache then
        return private.InRoomInfoCache.RoomInfo.SupplementInfo.HouseOwnerACID == compareACID
    end
    return false
end

function CustomRoom_Model.GetCurRoomName()
    if private.InRoomInfoCache then
        return private.InRoomInfoCache.RoomInfo.BriefInfo.RoomName
    end
end

function CustomRoom_Model.GetCurRoomWatchBattleId()
    if private.InRoomInfoCache then
        return private.InRoomInfoCache.RoomInfo.BriefInfo.groomId
    end
    return nil
end

function CustomRoom_Model.ClearCurRoomWatchBattleId()
    if private.InRoomInfoCache then
        private.InRoomInfoCache.RoomInfo.BriefInfo.groomId = ""
    end
end

function CustomRoom_Model.GetIsReadyEnterWatch()
    if private.InRoomInfoCache then
        local curState = CustomRoom_Model.GetCurRoomState()
        if curState == CustomRoom_Model.RoomState.InBattle then
            local groomId = CustomRoom_Model.GetCurRoomWatchBattleId()
            if not string.isNilOrEmpty(groomId) then
                return private.InRoomInfoCache.RoomInfo.BriefInfo.isChoosingHero == false
            end
        end
    end
    return false
end

function CustomRoom_Model.GetCurRoomIsChoosingHero()
    if private.InRoomInfoCache then
        local briefInfo = private.InRoomInfoCache.RoomInfo.BriefInfo
        return briefInfo.isChoosingHero
    end
    return false
end

function CustomRoom_Model.GetCurRoomId()
    if private.InRoomInfoCache then
        local briefInfo = private.InRoomInfoCache.RoomInfo.BriefInfo
        return briefInfo.RoomID
    end
    return nil
end

function CustomRoom_Model.GetCurRoomActivityId()
    if private.InRoomInfoCache then
        local briefInfo = private.InRoomInfoCache.RoomInfo.BriefInfo
        return briefInfo.ActivityID
    end
    return nil
end

function CustomRoom_Model.GetCurRoomState()
    if private.InRoomInfoCache then
        local briefInfo = private.InRoomInfoCache.RoomInfo.BriefInfo
        return briefInfo.CurState
    end
    return nil
end

function CustomRoom_Model.GetInRoomMemberDic()
    return private.InRoomInfoCache.MemberInfoDic
end

function CustomRoom_Model.GetInRoomSetting()
    return private.InRoomSetting
end

function CustomRoom_Model.GetMyStateInfo()
    local myData = CustomRoom_Model.GetMemberDataByACID()
    if myData then
        local isReady = myData.SupplementInfo.CurState == MDL.CustomRoom.MemberState.Ready and true or false
        local isOnline = myData.SupplementInfo.Online
        local pos = myData.SupplementInfo.Position + 1
        return pos, isReady, isOnline
    end
end

function CustomRoom_Model.IsInExchangeCD()
    return UTL.Time.GetServerTimestamp() <= CustomRoom_Model.AbleExchangeTimestamp
end

function CustomRoom_Model.GetMemberDataByACID(ACID)
    local acid = ACID or BattleDataGetter.GetAcID()
    for i, v in pairs(private.InRoomInfoCache.MemberInfoDic) do
        if v.BriefInfo.ACID == acid then
            return v
        end
    end
    return nil
end

--- 根据roomID 返回上次查询的房间列表的指定房间信息
---@return isSuccess boolean 是否存在此房间
---@return RoomShowInfo table 房间信息结构
function CustomRoom_Model.GetRoomInfoInCacheByRoomID(roomID)
    if not private.QueryResultCache then
        return false, nil
    end

    for i, v in ipairs(private.QueryResultCache.PageInfo.RoomBriefInfos) do
        if roomID == v.BriefInfo.RoomID then
            return true, v
        end
    end
    return false, nil
end

function CustomRoom_Model.IsRoomExit(roomID)
    local roomID = tonumber(roomID)
    if not private.QueryResultCache then
        -- 没有任何查询缓存
        return false
    end

    for i, v in ipairs(private.QueryResultCache.PageInfo.RoomBriefInfos) do
        if roomID == v.BriefInfo.RoomID then
            return true
        end
    end
    return false
end

function CustomRoom_Model.IsAllPlayerReady()
    for k, v in pairs(private.InRoomInfoCache.MemberInfoDic) do
        if not CustomRoom_Model.IsRoomOwner(v.BriefInfo.ACID) and v.SupplementInfo.CurState == MDL.CustomRoom.MemberState.Waiting then
            return false
        end
    end
    return true
end

--- 将RoomInfo结构进行整合, 全量更新时使用
---@param RoomInfo table 原始房间信息msg
function private.UpdateCustomInRoomDataCache(roomInfo)
    if not private.InRoomInfoCache then
        private.InRoomInfoCache = { RoomInfo = {}, MemberInfoDic = {} }
    end
    private.InRoomInfoCache.RoomInfo = roomInfo
    private.SetRoomSettingInfo(
            roomInfo.BriefInfo.ActivityID,
            roomInfo.BriefInfo.RoomID,
            roomInfo.BriefInfo.RoomName,
            roomInfo.BriefInfo.AccessDan,
            roomInfo.BriefInfo.RequirePassword,
            roomInfo.SupplementInfo.Password,
            false
    )
    if roomInfo.MemberInfos and #roomInfo.MemberInfos > 0 then
        private.InRoomInfoCache.MemberInfoDic = private.CreateInRoomMemberDic(roomInfo.MemberInfos, private.InRoomInfoCache.ActivityID)
    end
end

function private.SetRoomSettingInfo(activityID, roomID, roomName, accessDan, requirePWD, pwd, isChangeSetting)
    if not private.InRoomSetting then
        private.InRoomSetting = {}
    end

    if activityID ~= nil then
        private.InRoomSetting.ActivityID = activityID
    end

    if roomID ~= nil then
        private.InRoomSetting.RoomID = roomID
    end

    local oldName = private.InRoomSetting.RoomName
    if roomName ~= nil and oldName ~= roomName then
        private.InRoomSetting.RoomName = roomName
        private.InRoomInfoCache.RoomInfo.BriefInfo.RoomName = roomName
        if isChangeSetting then
            EventSystem.Dispatch(EventID.UI_OnUpdateChangeRoomName, true)
        end
    end

    local oldAccessDan = private.InRoomSetting.AccessDan
    if accessDan ~= nil and oldAccessDan ~= accessDan then
        private.InRoomSetting.AccessDan = accessDan
        private.InRoomInfoCache.RoomInfo.BriefInfo.AccessDan = accessDan
        if isChangeSetting then
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Room_Tips_3"])
        end
    end
    
    local oldRequirePWD = private.InRoomSetting.RequirePassword
    if requirePWD ~= nil and oldRequirePWD ~= requirePWD then
        private.InRoomSetting.RequirePassword = requirePWD
        private.InRoomInfoCache.RoomInfo.BriefInfo.RequirePassword = requirePWD
    end

    local oldPWD = private.InRoomSetting.Password
    if pwd ~= nil and oldPWD ~= pwd then
        private.InRoomSetting.Password = pwd
        private.InRoomInfoCache.RoomInfo.SupplementInfo.Password = pwd
        if isChangeSetting then
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Room_Tips_6"])
        end
    end
end

function private.CreateInRoomMemberDic(memberList, activityType)
    local memberDic = {}
    for _, memberInfo in ipairs(memberList) do
        local curPos = memberInfo.SupplementInfo.Position
        memberDic[curPos] = memberInfo
    end
    return memberDic
end

--- 成员换位更新位置(1个人换位置，2个人换位置)
---@param updatedMemberList array 变化的成员位置
function private.UpdateCustomInRoomMemberInfosDataCache(updatedMemberList)
    local memberInfoDicCache = private.InRoomInfoCache.MemberInfoDic
    if #updatedMemberList == 1 then
        local acid = updatedMemberList[1].BriefInfo.ACID
        local oldInfo = CustomRoom_Model.GetMemberDataByACID(acid)
        local oldIndex = oldInfo.SupplementInfo.Position
        local newIndex = updatedMemberList[1].SupplementInfo.Position
        memberInfoDicCache[newIndex] = updatedMemberList[1]
        memberInfoDicCache[oldIndex] = nil
    elseif #updatedMemberList > 1 then
        for _, v in ipairs(updatedMemberList) do
            local pos = v.SupplementInfo.Position
            memberInfoDicCache[pos] = v
        end
    end
end

-- 请求下一页
function CustomRoom_Model.QueryNextPage()
    local lastParam = CustomRoom_Model.GetQueryParamCache()
    lastParam.TargetPage = lastParam.TargetPage + 1
    MDL.CustomRoom.QueryCustomRoomReq(lastParam)
end

-- 请求上一页
function CustomRoom_Model.QueryPreviousPage()
    local lastParam = CustomRoom_Model.GetQueryParamCache()
    lastParam.TargetPage = lastParam.TargetPage - 1
    MDL.CustomRoom.QueryCustomRoomReq(lastParam)
end

function CustomRoom_Model.SaveSoloPKFormation(heroList)
    if heroList then
        PersistentData.PlayerData:Set(CUSTOMROOM_FORMATION_KEY, heroList, true)
    end
end

function CustomRoom_Model.LoadSoloPKFormation()
    local isDirty = false
    local heroList = {} -- 当前阵容
    local HeroDic = {} -- 可选的武将字典
    local cacheLineUP = PersistentData.PlayerData:Get(CUSTOMROOM_FORMATION_KEY)
    if cacheLineUP then
        for i, v in ipairs(cacheLineUP) do
            table.insert(heroList, v)
        end
    else
        for i, v in ipairs(MDL.Player.GetHeroLinUpIds()) do
            table.insert(heroList, v)
        end
    end
    
    -- 限免武将
    for _, v in ipairs(MDL.SyncSolo.GetSyncSoloSeasonInfo().freeHeroes) do --将武将的道具ID转换成武将ID
        local itemData = DataSheetManager.ItemData:GetDataByID(v)
        HeroDic[itemData.BelongToHero] = true
    end

    -- 自己的武将以及体验卡武将
    local soloheroList = MDL.Replay.GetSortedAvailableSelectHeroList(MDL.Replay.FairPlayType.Solo, false)
    for _, v in ipairs(soloheroList) do
        HeroDic[v.heroId] = true
    end
    
    for index, heroID in ipairs(heroList) do
        local id, isAwaken = CTL.HeroAwaken.DecodeHeroId(heroID)
        if (heroID > 0 and not HeroDic[id]) or (isAwaken and MDL.HeroAwaken.GetIsHeroAwaken(id) == false) then
            heroList[index] = -1
            isDirty = true
        end
    end
    
    if isDirty then
        PersistentData.PlayerData:Set(CUSTOMROOM_FORMATION_KEY, heroList, true)
    end
    return heroList
end

function private.GetHeroListFormationCount(heroList)
    local len = 0
    for i, v in ipairs(heroList) do
        if v > 0 then
            len = len + 1
        end
    end
    return len
end

function private.GetSyncSoloPKModeSuccess(msgHeroList)
    local heroList = CustomRoom_Model.LoadSoloPKFormation()
    local len = private.GetHeroListFormationCount(heroList)
    if len < 6 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_LineupNotToReady"])
        return false, false
    end

    for i, v in ipairs(heroList) do
        local heroInfo = NetManager.GetPB("battle_match_pb").MatchHeroInfo()
        local id, res = CTL.HeroAwaken.DecodeHeroId(v)
        if res then
            heroInfo.isAwaken = true
            heroInfo.heroId = id
        else
            heroInfo.isAwaken = false
            heroInfo.heroId = v
        end
        table.insert(msgHeroList, heroInfo)
    end

    return true, true
end

-- 移除队列中的房间请求
function private.RemoveInvitedListByActivityIDAndRoomID(activityID, roomID)
    local index
    local list = MDL.Team.GetInviteList()
    for i, v in ipairs(list) do
        if v.type == MDL.Team.InvitedType.Room and v.info.BriefInfo.ActivityID == activityID and v.info.BriefInfo.RoomID == roomID then
            index = i
            break
        end
    end
    if index then
        table.remove(list, index)
    end
end

function CustomRoom_Model.GetInviteListIndexByActivityIDAndRoomID(activityID, roomID)
    for i, v in ipairs(MDL.Team.GetInviteList()) do
        if v.type == MDL.Team.InvitedType.Room and v.info.BriefInfo.ActivityID == activityID and v.info.BriefInfo.RoomID == roomID then
            return i - 1
        end
    end
end

function CustomRoom_Model.RemoveInvitedInfo(activityID, roomID)
    CTL.Team.OperateTeamInvitedPanel(false,
            {
                type = MDL.Team.InvitedType.Room,
                ActivityID = activityID,
                RoomID = roomID
            }
    )
    private.RemoveInvitedListByActivityIDAndRoomID(activityID, roomID)
end

function private.RefreshByGMS(funcID, isUnlock)
    if funcID == MDL.Unlock.FunctionType.SyncSoloPK or funcID == MDL.Unlock.FunctionType.SyncTVTPK then
        local tabs = CTL.CustomRoom.GetPKRoomListLeftTab()
        if #tabs <= 0 then
            CTL.CustomRoom.CloseRoomRelateView()
            UIManager.CloseView(Const_UI_Lua.UIEnum.UIPKRoomList)
        end
    end
end
--region ============================ 网络协议 ======================================
--- G->C
---

--- 修改房间信息(Push,除房主外推送)
function private.G2CChangeCustomRoomInfo(msg)
    private.SetRoomSettingInfo(
            nil,
            nil,
            msg.ParamInfo.RoomName,
            msg.ParamInfo.AccessDan,
            msg.ParamInfo.RequirePassword,
            msg.ParamInfo.Password
    )
    EventSystem.Dispatch(EventID.UI_UpdateRoomSettingInfo)
end

--- 房间全量信息（Push，成员进出、成员踢出、房主变化时，会向所有房间成员推送全量信息）
function private.G2CCustomRoomInfo(msg)
    -- 更新缓存
    private.UpdateCustomInRoomDataCache(msg.RoomInfo)
    EventSystem.Dispatch(EventID.UI_UpdateRoomInfo)
end

---自定义房间被邀请(Push)
function private.G2CCustomRoomInvite(msg)
    local invitedList = MDL.Team.GetInviteList()
    if #invitedList >= TeamListMax then
        return
    end

    local invitedInfo = { type = MDL.Team.InvitedType.Room, info = msg.RoomShowInfo }
    table.insert(invitedList, invitedInfo)
    CTL.Team.OperateTeamInvitedPanel(true, invitedInfo)
end

---被请求交换位置（Push）
function private.G2CPushEXPosition(msg)
    if msg.RoomID == private.InRoomInfoCache.RoomInfo.BriefInfo.RoomID then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIPKChangeConfirmPanel, msg)
    end
end

-- 有两人成功交换位置
function private.G2CMemberOptEXPosition(msg)
    local roomID = private.InRoomInfoCache.RoomInfo.BriefInfo.RoomID
    local activityID = private.InRoomInfoCache.RoomInfo.BriefInfo.ActivityID
    if msg.RoomID == roomID and msg.ActivityID == activityID then
        private.UpdateCustomInRoomMemberInfosDataCache(msg.UpdateMemberInfo)
        EventSystem.Dispatch(EventID.UI_UpdateMemberState)
        for i, v in ipairs(msg.UpdateMemberInfo) do
            -- 交换的两个人中有自己
            if v.BriefInfo.ACID == BattleDataGetter.GetAcID() then
                table.remove(CustomRoom_Model.InteractingQueue)
            end
        end
    end
end

--- 对方拒绝交换位置（push）
function private.G2CRefusesEXPosition(msg)
    table.remove(CustomRoom_Model.InteractingQueue)
    EventSystem.Dispatch(EventID.UI_UpdateMemberState)
end

---成员切换自身状态（Push，除操作者外推送）
function private.G2CMemberChangeState(msg)
    local memberInfo = CustomRoom_Model.GetMemberDataByACID(msg.ChangeACID)
    memberInfo.SupplementInfo.CurState = msg.Ready == true and CustomRoom_Model.MemberState.Ready or CustomRoom_Model.MemberState.Waiting
    EventSystem.Dispatch(EventID.UI_UpdateMemberState)
end

--- 被踢出自定义房间
function private.G2CBeKickedOutCustomRoom(msg)
    private.OnLeaveRoom(false, msg.ActivityID, msg.RoomID)
    if msg.IsRealBeKicked then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Room_Tips_15"])
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Quit"])
    end
end

--- 交换的状态被打断(push 只推被打断的一方)
function private.G2CEXPositionInterrupted(msg)
    table.remove(CustomRoom_Model.InteractingQueue)
    EventSystem.Dispatch(EventID.UI_UpdateMemberState)
end

--region ============================ Req -> Resp ======================================

---创建自定义房间
---@param activityID int 活动ID
---@param roomName string 房间名称
---@param accessDan int 准入段位
---@param isPublic boolean 是否空开显示
---@param pwd int 密码
---@param heroList [int]Array 出阵阵容[OPTION]
function CustomRoom_Model.CreateCustomRoomReq(activityID, roomName, accessDan, pwd, canBeWatch)
    local msg = custom_room_opt_pb.CreateCustomRoomReq()
    msg.ActivityID = activityID or 0
    msg.RoomName = roomName or ""
    msg.AccessDan = accessDan or 0
    msg.PublicDisplay = true

    local intPWD = tonumber(pwd)
    msg.Password = intPWD or -1
    msg.CanBeWatch = canBeWatch
    NetManager.SendMessage(MessageEnums.MessageCreateCustomRoom, msg)
end

function private.NotifySoloFormation()
    local curActivityID = CustomRoom_Model.GetCurRoomActivityId()
    if curActivityID == LuaConst.ActivityType.SyncSoloPK then
        local heroList = CustomRoom_Model.LoadSoloPKFormation()
        local len = private.GetHeroListFormationCount(heroList)
        if len >= 6 then
            MDL.CustomRoom.ChangeLineupReq(curActivityID)
        end
    end
end

function private.CreateCustomRoomResp(msg)
    if msg.Resp.Code == 0 then
        private.SetEnterType(CustomRoom_Model.MemberEnterType_Fighter)
        NotSyncBattleSetter.StopAutoFightPathInTown() --停止现在的寻路
        private.UpdateCustomInRoomDataCache(msg.RoomInfo)
        UIManager.CloseView(Const_UI_Lua.UIEnum.UIPKCreatePanel)
        UIManager.OpenAndPushAll(Const_UI_Lua.UIEnum.UIPKRoomBase)
        private.NotifySoloFormation()
    else
        EventSystem.Dispatch(EventID.UI_PK_FailClearInfo)
    end
end

function CustomRoom_Model.CreateParam(activityID, accessDan, roomID, targetPage)
    local param = {}
    param.ActivityID = activityID
    param.AccessDan = accessDan
    param.TargetPage = targetPage
    param.RoomID = roomID
    return param
end

function private.SetParam(msgParam, myParam)
    msgParam.ActivityID = myParam.ActivityID or 0
    msgParam.AccessDan = myParam.AccessDan or 0
    msgParam.TargetPage = myParam.TargetPage or 1
    msgParam.RoomID = myParam.RoomID or 0
end

--- 查询自定义房间(Req)
--- 任何参数不填直接请求上次缓存的参数
---@param activityID int 活动ID
function CustomRoom_Model.QueryCustomRoomReq(param)
    local msg = custom_room_opt_pb.QueryCustomRoomReq()
    if param and param.ActivityID then
        private.SetParam(msg.Param, param)
    else
        private.SetParam(msg.Param, CustomRoom_Model.GetQueryParamCache())
    end
    NetManager.SendMessage(MessageEnums.MessageQueryCustomRoom, msg)
end

--- 1. 精准房间查询 ：No不会缓存查询参数，Yes会缓存查询结果；无结果不会刷新界面, 有结果刷新界面。
---    进入房间的定向查询  不刷新界面
--- 2. 筛选查询 ： 缓存查询结果和参数，刷新界面
function private.QueryCustomRoomResp(msg)
    if msg.Resp.Code == 0 then
        if msg.Param.RoomID and msg.Param.RoomID > 0 then
            private.QueryResultCache = msg
            if msg.PageInfo.TotalPage <= 0 then
                -- 精准查询无结果
                return
            end

            if not MDL.CustomRoom.IsEnteringRoom() then
                -- 非进入房间前的定向查询需要刷新查询大厅
                EventSystem.Dispatch(EventID.UI_UpdateCustomRoomQuery, msg.PageInfo.CurPage, msg.PageInfo.TotalPage, msg.PageInfo.RoomBriefInfos)
            end
        else
            private.QueryResultCache = msg
            private.QueryParamCache = msg.Param
            local result = {}
            for i, v in ipairs(msg.PageInfo.RoomBriefInfos) do
                table.insert(result, v)
            end
            EventSystem.Dispatch(EventID.UI_UpdateCustomRoomQuery, msg.PageInfo.CurPage, msg.PageInfo.TotalPage, msg.PageInfo.RoomBriefInfos)
        end
    end
end

--- 进入自定义房间，或接受邀请
function CustomRoom_Model.EnterCustomRoomReq(isInvite, activityID, roomID, pwd, enterType)
    local msg = custom_room_opt_pb.EnterCustomRoomReq()
    msg.ActivityID = activityID
    msg.RoomID = roomID
    msg.Password = tonumber(pwd) or 0
    msg.InvitePositionEnter = isInvite
    local myParam = CustomRoom_Model.CreateParam(activityID, nil, roomID)
    private.SetParam(msg.Param, myParam)
    msg.enterType = enterType or CustomRoom_Model.MemberEnterType_Fighter
    NetManager.SendMessage(MessageEnums.MessageEnterCustomRoom, msg)
end

function private.EnterCustomRoomResp(msg)
    if msg.Resp.Code == 0 then
        CTL.Level.TryBreakConveyProgress()
        NotSyncBattleSetter.StopAutoFightPathInTown() --停止现在的寻路
        private.SetEnterType(msg.enterType)
        if msg.InvitePositionEnter then
            -- 移除邀请队列中的请求
            CustomRoom_Model.RemoveInvitedInfo(msg.RoomInfo.BriefInfo.ActivityID, msg.RoomInfo.BriefInfo.RoomID)
        end
        private.UpdateCustomInRoomDataCache(msg.RoomInfo)
        CTL.CustomRoom.TryOpenRoomPanel()
        if CustomRoom_Model.GetIsWatcher() == false then
            private.NotifySoloFormation()
        end
    else
        -- 未成功进入
        if msg.Resp.Code ~= 1909 then
            -- 密码正确或者无需密码
            if msg.InvitePositionEnter then
                EventSystem.Dispatch(EventID.UI_UpdateCustomRoomQuery, msg.PageInfo.CurPage, msg.PageInfo.TotalPage, msg.PageInfo.RoomBriefInfos)
            end
            UIManager.CloseView(Const_UI_Lua.UIEnum.UIPKAddInPanel)
            CustomRoom_Model.QueryCustomRoomReq()
        end
    end
end

--- 踢出房间内成员
function CustomRoom_Model.KickOutMemberReq(targetACID)
    local msg = custom_room_opt_pb.KickOutMemberReq()
    msg.TargetACID = targetACID
    NetManager.SendMessage(MessageEnums.MessageKickOutMember, msg)
end

function private.KickOutMemberResp(msg)
    private.UpdateCustomInRoomDataCache(msg.RoomInfo)
    EventSystem.Dispatch(EventID.UI_UpdateRoomInfo)
end

--- 自己离开房间
function CustomRoom_Model.LeaveCustomRoomReq(activityID, roomID)
    local msg = custom_room_opt_pb.LeaveCustomRoomReq()
    msg.ActivityID = activityID
    msg.RoomID = roomID
    NetManager.SendMessage(MessageEnums.MessageLeaveCustomRoom, msg)
end

function private.LeaveCustomRoomResp(msg)
    if msg.Resp.Code == 0 then
        private.OnLeaveRoom(false, msg.ActivityID, msg.RoomID)
    elseif msg.Resp.Code == 1904 then
        private.OnLeaveRoom(true)
    end
end

function private.OnLeaveRoom(isHardLeave, activityID, roomID)
    private.SetEnterType(nil)
    -- 清空当前房间缓存信息
    if private.InRoomInfoCache == nil then
        return
    end
    local roomData = private.InRoomInfoCache.RoomInfo.BriefInfo
    if isHardLeave or (roomData.RoomID == roomID and roomData.ActivityID == activityID) then
        private.ClearRoomInfo()
    end
end

function private.ClearRoomInfo()
    -- 退出房间清空交换信息
    CustomRoom_Model.AbleExchangeTimestamp = UTL.Time.GetServerTimestamp()
    table.clearArray(CustomRoom_Model.InteractingQueue)
    CTL.CustomRoom.LeavePKRoomChatChannel()
    CTL.CustomRoom.CloseRoomRelateView()
    private.InRoomInfoCache = nil
    private.InRoomSetting = nil
    private.SetEnterType(nil)
end

-- 房间解散
function private.G2CCustomRoomDissolve()
    CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_DisRoom"])
    private.OnLeaveRoom(true)
end

function private.OnG2CCustomHeroInfo(msg)
    if CustomRoom_Model.GetIsWatcher() == false then
        return
    end
    local curActivityID = CustomRoom_Model.GetCurRoomActivityId()
    local curRoomId = CustomRoom_Model.GetCurRoomId()
    if curRoomId == msg.RoomID and curActivityID == msg.ActivityID then
        if not string.isNilOrEmpty(msg.targetAcid) then
            --更新成员选将信息
            local memberDic = CustomRoom_Model.GetInRoomMemberDic()
            for _, memberInfo in pairs(memberDic) do
                if memberInfo.BriefInfo.ACID == msg.targetAcid then
                    table.clearArray(memberInfo.SupplementInfo.heroList)
                    for i, v in ipairs(msg.heroList) do
                        table.insert(memberInfo.SupplementInfo.heroList,  v)
                    end
                    table.clearArray(memberInfo.SupplementInfo.awakenList)
                    for i, v in ipairs(msg.awakenList) do
                        table.insert(memberInfo.SupplementInfo.awakenList,  v)
                    end
                    break
                end
            end
        end
        private.InRoomInfoCache.RoomInfo.BriefInfo.isChoosingHero = msg.isChoosingHero
        if not string.isNilOrEmpty(msg.groomId) then
            private.InRoomInfoCache.RoomInfo.BriefInfo.groomId = msg.groomId
        end
        EventSystem.Dispatch(EventID.UI_UpdateRoomInfo)
    else
        logging.error(LTAG.ERROR, "[G2CBPInfo]", curRoomId, msg.RoomID, curActivityID, msg.ActivityID)
    end
end

function private.OnG2CPushCustom1V1BattleResult(msg)
    if LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.None and LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.FastPlay then
        EventSystem.Dispatch(EventID.BI_LevelMiddle, BIManager.BIType.SyncBattle, "[sync]tournamentResultAtBeforeBegin")
        NotSyncBattleSetter.StopCurLevel()
        LevelManager.SetLoadingLevelEnd()
    end
    CameraController.Instance:SetGray(false)
    CTL.HomeMain.CloseOpenView()

    local curCampId
    if BattleDataGetter.GetCurEntity() then
        curCampId = BattleDataGetter.GetCurEntity():GetCampID()
    end
    local info = {
        passTime = msg.passTime,
        Icons = msg.Icons,
        isWin = msg.winnerCampId == curCampId,
        enemyFighterRecords = curCampId == 1 and msg.camp2 or msg.camp1, -- 右侧显示camp2
        ourFighterRecords = curCampId == 1 and msg.camp1 or msg.camp2, -- 左侧显示camp1
        diffValue = 0,
        IsCustomRoom = true,
        costProtectCard = false,
    }
    UIManager.OpenView(Const_UI_Lua.UIEnum.UISyncSoloBattleOverPanel, info) -- 使用1v1的界面
end

function private.OnG2CPushCustom3V3BattleResult(msg)
    if LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.None and LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.FastPlay then
        EventSystem.Dispatch(EventID.BI_LevelMiddle,BIManager.BIType.SyncBattle,"[sync]3v3ResultAtBeforeBegin")
        NotSyncBattleSetter.StopCurLevel()
        LevelManager.SetLoadingLevelEnd()
    end
    CameraController.Instance:SetGray(false)
    UIManager.CloseAllBase()
    UIManager.OpenView(Const_UI_Lua.UIEnum.UIPKRoom3v3BattleOverPanel, msg, Const_UI_Lua.UIEnum.UISyncTeamPVPBattleOverPanel)

    local curCampId
    if BattleDataGetter.GetCurEntity() then
        curCampId = BattleDataGetter.GetCurEntity():GetCampID()
    end
    local myProgress, enemyProgress
    if curCampId == 1 then
        myProgress = msg.camp1CaptureProgress
        enemyProgress = msg.camp2CaptureProgress
    else
        myProgress = msg.camp2CaptureProgress
        enemyProgress = msg.camp1CaptureProgress
    end
    EventSystem.Dispatch(EventID.UI_SyncTeamPVPBattleOver_ShowResult, myProgress, enemyProgress)
end

--- 更改房间信息
---@param operType SettingOptType 操作类型
---@param roomName string 房间名称
---@param accessDan int 准入等级
---@param isPublic bool 是否公开显示
---@param isNeedPWD bool 是否需要密码
---@param pwd string 密码
function CustomRoom_Model.ChangeCustomRoomInfoReq(operType, roomName, accessDan, isNeedPWD, pwd)
    local msg = custom_room_opt_pb.ChangeCustomRoomInfoReq()
    msg.ChangeType = operType
    if roomName ~= nil then
        msg.ParamInfo.RoomName = roomName
    end
    if accessDan ~= nil then
        msg.ParamInfo.AccessDan = accessDan
    end
    if isNeedPWD ~= nil then
        msg.ParamInfo.RequirePassword = isNeedPWD
    end
    local intPWD = tonumber(pwd)
    if intPWD ~= nil then
        msg.ParamInfo.Password = intPWD
    end
    -- 保存缓存
    NetManager.SendMessage(MessageEnums.MessageChangeCustomRoomInfo, msg)
end

function private.ChangeCustomRoomInfoResp(msg)
    if msg.Resp.Code == 0 then
        -- 更新房间内设置缓存
        private.SetRoomSettingInfo(
                nil,
                nil,
                msg.RoomParamInfo.RoomName,
                msg.RoomParamInfo.AccessDan,
                msg.RoomParamInfo.RequirePassword,
                msg.RoomParamInfo.Password,
                true
        )
        EventSystem.Dispatch(EventID.UI_UpdateRoomSettingInfo)
    else
        EventSystem.Dispatch(EventID.UI_PK_FailClearInfo)
    end
end

--- 成员请求交换位置(req)
function CustomRoom_Model.MemberEXPositionReq(position)
    local msg = custom_room_opt_pb.MemberEXPositionReq()
    msg.Position = position
    local memberData = CustomRoom_Model.GetInRoomMemberDic()[position]
    private.changePlayerInfo = memberData
    NetManager.SendMessage(MessageEnums.MessageMemberEXPosition, msg)
end

function private.MemberEXPositionResp(msg)
    if msg.Resp.Code == 0 then
        if not msg.UpdateMemberInfo or #msg.UpdateMemberInfo == 0 and private.changePlayerInfo then
            table.insert(CustomRoom_Model.InteractingQueue, {
                targetACID = private.changePlayerInfo.ACID,
                ExEndTimeStamp = msg.ExEndTimeStamp
            })
            CustomRoom_Model.AbleExchangeTimestamp = msg.ExEndTimeStamp
        end
        private.UpdateCustomInRoomMemberInfosDataCache(msg.UpdateMemberInfo)
        EventSystem.Dispatch(EventID.UI_UpdateRoomInfo)
    end
end

--- 成员处理交换位置请求(Req)。
function CustomRoom_Model.MemberOptEXPositionReq(isAgree)
    local msg = custom_room_opt_pb.MemberOptEXPositionReq()
    msg.Agree = isAgree
    NetManager.SendMessage(MessageEnums.MessageMemberOptEXPosition, msg)
end

function private.MemberOptEXPositionResp(msg)
    if msg.Resp.Code == 0 then
        private.UpdateCustomInRoomMemberInfosDataCache(msg.UpdateMemberInfo)
        table.remove(CustomRoom_Model.InteractingQueue)
        EventSystem.Dispatch(EventID.UI_UpdateRoomInfo)
    end
end

--- 邀请玩家进入房间
function CustomRoom_Model.CustomRoomInviteReq(targetACID)
    local msg = custom_room_opt_pb.CustomRoomInviteReq()
    msg.TargetACID = targetACID
    NetManager.SendMessage(MessageEnums.MessageCustomRoomInvite, msg)
end

function private.CustomRoomInviteResp(msg)
    if msg.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamUI_ActiveInvitation_HaveBeenInvited"])
    else
        if msg.Resp.Code == 1004 then
            -- 邀请的目标人没有权限
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_InviteLocker"])
        end
    end
end

-- 拒绝邀请进入房间
function CustomRoom_Model.RefuseCustomRoomInviteReq(activityID, roomID)
    local msg = custom_room_opt_pb.RefuseCustomRoomInviteReq()
    msg.ActivityID = activityID
    msg.RoomID = roomID
    table.insert(private.RemoveInviteMsgCacheQueue, { ActivityID = activityID, RoomID = roomID })
    NetManager.SendMessage(MessageEnums.MessageRefuseCustomRoomInvite, msg)
end

function private.RefuseCustomRoomInviteResp(msg)
    local tempData = table.remove(private.RemoveInviteMsgCacheQueue, 1)
    CustomRoom_Model.RemoveInvitedInfo(tempData.ActivityID, tempData.RoomID)
end

--- 取消玩家准备状态
function CustomRoom_Model.CancelMemberReadyState()
    if CustomRoom_Model.IsInRoom() and not CustomRoom_Model.IsRoomOwner() then
        local msg = custom_room_opt_pb.MemberChangeStateReq()
        msg.Ready = false
        NetManager.SendMessage(MessageEnums.MessageMemberChangeState, msg)
    end
end

--- 切换准备状态
function CustomRoom_Model.MemberChangeStateReq()
    local msg = custom_room_opt_pb.MemberChangeStateReq()
    local myData = CustomRoom_Model.GetMemberDataByACID()
    local myState = myData.SupplementInfo.CurState
    local isWaiting = myState == CustomRoom_Model.MemberState.Waiting
    if isWaiting and #CustomRoom_Model.InteractingQueue > 0 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Room_Tips_10"])
        return
    end
    
    local success = CustomRoom_Model.ChangeLineupReq(private.InRoomSetting.ActivityID)
    if myState == CustomRoom_Model.MemberState.Waiting and success then
        -- 准备必须上阵
        msg.Ready = true
        NetManager.SendMessage(MessageEnums.MessageMemberChangeState, msg)
    else
        -- 取消
        msg.Ready = false 
        NetManager.SendMessage(MessageEnums.MessageMemberChangeState, msg)
    end
end

function private.MemberChangeStateResp(msg)
    if msg.Resp.Code == 0 then
        local myData = CustomRoom_Model.GetMemberDataByACID()
        myData.SupplementInfo.CurState = msg.Ready == true and CustomRoom_Model.MemberState.Ready or CustomRoom_Model.MemberState.Waiting
        EventSystem.Dispatch(EventID.UI_UpdateMemberState)
    end
end

-- 房主点击进入战斗
function CustomRoom_Model.CustomRoomEnterBattleReq()
    local msg = custom_room_opt_pb.CustomRoomEnterBattleReq()
    local activityId = private.InRoomInfoCache.RoomInfo.BriefInfo.ActivityID
    local playerCount = private.InRoomInfoCache.RoomInfo.BriefInfo.CurrentNum

    if not CustomRoom_Model.IsAllPlayerReady() then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_PK_Room_Tips_8"])
        return
    end

    if not CTL.CustomRoom.IsRoomMemberFull(activityId, playerCount) then
        UTL.MessageBox.ShowOKCancelBox("", Const_IDS.IDS_Robot_Tips, function()
            local success = CustomRoom_Model.ChangeLineupReq(private.InRoomSetting.ActivityID)
            if success then
                NetManager.SendMessage(MessageEnums.MessageCustomRoomEnterBattle, msg)
            end
        end)
        return
    end

    local success = CustomRoom_Model.ChangeLineupReq(private.InRoomSetting.ActivityID)
    if success then
        NetManager.SendMessage(MessageEnums.MessageCustomRoomEnterBattle, msg)
    end
end

function private.CustomRoomEnterBattleResp(msg)
    logging.log(LTAG.LOG, "CustomRoomEnterBattleResp :", msg.Resp.Code)
end

--- 改变出阵阵容, 返回是自己是否合法阵容进行后续操作
function CustomRoom_Model.ChangeLineupReq(activityID)
    local msg = custom_room_opt_pb.ChangeLineupReq()
    local success = false
    local needChangeLineup = false
    if activityID == LuaConst.ActivityType.SyncSoloPK then
        -- 1v1PK 模式
        success, needChangeLineup = private.GetSyncSoloPKModeSuccess(msg.HeroInfos)
    elseif activityID == LuaConst.ActivityType.SyncTVTPK then
        -- 3v3 PK模式
        success, needChangeLineup = true, false
    end

    if needChangeLineup then
        NetManager.SendMessage(MessageEnums.MessageChangeLineup, msg)
    end
    return success
end

function private.ChangeLineupResp(msg)
    logging.log(LTAG.LOG, " ChangeLineupResp ")
end

--- 添加机器人
function CustomRoom_Model.CustomRoomAddRobotReq(activityID, roomID, index)
    local msg = custom_room_opt_pb.CustomRoomAddRobotReq()
    msg.ActivityID = activityID
    msg.RoomID = roomID
    msg.index = index
    NetManager.SendMessage(MessageEnums.MessageCustomRoomAddRobot, msg)
end
--endregion ===================================Req -> Resp ==================================================
--endregion =================================== 网络协议END==================================================

function private.SetEnterType(enterType)
    private.memberEnterType = enterType
end

function CustomRoom_Model.GetIsWatcher()
    return private.memberEnterType == CustomRoom_Model.MemberEnterType_Watcher
end

return CustomRoom_Model