#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GameXiangong
#
# @todo:Ïɹ¬
# @author hxp
# @date 2024-09-04
# @version 1.0
#
# ÏêϸÃèÊö: Ïɹ¬
#
#-------------------------------------------------------------------------------
#"""Version = 2024-09-04 16:30"""
#-------------------------------------------------------------------------------

import ShareDefine
import PyDataManager
import NetPackCommon
import ChPyNetSendPack
import PlayerCompensation
import PlayerViewCache
import CrossRealmMsg
import IpyGameDataPY
import PyGameData
import GameWorld
import ChConfig

import time

# Ïɹ¬Íæ¼Ò¼Ç¼
def GetXGPlayerID(recData): return recData.GetValue1() # Ïɹ¬Íæ¼ÒID
##--------------------------------------------------------------------------------------------------

def OnPlayerLogin_CrossLogic(serverGroupID, serverID, playerID):
    ## Íæ¼ÒµÇ¼ - ¿ç·þ´¦ÀíÂß¼­
    
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in range(ipyDataMgr.GetXiangongCount()):
        ipyData = ipyDataMgr.GetXiangongByIndex(index)
        if not ipyData:
            continue
        SendShowXiangongPlayerToClientServer(ipyData, serverGroupID, serverID, playerID)
        
    return

def IsXiangongPlayer(playerID):
    ## ÊÇ·ñÏɹ¬Íæ¼Ò
    gameRecMgr = PyDataManager.GetDBGameRecDataManager()
    recDataDict = gameRecMgr.GetGameRecDataDict(ShareDefine.Def_GameRecType_Xiangong)
    for xiangongID in recDataDict.keys():
        if gameRecMgr.GetGameRecDataMatch(ShareDefine.Def_GameRecType_Xiangong, xiangongID, [playerID], findone=True):
            return True
    return False

def AddXiangongPlayer(xiangongID, playerID, serverIDList, rank=None, syncDict=None):
    ## Ìí¼ÓнúÏɹÙÍæ¼Ò
    if not xiangongID:
        return
    
    ipyData = IpyGameDataPY.GetIpyGameData("Xiangong", xiangongID)
    if not ipyData:
        return
    
    gameRecMgr = PyDataManager.GetDBGameRecDataManager()
    recData = gameRecMgr.AddGameRecData(ShareDefine.Def_GameRecType_Xiangong, xiangongID, [playerID])
    playerInfo = PlayerViewCache.GetShotCacheDict(playerID, "ServerID")
    
    serverID = playerInfo.get("ServerID", 0)
    saveServerIDList = [] + serverIDList # ÖØд´½¨Ò»·Ý´æ´¢£¬²»¸Ä±ä´«ÈëÖµ
    # È·±£Íæ¼Ò×ÔÉíÒ»¶¨ÄÜ¿´µ½×Ô¼º£¬¿ç·þÅÅλÈüÀúÊ··ÖÇøÎÊÌâ
    if saveServerIDList and serverID and not GameWorld.CheckServerIDInList(serverID, saveServerIDList):
        saveServerIDList.append(serverID)
    recData.SetUserDataByKey(ChConfig.Def_RecDataKey_ServerIDList, saveServerIDList) # ±£´æµ±ÏµÄÇø·þID·¶Î§        
    recData.SetUserDataByKey(ChConfig.Def_RecDataKey_PlayerInfo, playerInfo) # ±£´æµ±ÏµÄÍæ¼Ò»ù±¾ÐÅÏ¢
    GameWorld.Log("нúÏɹÙÍæ¼Ò: xiangongID=%s,playerID=%s,rank=%s,serverID=%s,saveServerIDList=%s,%s" 
                  % (xiangongID, playerID, rank, serverID, saveServerIDList, playerInfo))
    
    # ½úÉýÓʼþ֪ͨ
    if playerID > 10000 and rank:
        titleID = ipyData.GetTitleID()
        addItemList = ipyData.GetAwardItemList()
        addQiyun = 0 if not addItemList else addItemList[0][1]
        paramList = [rank, titleID, addQiyun]
        PlayerCompensation.SendMailByKey(ipyData.GetMailKey(), [playerID], addItemList, paramList, crossMail=True)
        
    if isinstance(syncDict, dict):
        if xiangongID not in syncDict:
            syncDict[xiangongID] = []
        newRecDataList = syncDict[xiangongID]
        newRecDataList.append(recData)
    return

