#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package DB.StructData.DBFamily
#
# @todo:DB¼Ò×åÏà¹Ø
# @author hxp
# @date 2025-05-09
# @version 1.0
#
# ÏêϸÃèÊö: DB¼Ò×åÏà¹Ø
#
#-------------------------------------------------------------------------------
#"""Version = 2025-05-09 12:20"""
#-------------------------------------------------------------------------------

import DBStruct
import CommFunc
import GameWorld
import ShareDefine
import PlayerControl
import PlayerViewCache
import PyMongoMain
import DBDataMgr
import ChConfig
import DBComm

import time

FamilyUpperLimitCount = 2000

class FamilyActionData():
    
    def __init__(self, dbData=None, dataToJson=False):
        self.__dbData = DBStruct.tagDBFamilyAction() if not dbData else dbData
        self.__dataDict = DBComm.UserDataDict(self.__dbData, "Data", "DataLen", dataToJson)
        return
    
    def GetFamilyID(self): return self.__dbData.FamilyID
    def GetActionType(self): return self.__dbData.ActionType
    def GetName(self): return self.__dbData.Name
    def SetName(self, name): self.__dbData.Name = name
    def GetTime(self): return self.__dbData.Time
    def SetTime(self, setTime): self.__dbData.Time = setTime
    def GetValue1(self): return self.__dbData.Value1
    def SetValue1(self, value1): self.__dbData.Value1 = value1
    def GetValue2(self): return self.__dbData.Value2
    def SetValue2(self, value2): self.__dbData.Value2 = value2
    def GetValue3(self): return self.__dbData.Value3
    def SetValue3(self, value3): self.__dbData.Value3 = value3
    def GetValue4(self): return self.__dbData.Value4
    def SetValue4(self, value4): self.__dbData.Value4 = value4
    def GetValue5(self): return self.__dbData.Value5
    def SetValue5(self, value5): self.__dbData.Value5 = value5
    def GetValue6(self): return self.__dbData.Value6
    def SetValue6(self, value6): self.__dbData.Value6 = value6
    def GetUserDict(self): return self.__dataDict.GetData()
    def GetUserData(self): return self.__dataDict.ToString()
    def SetUserData(self, value): self.__dataDict.SetData(value)
    def GetBuffer(self):
        self.__dataDict.ToString()
        return self.__dbData.getBuffer()
    
class FamilyAction():
    
    def __init__(self):
        self.familyID = 0
        self.actionType = 0
        self.__actionDataList = []
        return
    
    def InitActionInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        dataToJson = False
        # Èç¹ûÐèÒª dataToJson£¬¿É¸ù¾ÝActionTypeÔÚÕâÀï´¦Àí
        if dbData.ActionType in []:
            dataToJson = True
        actionData = FamilyActionData(dbData, dataToJson)
        self.__actionDataList.append(actionData)
        return actionData
    
    def AddAction(self, maxCount=None):
        ## Ìí¼ÓÏÉÃËActionÊý¾Ý
        # @param maxCount: ¿É´«ÈëÓÉÅäÖþö¶¨µÄ×î´óÌõÊý£¬Èç¹ûΪNoneÔò½øÒ»²½È¡³ÌÐòĬÈÏÉ趨µÄ×î´óÌõÊý£¬¶¼Ã»ÅäÖõĻ°Ä¬Èϲ»ÏÞÌõÊý
        
        fullClear = True
        if maxCount == None:
            maxCount = ShareDefine.ActionTypeSaveCnt.get(self.actionType, 0)
        actionData = None
        if maxCount and self.Count() >= maxCount:
            if not fullClear:
                #³¬¹ý¼Ç¼¼Ç¼²»ÁËÁË
                return actionData
            self.SortByTime()  # °´Ê±¼äÉýÐò
            self.DelAction(0)  # ɾ³ýµÚÒ»¸ö
            
        dbData = DBStruct.tagDBFamilyAction()
        dbData.FamilyID = self.familyID
        dbData.ActionType = self.actionType
        dbData.Time = int(time.time())
        
        actionData = self.InitActionInstance(dbData)
        return actionData
    
    def SortByTime(self):
        self.__actionDataList.sort(key=lambda f: (f.GetTime()))
        return
    
    def DelAction(self, index):
        if 0 <= index < len(self.__actionDataList):
            self.__actionDataList.pop(index)
        return
    
    def GetOneAction(self, isAdd=False):
        ## »ñÈ¡Ò»¸öactionÊý¾Ý£¬½öÕë¶ÔÖ»´æÒ»ÌõÊý¾ÝµÄÀàÐÍ
        aData = None
        if self.Count():
            aData = self.At(0)
        elif isAdd:
            aData = self.AddAction()
        return aData
    
    def Count(self): return len(self.__actionDataList)
    def At(self, index):
        aData = None
        if 0 <= index < len(self.__actionDataList):
            aData = self.__actionDataList[index]
        elif False:
            aData = FamilyActionData()
        return aData
        
