#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerTalk
#
# @todo:ÁÄÌì
# @author hxp
# @date 2025-05-23
# @version 1.0
#
# ÏêϸÃèÊö: ÁÄÌì
#
#-------------------------------------------------------------------------------
#"""Version = 2025-05-23 20:00"""
#-------------------------------------------------------------------------------

import ChConfig
import GameWorld
import ShareDefine
import IPY_GameWorld
import ChPyNetSendPack
import CrossRealmPlayer
import PlayerViewCache
import NetPackCommon
import IpyGameDataPY
import PlayerControl
import PlayerFamily
import DBDataMgr

import math

#ÐèÒª¼Ç¼ÁÄÌ컺´æµÄƵµÀ¶ÔÓ¦ÏÞÖÆ×î´óÌõÊý
ChannelCacheMax = {IPY_GameWorld.tcFamily:30,
                   IPY_GameWorld.tcWorld:100,
                   }
    
def OnPlayerLogin(curPlayer):
    NotifyTalkCache(curPlayer)
    return

#// B3 20 ÁÄÌì #tagCMTalk
#
#struct    tagCMPyTalk
#{
#    tagHead        Head;
#    BYTE        ChannelType;    // ƵµÀ
#    WORD        Len;
#    char        Content[Len];        //size = Len
#};
def OnTalk(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    playerID = curPlayer.GetPlayerID()
    familyID = curPlayer.GetFamilyID()
    channelType = clientData.ChannelType
    content = clientData.Content
    
    #GameWorld.DebugLog("OnTalk channelType=%s, %s" % (channelType, GameWorld.CodeToGbk(content)))
    if channelType == IPY_GameWorld.tcFamily:
        if not familyID:
            PlayerControl.NotifyCode(curPlayer, "jiazu_lhs_0")
            return
        
    elif channelType == IPY_GameWorld.tcCountry:
        if GameWorld.IsCrossServer():
            return
        if not CrossRealmPlayer.IsCrossServerOpen():
            PlayerControl.NotifyCode(curPlayer, "CrossMatching18")
            return
        
    if not __CheckTalk(curPlayer, channelType, content, tick):
        return
    
    curPlayer.SetLastChatTick(tick)
    curPlayer.SetDict(ChConfig.Def_ChannelTalkTick % channelType, tick)
    
    if channelType == IPY_GameWorld.tcCountry:
        #·¢Ë͵½¿ç·þ£¬´ýÀ©Õ¹
        return
    
    bubbleBox = PlayerControl.GetChatBubbleBox(curPlayer) # ÆøÅÝ¿ò
    
    clientPack = ChPyNetSendPack.tagMCTalk()
    clientPack.ChannelType = channelType
    clientPack.PlayerID = playerID
    clientPack.Name = curPlayer.GetPlayerName()
    clientPack.NameLen = len(clientPack.Name)
    clientPack.Content = content
    clientPack.Len = len(clientPack.Content)
    clientPack.BubbleBox = bubbleBox
    clientPack.LV = curPlayer.GetLV()
    clientPack.Job = curPlayer.GetJob()
    clientPack.RealmLV = curPlayer.GetOfficialRank()
    clientPack.Face = curPlayer.GetFace()
    clientPack.FacePic = curPlayer.GetFacePic()
    clientPack.ServerID = GameWorld.GetPlayerServerID(curPlayer)
    
    if channelType == IPY_GameWorld.tcWorld:
        NetPackCommon.SendFackPackOnline(clientPack)
    elif channelType == IPY_GameWorld.tcFamily:
        PlayerFamily.Broadcast_FamilyPack(familyID, clientPack)
        
    DoTalkCache(channelType, playerID, content, bubbleBox, familyID)
    return

def __CheckTalk(curPlayer, channelType, content, tick, checkGMForbidenTalk=True):
    ## ÁÄÌìͨÓüì²é 
    if checkGMForbidenTalk and GetGMToolForbidTalk(curPlayer):
        #GeRen_chenxin_921745 ¶Ô²»Æð£¬ÄúÒѱ»GM½ûÑÔ£¬·¢ËÍÐÅϢʧ°Ü
        #PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_921745")
        return False
    
    #¼ä¸ôʱ¼ä
    if tick - curPlayer.GetLastChatTick() < ChConfig.Def_PlayerTalkTick:
        #PlayerControl.NotifyCode(curPlayer, "CanootTalk02")
        return False
    
    #ƵµÀ¸÷×Ô¼ä¸ôʱ¼ä
    if channelType != None:
        talkCDDict = IpyGameDataPY.GetFuncEvalCfg("TalkCD", 1, {})
        if str(channelType) in talkCDDict:
            cdTicks = talkCDDict[str(channelType)] * 1000
            lastTalkTick = curPlayer.GetDictByKey(ChConfig.Def_ChannelTalkTick % channelType)
            remainTick = cdTicks - (tick - lastTalkTick)
            if remainTick > 0:
                PlayerControl.NotifyCode(curPlayer, "CanootTalk01", [int(math.ceil(remainTick / 1000.0))])
                return False
            
    #ÁÄÌìÐÅϢ̫³¤
    if len(content) > ChConfig.Def_PlayerTalkMaxCount:
        PlayerControl.NotifyCode(curPlayer, "CanootTalk13")
        return False
    
    #²»ÄÜÖ»·¢¿Õ¸ñ
    if content.strip() == '':
        PlayerControl.NotifyCode(curPlayer, "CanootTalk14")
        return False
    
    return True

def GetGMToolForbidTalk(curPlayer):
    ## »ñµÃÍæ¼ÒÊÇ·ñ±»½ûÑÔ 
    #accIDForbid = (curPlayer.GetAccState() & pow(2, ChConfig.Def_PysForbidTalk)) > 0
    return curPlayer.GetGMForbidenTalk()# or accIDForbid

def DoTalkCache(channelType, playerID, content, bubbleBox, familyID=0):
    # ÁÄÌ컺´æ
    if channelType not in ChannelCacheMax:
        return
    cacheMaxDict = IpyGameDataPY.GetFuncEvalCfg("TalkCache", 1, {})
    maxCount = min(ChannelCacheMax[channelType], cacheMaxDict.get(channelType, 0))
    
    # ÏÉÃËÁÄÌì´æFamilyAction
    if channelType == IPY_GameWorld.tcFamily:
        familyActonMgr = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ShareDefine.Def_ActionType_TalkCache)
        actionData = familyActonMgr.AddAction(maxCount)
        actionData.SetValue1(playerID)
        actionData.SetValue2(bubbleBox)
        actionData.GetUserDict().update({"content":content})
        
    else:
        recTypeIDMgr = DBDataMgr.GetGameRecMgr().GetRecTypeIDMgr(ShareDefine.Def_GameRecType_TalkCache, channelType)
        recData = recTypeIDMgr.AddRecData(maxCount)
        recData.SetValue1(playerID)
        recData.SetValue2(bubbleBox)
        recData.GetUserDict().update({"content":content})
        
    return