def SendNewXiangongPlayerToClientServer(syncDict):
    ## ͬ²½Ð½úÏɹ¬Íæ¼Òµ½×Ó·þ
    if not syncDict or not isinstance(syncDict, dict):
        return
    for xiangongID, newRecDataList in syncDict.items():
        ipyData = IpyGameDataPY.GetIpyGameData("Xiangong", xiangongID)
        if not ipyData:
            continue
        SendShowXiangongPlayerToClientServer(ipyData, syncRecDataList=newRecDataList)
    return

def SendShowXiangongPlayerToClientServer(ipyData, serverGroupID=0, playerServerID=0, queryPlayerID=0, syncRecDataList=None):
    ## ·¢ËÍÐèҪչʾµÄнúÏɹ¬Íæ¼Òµ½×Ó·þ
    
    if not ipyData:
        return
    xiangongID = ipyData.GetXiangongID()
    showDays = ipyData.GetShowDays()
    
    curTime = int(time.time())
    if syncRecDataList:
        recDataList = syncRecDataList
    else:
        gameRecMgr = PyDataManager.GetDBGameRecDataManager()
        recDataList = gameRecMgr.GetGameRecDataList(ShareDefine.Def_GameRecType_Xiangong, xiangongID)
        
    if not recDataList:
        return
    
    GameWorld.DebugLog("·¢ËÍÐèҪչʾµÄнúÏɹ¬Íæ¼Òµ½×Ó·þ: xiangongID=%s,recDataLen=%s" % (xiangongID, len(recDataList)))
    GameWorld.DebugLog("serverGroupID=%s,playerServerID=%s,queryPlayerID=%s" % (serverGroupID, playerServerID, queryPlayerID))
    playerInfoList = []
    for recData in recDataList[::-1]:
        xgPlayerID = GetXGPlayerID(recData)
        addTime = recData.GetTime()
        passDays = GameWorld.GetDiff_Day(curTime, addTime) + 1
        if passDays > showDays:
            GameWorld.DebugLog("    xgPlayerID=%s,addTime=%s,passDays=%s > %s" % (xgPlayerID, addTime, passDays, showDays))
            break
        serverIDList = recData.GetUserDataByKey(ChConfig.Def_RecDataKey_ServerIDList)
        if playerServerID:
            if serverIDList == None:
                GameWorld.DebugLog("    xgPlayerID=%s,serverIDList is None" % (xgPlayerID))
                continue
            if not GameWorld.CheckServerIDInList(playerServerID, serverIDList):
                GameWorld.DebugLog("    xgPlayerID=%s,playerServerID=%s not in %s" % (xgPlayerID, playerServerID, serverIDList))
                continue
            
        playerInfo = PlayerViewCache.GetShotCacheDict(xgPlayerID, "PlayerID", "ServerID", "Model")
        if not playerInfo:
            GameWorld.Log("ÕÒ²»µ½Íæ¼Ò»º´æµÄÔݲ»Í¬²½Ïɹ¬Ð½úÏɹÙ! xgPlayerID=%s" % xgPlayerID)
            continue
        playerInfo["AddTime"] = addTime
        playerInfo["ServerIDList"] = serverIDList
        
        playerInfoList.insert(0, playerInfo)
        
    GameWorld.DebugLog("playerInfoListLen=%s" % (len(playerInfoList)))
    if not playerInfoList:
        return
    
    serverGroupIDList = [serverGroupID] if serverGroupID else []
    dataMsg = {"msgType":"ShowXiangongPlayer", "xiangongID":xiangongID, "playerInfoList":playerInfoList, "queryPlayerID":queryPlayerID}
    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_Xiangong, dataMsg, serverGroupIDList)
    return

def ClientServerMsg_QueryXiangong(serverGroupID, msgData):
    ## ÊÕµ½×Ó·þ - ²é¿´ÏÉÃû¼
    
    serverID = msgData["serverID"]
    queryPlayerID = msgData["queryPlayerID"]
    xiangongID = msgData["xiangongID"]
    
    playerInfoList = []
    maxSyncCount = min(IpyGameDataPY.GetFuncCfg("XiangongSet", 2), 200)
    gameRecMgr = PyDataManager.GetDBGameRecDataManager()
    recDataList = gameRecMgr.GetGameRecDataList(ShareDefine.Def_GameRecType_Xiangong, xiangongID)
    
    for recData in recDataList[::-1]:
        serverIDList = recData.GetUserDataByKey(ChConfig.Def_RecDataKey_ServerIDList)
        playerInfo = recData.GetUserDataByKey(ChConfig.Def_RecDataKey_PlayerInfo)
        if not playerInfo or not GameWorld.CheckServerIDInList(serverID, serverIDList):
            continue
        playerInfo["AddTime"] = recData.GetTime()
        playerInfo["PlayerID"] = GetXGPlayerID(recData)
        playerInfoList.insert(0, playerInfo)
        if len(playerInfoList) >= maxSyncCount:
            break
        
    # ûÓмǼҲҪ»Ø°ü
    serverGroupList = [serverGroupID] # ½ö֪ͨ²éѯ·þ¼´¿É
    sendMsg = {"msgType":"QueryXiangongPlayer", "xiangongID":xiangongID, "playerInfoList":playerInfoList, "queryPlayerID":queryPlayerID}
    CrossRealmMsg.SendMsgToClientServer(ShareDefine.CrossServerMsg_Xiangong, sendMsg, serverGroupList)
    return