class FamilyActionMgr():
    
    def __init__(self):
        self.__familyActionDict = {} # ÏÉÃËactionÐÅÏ¢ {familyID:{actionType:FamilyAction, ...}, ...}
        return
    
    def GetFamilyAction(self, familyID, actionType):
        if familyID not in self.__familyActionDict:
            self.__familyActionDict[familyID] = {}
        actionDict = self.__familyActionDict[familyID]
        if actionType in actionDict:
            action = actionDict[actionType]
        else:
            action = FamilyAction()
            action.familyID = familyID
            action.actionType = actionType
            actionDict[actionType] = action
        return action
    
    def DelFamilyAction(self, familyID, actionType):
        if familyID not in self.__familyActionDict:
            return
        actionDict = self.__familyActionDict[familyID]
        actionDict.pop(actionType, None)
        return
    
    def ClearFamilyAction(self, familyID):
        self.__familyActionDict.pop(familyID, None)
        return
    
    def GetActionTypeList(self, familyID):
        ## »ñÈ¡ÓÐÊý¾ÝµÄactionÀàÐÍÁбí
        return self.__familyActionDict.get(familyID, {}).keys()
    
class FamilyMem():
    
    def __init__(self, dbData=None):
        self.__dbData = DBStruct.tagDBFamilyMem() if not dbData else dbData
        return
    
    def GetPlayerID(self): return self.__dbData.PlayerID
    def GetFamilyID(self): return self.__dbData.FamilyID
    def GetJoinTime(self): return self.__dbData.JoinTime
    def GetPlayerName(self): return self.__dbData.PlayerName
    def SetPlayerName(self, playerName): self.__dbData.PlayerName = playerName
    def GetLV(self): return self.__dbData.LV
    def SetLV(self, lv): self.__dbData.LV = lv
    def GetJob(self): return self.__dbData.Job
    def SetJob(self, job): self.__dbData.Job = job
    def GetRealmLV(self): return self.__dbData.RealmLV
    def SetRealmLV(self, realmLV): self.__dbData.RealmLV = realmLV
    def GetFace(self): return self.__dbData.Face
    def SetFace(self, face): self.__dbData.Face = face
    def GetFacePic(self): return self.__dbData.FacePic
    def SetFacePic(self, facePic): self.__dbData.FacePic = facePic
    def GetFightPower(self): return self.__dbData.FightPower
    def GetFightPowerEx(self): return self.__dbData.FightPowerEx
    def GetFightPowerTotal(self): return self.__dbData.FightPowerEx * ChConfig.Def_PerPointValue + self.__dbData.FightPower
    def SetFightPowerTotal(self, fightPowerTotal):
        self.__dbData.FightPower = fightPowerTotal % ChConfig.Def_PerPointValue
        self.__dbData.FightPowerEx = fightPowerTotal / ChConfig.Def_PerPointValue
        return
    def GetServerID(self): return self.__dbData.ServerID
    def SetServerID(self, serverID): self.__dbData.ServerID = serverID
    def GetOffTime(self): return self.__dbData.OffTime
    def SetOffTime(self, offTime): self.__dbData.OffTime = offTime
    def GetFmLV(self): return self.__dbData.FmLV
    def SetFmLV(self, fmLV): self.__dbData.FmLV = fmLV
    def GetContribTotal(self): return self.__dbData.ContribTotal
    def SetContribTotal(self, contribTotal): self.__dbData.ContribTotal = contribTotal
    def GetContribWeek(self): return self.__dbData.ContribWeek
    def SetContribWeek(self, contribWeek): self.__dbData.ContribWeek = contribWeek
    def GetBuffer(self): return self.__dbData.getBuffer()
    
    def RefreshMemberByID(self, playerID):
        ## ¸ù¾ÝÍæ¼ÒID¸üгÉÔ±Êý¾Ý£¬Ò»°ãÓÃÓÚÀëÏß¹¦ÄÜ£¬ÈçÌí¼ÓÀëÏß³ÉÔ±£¬Ö±½ÓʹÓò鿴»º´æ¸üÐÂ
        if playerID != self.GetPlayerID():
            return
        viewCache = PlayerViewCache.FindViewCache(playerID)
        if not viewCache:
            return
        self.SetPlayerName(viewCache.GetPlayerName())
        self.SetLV(viewCache.GetLV())
        self.SetJob(viewCache.GetJob())
        self.SetRealmLV(viewCache.GetRealmLV())
        self.SetFace(viewCache.GetFace())
        self.SetFacePic(viewCache.GetFacePic())
        self.SetServerID(viewCache.GetServerID())
        fpChange = False
        fightPowerTotal = viewCache.GetFightPowerTotal()
        if self.GetFightPowerTotal() < fightPowerTotal:
            self.SetFightPowerTotal(fightPowerTotal)
            fpChange = True
        return fpChange
    
    def RefreshMember(self, curPlayer):
        '''ˢгÉÔ±ÐÅÏ¢£¬ÏÉÃ˳ÉÔ±ÊôÓÚÓÀ¾Ã¹¦ÄÜÊý¾Ý£¬³ý·ÇÏÉÃ˽âÉ¢£¬ËùÒÔµ¥¶À´æÒ»·Ý³ÉÔ±»ù´¡ÐÅÏ¢£¬·ÀÖ¹¹ý¶ÈÒÀÀµ²é¿´»º´æÊý¾ÝÒý·¢µÄÎÊÌâ
        @return: Õ½Á¦ÊÇ·ñ±ä¸ü
        '''
        if not curPlayer or curPlayer.GetPlayerID() != self.GetPlayerID():
            return
        self.SetPlayerName(curPlayer.GetPlayerName())
        self.SetLV(curPlayer.GetLV())
        self.SetJob(curPlayer.GetJob())
        self.SetRealmLV(curPlayer.GetOfficialRank())
        self.SetFace(curPlayer.GetFace())
        self.SetFacePic(curPlayer.GetFacePic())
        self.SetServerID(GameWorld.GetPlayerServerID(curPlayer))
        fightPowerTotal = PlayerControl.GetFightPower(curPlayer)
        fpChange = self.GetFightPowerTotal() != fightPowerTotal
        self.SetFightPowerTotal(fightPowerTotal)
        return fpChange
    