def NotifyTalkCache(curPlayer):
    ##ÉÏÏß֪ͨÁÄÌ컺´æ
    
    for channelType in ChannelCacheMax.keys():
        cacheList = []
        if channelType == IPY_GameWorld.tcFamily:
            familyID = curPlayer.GetFamilyID()
            if not familyID:
                continue
            familyActonMgr = DBDataMgr.GetFamilyActionMgr().GetFamilyAction(familyID, ShareDefine.Def_ActionType_TalkCache)
            for index in range(familyActonMgr.Count()):
                actionData = familyActonMgr.At(index)
                talkTime = actionData.GetTime()
                playerID = actionData.GetValue1()
                bubbleBox = actionData.GetValue2()
                content = actionData.GetUserDict().get("content", "")
                if not content:
                    content
                cacheList.append([talkTime, playerID, bubbleBox, content])
        else:
            recTypeIDMgr = DBDataMgr.GetGameRecMgr().GetRecTypeIDMgr(ShareDefine.Def_GameRecType_TalkCache, channelType)
            for index in range(recTypeIDMgr.GetCount()):
                recData = recTypeIDMgr.At(index)
                talkTime = recData.GetTime()
                playerID = recData.GetValue1()
                bubbleBox = recData.GetValue2()
                content = recData.GetUserDict().get("content", "")
                if not content:
                    content
                cacheList.append([talkTime, playerID, bubbleBox, content])
                
        if not cacheList:
            continue
        
        packCacheList = []
        for talkTime, playerID, bubbleBox, content in cacheList:
            viewCache = PlayerViewCache.FindViewCache(playerID)
            if not viewCache:
                continue
            talkCache = ChPyNetSendPack.tagMCTalkCacheInfo()
            talkCache.PlayerID = playerID
            talkCache.Name = viewCache.GetPlayerName()
            talkCache.NameLen = len(talkCache.Name)
            talkCache.Content = content
            talkCache.Len = len(talkCache.Content)
            talkCache.BubbleBox = bubbleBox
            talkCache.LV = viewCache.GetLV()
            talkCache.Job = viewCache.GetJob()
            talkCache.RealmLV = viewCache.GetRealmLV()
            talkCache.Face = viewCache.GetFace()
            talkCache.FacePic = viewCache.GetFacePic()
            talkCache.ServerID = viewCache.GetServerID()
            talkCache.TalkTime = talkTime
            packCacheList.append(talkCache)
            
        if not packCacheList:
            continue
        
        clientPack = ChPyNetSendPack.tagMCTalkCacheList()
        clientPack.ChannelType = channelType
        clientPack.InfoList = packCacheList
        clientPack.Count = len(clientPack.InfoList)
        NetPackCommon.SendFakePack(curPlayer, clientPack)
        
    return