##--------------------------------------------------------------------------------------------------

#// A9 06 ²é¿´Ïɹ¬ÏÉÃû¼ #tagCGQueryXiangongRecPlayers
#
#struct    tagCGQueryXiangongRecPlayers
#{
#    tagHead        Head;
#    WORD        XiangongID;    // Ïɹ¬ID
#};
def OnQueryXiangongRecPlayers(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    xiangongID = clientData.XiangongID
    
    serverID = GameWorld.GetPlayerServerID(curPlayer)
    dataMsg = {"serverID":serverID, "queryPlayerID":playerID, "xiangongID":xiangongID}
    CrossRealmMsg.SendMsgToCrossServer(ShareDefine.ClientServerMsg_QueryXiangong, dataMsg)
    return

#// A9 07 µãÔÞÏɹ¬ #tagCGLikeXiangong
#
#struct    tagCGLikeXiangong
#{
#    tagHead        Head;
#    WORD        XiangongID;    // Ïɹ¬ID£¬Îª0ʱ´ú±íÿÈÕµÄÏɹ¬µãÔÞ
#};
def OnLikeXiangong(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    xiangongID = clientData.XiangongID
    
    if xiangongID:
        ipyData = IpyGameDataPY.GetIpyGameData("Xiangong", xiangongID)
        if not ipyData:
            return
        showDays = ipyData.GetShowDays()
        timeDict = PyGameData.g_xiangongCanLikeTimeDict.get(playerID, {})
        if xiangongID not in timeDict:
            GameWorld.DebugLog("¸ÃÏɹ¬Ã»ÓÐÐèҪչʾµÄнúÍæ¼Ò¼Ç¼! xiangongID=%s" % xiangongID, playerID)
            return
        addTime = timeDict[xiangongID]
        passDays = GameWorld.GetDiff_Day(int(time.time()), addTime) + 1
        if passDays > showDays:
            GameWorld.DebugLog("¸ÃÏɹ¬Ð½úչʾʱ¼ä³¬¹ý×î´óչʾÌìÊý£¬ÎÞ·¨µãÔÞ! xiangongID=%s,addTime=%s,passDays=%s > %s" 
                               % (xiangongID, addTime, passDays, showDays), playerID)
            return
        moneyType, moneyValue = ipyData.GetMoneyType(), ipyData.GetMoneyValue()
    else:
        moneyType, moneyValue = IpyGameDataPY.GetFuncEvalCfg("XiangongSet", 1)
        
    msgInfo = str(["LikeXiangong", [xiangongID, moneyType, moneyValue]])
    curPlayer.MapServer_QueryPlayerResult(0, 0, "Xiangong", msgInfo, len(msgInfo))
    return

def CrossServerMsg_Xiangong(msgData):
    ## ×Ó·þÊÕµ½¿ç·þÐÅÏ¢
    
    msgType = msgData["msgType"]
    
    if msgType == "ShowXiangongPlayer":
        __Client_ShowXiangongPlayer(msgData)
        
    elif msgType == "QueryXiangongPlayer":
        __Client_QueryXiangongPlayer(msgData)
        
    return

def __Client_ShowXiangongPlayer(msgData):
    ## ×Ó·þÊÕµ½ - ¿ç·þͬ²½Õ¹Ê¾µÄнúÏɹ¬Íæ¼Ò
    
    xiangongID = msgData["xiangongID"]
    playerInfoList = msgData["playerInfoList"]
    queryPlayerID = msgData.get("queryPlayerID", 0)
    
    if not playerInfoList:
        return
    
    newPlayerList = []
    for playerInfo in playerInfoList:
        newP = ChPyNetSendPack.tagGCXiangongNewPlayer()
        newP.AddTime = playerInfo["AddTime"]
        newP.ServerID = playerInfo["ServerID"]
        newP.PlayerID = playerInfo["PlayerID"]
        newP.Name = playerInfo["Name"]
        newP.NameLen = len(newP.Name)
        newP.LV = playerInfo["LV"]
        newP.Job = playerInfo["Job"]
        newP.RealmLV = playerInfo["RealmLV"]
        newP.EquipShowSwitch = playerInfo["EquipShowSwitch"]
        newP.EquipShowID = playerInfo["EquipShowID"]
        newP.EquipShowIDCount = len(newP.EquipShowID)
        newPlayerList.append(newP)
        
    if not newPlayerList:
        return
    
    if queryPlayerID:
        curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(queryPlayerID)
        if not curPlayer:
            return
        __updXiangongCanLikeTime(queryPlayerID, xiangongID, playerInfoList[-1]["AddTime"])
        clientPack = ChPyNetSendPack.tagGCXiangongNewPlayerInfo()
        clientPack.XiangongID = xiangongID
        clientPack.NewPlayerList = newPlayerList[-255:]
        clientPack.NewPlayerCount = len(clientPack.NewPlayerList)
        NetPackCommon.SendFakePack(curPlayer, clientPack)
        return
    
    ## È«·þͬ²½
    clientPack = ChPyNetSendPack.tagGCXiangongNewPlayerInfo()
    clientPack.XiangongID = xiangongID
    
    playerManager = GameWorld.GetPlayerManager()
    for i in range(0, playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(i)
        if curPlayer == None or not curPlayer.GetInitOK():
            continue
        syncNewPlayerList = []
        for nIndex, newP in enumerate(newPlayerList):
            playerInfo = playerInfoList[nIndex]
            serverIDList = playerInfo["ServerIDList"]
            if not GameWorld.CheckServerIDInList(GameWorld.GetPlayerServerID(curPlayer), serverIDList):
                continue
            syncNewPlayerList.append(newP)
            __updXiangongCanLikeTime(curPlayer.GetPlayerID(), xiangongID, playerInfo["AddTime"])
        if not syncNewPlayerList:
            continue
        clientPack.NewPlayerList = syncNewPlayerList[-255:]
        clientPack.NewPlayerCount = len(clientPack.NewPlayerList)
        NetPackCommon.SendFakePack(curPlayer, clientPack)
        
    return

def __updXiangongCanLikeTime(playerID, xiangongID, addTime):
    if playerID not in PyGameData.g_xiangongCanLikeTimeDict:
        PyGameData.g_xiangongCanLikeTimeDict[playerID] = {}
    timeDict = PyGameData.g_xiangongCanLikeTimeDict[playerID]
    canLikeTime = timeDict.get(xiangongID, 0)
    if addTime > canLikeTime:
        timeDict[xiangongID] = addTime
        GameWorld.DebugLog("¸üÐÂÍæ¼Ò¶ÔÓ¦Ïɹ¬¿ÉµãÔÞµÄ×îÐÂʱ¼ä´Á: xiangongID=%s,addTime=%s" % (xiangongID, addTime), playerID)
    return

def __Client_QueryXiangongPlayer(msgData):
    ## ×Ó·þÊÕµ½ - ¿ç·þͬ²½µÄ²éѯÏÉÃû¼»Ø°ü
    
    xiangongID = msgData["xiangongID"]
    playerInfoList = msgData["playerInfoList"]
    queryPlayerID = msgData.get("queryPlayerID", 0)
    
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(queryPlayerID)
    if not curPlayer:
        return
    
    recPlayerList = []
    for playerInfo in playerInfoList:
        if not playerInfo:
            continue
        recP = ChPyNetSendPack.tagGCXiangongRecPlayer()
        recP.AddTime = playerInfo["AddTime"]
        recP.ServerID = playerInfo["ServerID"]
        recP.PlayerID = playerInfo["PlayerID"]
        recP.Name = playerInfo["Name"]
        recP.NameLen = len(recP.Name)
        recP.LV = playerInfo["LV"]
        recP.Job = playerInfo["Job"]
        recP.RealmLV = playerInfo["RealmLV"]
        recPlayerList.append(recP)
        
    clientPack = ChPyNetSendPack.tagGCXiangongRecPlayerInfo()
    clientPack.XiangongID = xiangongID
    clientPack.RecPlayerList = recPlayerList
    clientPack.RecPlayerCount = len(clientPack.RecPlayerList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return