class Family():
    
    def __init__(self, dbData=None):
        self.__dbData = DBStruct.tagDBFamily() if not dbData else dbData
        self.__memberList = [] # [FamilyMem, ...]
        self.__memberDict = {} # ³ÉÔ±×Öµä {playerID:FamilyMem, ...}
        self.__familyMgr = DBDataMgr.GetFamilyMgr()
        self.__actionMgr = DBDataMgr.GetFamilyActionMgr()
        self.__memFightPowerChange = None # ³ÉÔ±Õ½Á¦ÊÇ·ñÓб仯£¬Ä¬ÈÏNone£¬´ú±íδ´¦Àí¹ý
        return
    
    def GetID(self): return self.__dbData.ID
    def GetCreateTime(self): return self.__dbData.CreateTime
    def GetServerID(self): return self.__dbData.ServerID
    def GetName(self): return self.__dbData.Name
    def SetName(self, name): self.__dbData.Name = name
    def GetLeaderID(self): return self.__dbData.LeaderID
    def SetLeaderID(self, leaderID): self.__dbData.LeaderID = leaderID
    def GetLV(self): return self.__dbData.LV
    def SetLV(self, lv): self.__dbData.LV = lv
    def GetExp(self): return self.__dbData.Exp
    def SetExp(self, exp): self.__dbData.Exp = exp
    def GetJoinReview(self): return self.__dbData.JoinReview # ³ÉÔ±¼ÓÈëÊÇ·ñÐèÒªÉóºË£¬Ä¬ÈÏ0×Ô¶¯¼ÓÈë
    def SetJoinReview(self, joinReview): self.__dbData.JoinReview = joinReview
    def GetJoinLVMin(self): return self.__dbData.JoinLVMin
    def SetJoinLVMin(self, JoinLVMin): self.__dbData.JoinLVMin = JoinLVMin
    def GetBroadcast(self): return self.__dbData.Broadcast
    def SetBroadcast(self, broadcast):
        self.__dbData.Broadcast = broadcast
        self.__dbData.BroadcastLen = len(self.__dbData.Broadcast)
        return
    def GetFightPower(self): return self.__dbData.FightPower
    def GetFightPowerEx(self): return self.__dbData.FightPowerEx
    def GetFightPowerTotal(self): return self.__dbData.FightPowerEx * ChConfig.Def_PerPointValue + self.__dbData.FightPower
    def SetFightPowerTotal(self, fightPowerTotal):
        self.__dbData.FightPower = fightPowerTotal % ChConfig.Def_PerPointValue
        self.__dbData.FightPowerEx = fightPowerTotal / ChConfig.Def_PerPointValue
        return
    def GetEmblemID(self): return self.__dbData.EmblemID
    def SetEmblemID(self, emblemID): self.__dbData.EmblemID = emblemID
    def GetBuffer(self): return self.__dbData.getBuffer()
        
    ## ------------------------------------------------
    def InitMemberInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        member = FamilyMem(dbData)
        playerID = member.GetPlayerID()
        if playerID in self.__memberDict:
            return
        self.__memberDict[playerID] = member
        self.__memberList.append(member)
        return member
    
    def GetMemberIDList(self): return self.__memberDict.keys()
    
    def AddMember(self, playerID):
        member = None
        if playerID in self.__memberDict:
            member = self.__memberDict[playerID]
        else:
            dbData = DBStruct.tagDBFamilyMem()
            dbData.PlayerID = playerID
            dbData.FamilyID = self.GetID()
            dbData.JoinTime = int(time.time())
            member = self.InitMemberInstance(dbData)
            if not member and False:
                member = FamilyMem()
        self.__memFightPowerChange = True
        return member
    
    def DeleteMember(self, playerID):
        delMem = self.__memberDict.pop(playerID, None)
        if delMem in self.__memberList:
            self.__memberList.remove(delMem)
        self.__memFightPowerChange = True
        return delMem
    
    def FindMember(self, playerID):
        mem = None
        if playerID in self.__memberDict:
            mem = self.__memberDict[playerID]
        elif False:
            mem = FamilyMem()
        return mem
    
    def GetCount(self): return len(self.__memberList)
    def GetAt(self, index):
        mem = None
        if 0 <= index < len(self.__memberList):
            mem = self.__memberList[index]
        elif False:
            mem = FamilyMem()
        return mem
    
    def RefreshFamilyMember(self, curPlayer):
        ## Ë¢ÐÂÔÚÏß³ÉÔ±ÐÅÏ¢
        playerID = curPlayer.GetPlayerID()
        familyID = curPlayer.GetFamilyID()
        if self.GetID() != familyID:
            return
        member = self.FindMember(playerID)
        if not member:
            return
        if member.RefreshMember(curPlayer):
            self.__memFightPowerChange = True
        return
    
    def RefrshFightPowerTotal(self, checkChange=False):
        ## Ë¢ÐÂ×ÜÕ½Á¦
        if checkChange and self.__memFightPowerChange == False: # ĬÈÏNone£¬Ê״αØË¢ÐÂ
            #GameWorld.DebugLog("ûÓгÉÔ±Õ½Á¦±ä»¯¿É²»Ë¢ÐÂÏÉÃË×ÜÕ½Á¦! familyID=%s" % self.GetID())
            return
        familyFightPowerTotal = 0
        for index in range(self.GetCount()):
            member = self.GetAt(index)
            if not member:
                continue
            familyFightPowerTotal += member.GetFightPowerTotal()
        self.SetFightPowerTotal(familyFightPowerTotal)
        #GameWorld.DebugLog("Ë¢ÐÂÏÉÃË×ÜÕ½Á¦! familyID=%s" % self.GetID())
        self.__memFightPowerChange = False
        return familyFightPowerTotal
    
    def GetReqJoinPlayerInfo(self):
        ## »ñÈ¡ÉêÇë¼ÓÈëµÄÍæ¼ÒÐÅÏ¢
        # @return: {playerID:ÉêÇëʱ¼ä´Á, ...}
        joinAction  = self.__actionMgr.GetFamilyAction(self.GetID(), ShareDefine.Def_ActionType_FamilyAdd)
        actionData = joinAction.GetOneAction(True)
        dataDict = actionData.GetUserDict()
        if "ReqJoin" not in dataDict:
            dataDict["ReqJoin"] = {}
        return dataDict["ReqJoin"]
    
    def AddReqJoinPlayerID(self, playerID):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        reqPlayerIDDict[playerID] = int(time.time()) # ÉêÇëʱ¼ä´Á
        self.__familyMgr.AddPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def DelReqJoinPlayerID(self, playerID):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        if playerID in reqPlayerIDDict:
            reqPlayerIDDict.pop(playerID)
        self.__familyMgr.DelPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def DelReqJoinPlayerAll(self):
        reqPlayerIDDict = self.GetReqJoinPlayerInfo()
        for playerID in reqPlayerIDDict.keys():
            reqPlayerIDDict.pop(playerID)
            self.__familyMgr.DelPlayerReqJoinFamilyID(playerID, self.GetID())
        return
    
    def OnDelete(self):
        self.DelReqJoinPlayerAll()
        self.__actionMgr.ClearFamilyAction(self.GetID())
        return
    
class FamilyMgr():
    
    def __init__(self):
        self.__familyList = [] # ÏÉÃ˶ÔÏóÁÐ±í£¬¿É½øÐÐÅÅÐò [Family, ...]
        self.__familyIDDict = {} # ÏÉÃËID¶ÔÏó×Öµä,  {familyID:Family, ...}
        self.__familyNameDict = {} # ÏÉÃËÃû³Æ¶ÔÏó×Öµä,  {familyName:Family, ...}
        self.__actionMgr = FamilyActionMgr()
        self.__playerReqJoinDict = None # Íæ¼ÒÉêÇë¼ÓÈëÏÉÃËÁбí {playerID:[familyID, ...], ...}
        return
    
    def InitFamilyInstance(self, dbData):
        '''³õʼ»¯¹¦ÄÜÊý¾ÝʵÀý£¬´´½¨»ò¼ÓÔØÊý¾ÝʱͨÓ㬹¦ÄÜÒ»°ã²»µ÷ÓÃ
        @param dbData: ʵÀý¶ÔÓ¦°ó¶¨µÄdbData
        @return: ³É¹¦·µ»ØʵÀý¶ÔÏó£¬Ê§°Ü·µ»ØNone
        '''
        family = Family(dbData)
        familyID = family.GetID()
        if familyID in self.__familyIDDict:
            return
        self.__familyList.append(family)
        self.__familyIDDict[familyID] = family
        self.__familyNameDict[family.GetName()] = family
        return family
    
    def Sort(self):
        ''' ĬÈÏÅÅÐòµ¹Ðò£¬°´  ÏÉÃË×ÜÕ½Á¦ -> ÏÉÃ˵ȼ¶
        '''
        self.__familyList.sort(key=lambda f: (f.GetFightPowerTotal(), f.GetLV()), reverse=True)
        return
    
    def AddFamily(self, familyName, serverID, familyID=None):
        ## ´´½¨ÐÂÏÉÃË
        newFamily = None
        if familyID == None:
            familyID = PyMongoMain.GetUserCtrlDB().GetNewFamilyID()
            if familyID <= 0:
                GameWorld.ErrLog("´´½¨ÏÉÃËʱÉú³ÉÐÂIDÒì³£!")
                return newFamily
        if familyID in self.__familyIDDict:
            GameWorld.ErrLog("´´½¨ÏÉÃËʱIDÒÑ´æÔÚ! familyID=%s" % familyID)
            return newFamily
        if familyName in self.__familyNameDict:
            GameWorld.ErrLog("´´½¨ÏÉÃËʱÃû³ÆÒÑ´æÔÚ! familyName=%s" % familyName)
            return newFamily
        if len(self.__familyList) >= FamilyUpperLimitCount:
            GameWorld.ErrLog("µ¥·þÏÞÖÆ´´½¨ÏÉÃËÊýÒÑ´ïÉÏÏÞ!")
            return newFamily
        
        dbData = DBStruct.tagDBFamily()
        dbData.ID = familyID
        dbData.Name = familyName
        dbData.ServerID = serverID
        dbData.CreateTime = int(time.time())
        
        newFamily = self.InitFamilyInstance(dbData)
        if not newFamily and False: # ²»Ö´ÐУ¬ÎªÁË´úÂëÌáʾ
            newFamily = Family()
        return newFamily
    
    def FindFamily(self, familyID):
        family = None
        if familyID in self.__familyIDDict:
            family = self.__familyIDDict[familyID]
        elif False:
            family = Family()
        return family
    
    def FindFamilyByName(self, familyName):
        family = None
        if familyName in self.__familyNameDict:
            family = self.__familyNameDict[familyName]
        elif False:
            family = Family()
        return family
    
    def DelFamily(self, familyID):
        family = self.FindFamily(familyID)
        if family:
            self.__familyNameDict.pop(family.GetName(), None)
            if family in self.__familyList:
                self.__familyList.remove(family)
            family.OnDelete()
        self.__familyIDDict.pop(familyID, None)
        if familyID > ShareDefine.FackFamilyIDMax:
            PyMongoMain.GetUserCtrlDB().FreeFamilyID(familyID) # ¹é»¹ÏÉÃËID£¬Öظ´Ê¹ÓÃ
        return family
    
    def DelAllFamily(self):
        for index in range(self.GetCount())[::-1]:
            family = self.GetAt(index)
            familyID = family.GetID()
            self.DelFamily(familyID)
        return
    
    def GetCount(self): return len(self.__familyList)
    def GetAt(self, index):
        family = None
        if 0 <= index < len(self.__familyList):
            family = self.__familyList[index]
        elif False:
            family = Family()
        return family
    
    def GetPlayerFamilyID(self, playerID):
        ## »ñÈ¡Íæ¼Òµ±Ç°ËùÊôµÄÏÉÃËID
        for index in range(self.GetCount()):
            family = self.GetAt(index)
            if family.FindMember(playerID):
                return family.GetID()
        return 0
    
    def GetFamilyActionMgr(self): return self.__actionMgr
    
    def GetPlayerReqJoinFamilyIDList(self, playerID):
        ## »ñÈ¡Íæ¼ÒÉêÇë¼ÓÈëµÄÏÉÃËIDÁбí
        if self.__playerReqJoinDict == None:
            self.__playerReqJoinDict = {}
            for index in xrange(self.GetCount()):
                family = self.GetAt(index)
                familyID = family.GetID()
                reqPlayerIDDict = family.GetReqJoinPlayerInfo()
                for reqID in reqPlayerIDDict.keys():
                    if reqID not in self.__playerReqJoinDict:
                        self.__playerReqJoinDict[reqID] = []
                    reqFamilyIDList = self.__playerReqJoinDict[reqID]
                    if familyID not in reqFamilyIDList:
                        reqFamilyIDList.append(familyID)
                        
        if playerID not in self.__playerReqJoinDict:
            self.__playerReqJoinDict[playerID] = []
        return self.__playerReqJoinDict[playerID]
    
    def AddPlayerReqJoinFamilyID(self, playerID, familyID):
        ## Ìí¼ÓÍæ¼ÒÉêÇë¼ÓÈëÄ¿±êÏÉÃ˼Ǽ
        # @return: ÊÇ·ñÓÐÔö¼Ó¼Ç¼
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        if familyID not in reqFamilyIDList:
            reqFamilyIDList.append(familyID)
            return True
        return False
    
    def DelPlayerReqJoinFamilyID(self, playerID, familyID):
        ## ɾ³ýÍæ¼ÒÉêÇë¼ÓÈëÄ¿±êÏÉÃ˼Ǽ
        # @return: ÊÇ·ñÓÐɾ³ý¼Ç¼
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        if familyID in reqFamilyIDList:
            reqFamilyIDList.remove(familyID)
            return True
        return False
    
    def DelPlayerReqJoinFamilyIDAll(self, playerID):
        ## ɾ³ýÍæ¼ÒËùÓеÄÉêÇë¼ÓÈëÏÉÃ˼Ǽ
        reqFamilyIDList = self.GetPlayerReqJoinFamilyIDList(playerID)
        for familyID in reqFamilyIDList[::-1]:
            family = self.FindFamily(familyID)
            if not family:
                continue
            family.DelReqJoinPlayerID(playerID)
        return
    
    # ±£´æÊý¾Ý ´æÊý¾Ý¿âºÍrealtimebackup
    def GetSaveData(self):
        
        familyDataCnt, familySavaData = 0, ""
        membreDataCnt, memberSavaData = 0, ""
        actionDataCnt, actionSavaData = 0, ""
        for family in self.__familyList:
            familyID = family.GetID()
            familySavaData += family.GetBuffer()
            familyDataCnt += 1
            
            for memIndex in range(family.GetCount()):
                member = family.GetAt(memIndex)
                memberSavaData += member.GetBuffer()
                membreDataCnt += 1
                
            for actionType in self.__actionMgr.GetActionTypeList(familyID):
                action = self.__actionMgr.GetFamilyAction(familyID, actionType)
                for aIndex in range(action.Count()):
                    actionData = action.At(aIndex)
                    actionSavaData += actionData.GetBuffer()
                    actionDataCnt += 1
                    
        saveData = ""
        
        saveData += CommFunc.WriteDWORD("", familyDataCnt) + familySavaData
        GameWorld.Log("Save DBFamily count :%s len=%s" % (familyDataCnt, len(familySavaData)))
        
        saveData += CommFunc.WriteDWORD("", membreDataCnt) + memberSavaData
        GameWorld.Log("Save DBFamilyMem count :%s len=%s" % (membreDataCnt, len(memberSavaData)))
        
        saveData += CommFunc.WriteDWORD("", actionDataCnt) + actionSavaData
        GameWorld.Log("Save DBFamilyAction count :%s len=%s" % (actionDataCnt, len(actionSavaData)))
        
        return saveData
    
    # ´ÓÊý¾Ý¿âÔØÈëÊý¾Ý
    def LoadPyGameData(self, datas, pos, dataslen):        
        # ÏÉÃË
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamily count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamily()
            pos += dbData.readData(datas, pos, dataslen)
            self.InitFamilyInstance(dbData)
        self.Sort()
        
        # ³ÉÔ±
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamilyMem count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamilyMem()
            pos += dbData.readData(datas, pos, dataslen)
            
            familyID = dbData.FamilyID
            family = self.FindFamily(familyID)
            if not family:
                continue
            family.InitMemberInstance(dbData)
            
        # ÐÐΪ
        cnt, pos = CommFunc.ReadDWORD(datas, pos)
        GameWorld.Log("Load DBFamilyAction count :%s" % cnt)
        for _ in xrange(cnt):
            dbData = DBStruct.tagDBFamilyAction()
            pos += dbData.readData(datas, pos, dataslen)
            
            familyID = dbData.FamilyID
            actionType = dbData.ActionType
            family = self.FindFamily(familyID)
            if not family:
                continue
            action = self.__actionMgr.GetFamilyAction(familyID, actionType)
            action.InitActionInstance(dbData)
            
        PyMongoMain.GetUserCtrlDB().OnFamilyIDInit(self.__familyIDDict.keys())
        return pos
    
def OnMinute():
    
    familyMgr = DBDataMgr.GetFamilyMgr()
    # ÿ·ÖÖÓË¢ÐÂÏÂÏÉÃËÕ½Á¦ÅÅÐò
    isSort = False
    for index in range(familyMgr.GetCount()):
        family = familyMgr.GetAt(index)
        if not family:
            continue
        if family.RefrshFightPowerTotal(True):
            isSort = True
    if isSort:
        familyMgr.Sort()
        
    return