#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
#-------------------------------------------------------------------------------
#
##@package PlayerFamilyRedPacket
#
# @todo:¼Ò×åºì°ü
# @author xdh
# @date 2017-08-29
# @version 1.0
#
# ÏêϸÃèÊö: ¼Ò×åºì°ü
#
#---------------------------------------------------------------------
#"""Version = 2017-08-29 18:00"""
#---------------------------------------------------------------------

import GameWorld
import ChPyNetSendPack
import NetPackCommon
import ShareDefine
import IpyGameDataPY
import PlayerDBGSEvent
import PlayerUniversalGameRec
import PlayerControl
import ChConfig
import PlayerCompensation
import PlayerFamily

import time
import random

#Def_UniversalGameRecType_FamilyRedPacketAllRecord
#value1    ºì°üΨһID
#value2    ¼Ò×åID
#value3    ×ܶî¶È*10+½ðÇ®ÀàÐÍ
#value4    ״̬
#value5    ʱ¼ä£¬ÓÃÀ´ÅжÏÊÇ·ñ¹ýÆÚɾ³ýµÄ
#strValue1 ´´½¨ÕßID|´´½¨ÕßÃû×Ö|´´½¨ÕßÖ°Òµ|»ñµÃ;¾¶
#strValue2 ¿ÉÇÀ×ܸöÊý
#strValue3 ×£¸£Óï

#Def_UniversalGameRecType_FamilyRedPacketGrabRecord
#value1    ºì°üΨһID
#value2    playerID
#value3    job
#value4    moneyType
#value5    getMoney
#strValue1 Ãû×Ö

(
State_NoSend,   #δ·¢
State_NoGot,    #δÁìÈ¡
State_HasGot,   #ÒÑÁìÈ¡
State_HasAllGot,#È«²¿ÁìÍê
)=range(4)

g_allRecordDict = {} #{ºì°üID:recData, ...}
g_grabDataDict = {} #{ºì°üID:{playerid:[ÇÀµ½µÄÇ®,Ãû×Ö,job]}, ...}
g_osRedCnt = 0 #¿ª·þºì°ü¸öÊý
## Íæ¼ÒµÇ¼
#  @param None
#  @return None
def OnPlayerLogin(curPlayer):
    NotifyRedPacketInfo(curPlayer)
    return


## ¸ôÌì¸üÐÂ
#  @param None
#  @return None
def DoOnDay():
    __CheckGrabRecData()
    
    return


## Éú³Éкì°ü
def CreatFamilyRedPacket(msgList):
    playerID, getType, packetCnt, moneyType, outputNum, wishStr, state, data = msgList
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
    if not curPlayer:
        return
    if getType == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):
        familyID = 0
        family = None
    else:
        familyID = curPlayer.GetFamilyID()
        family = GameWorld.GetFamilyManager().FindFamily(familyID)
        if not family:
            return
        packetCnt = min(packetCnt, family.GetCount())
#    if getType != 0:
#        commonCntLimit = IpyGameDataPY.GetFuncCfg('FamilyRedPacketCnt')
#        packetCnt = max(packetCnt, commonCntLimit)
    
    if outputNum < packetCnt:
        GameWorld.DebugLog("    Éú³ÉÐÂÏÉÃ˺ì°ü ºì°ü¶î¶È²»ÄܵÍÓÚºì°ü¸öÊý£¡outputNum=%s,redCnt=%s" % (outputNum, packetCnt))
        return
    job = curPlayer.GetJob()
    jobRank = PlayerControl.GetJobRank(curPlayer)
    playerName = curPlayer.GetName()
    redPacketRecData = __SaveNewRedRecord(familyID, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, wishStr)
    #֪ͨ
    if redPacketRecData:
        __NotifyFamilyRedPacketInfo(family, redPacketRecData, [])
        if not familyID:
            if not PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_OSRedPacket):
                PlayerControl.WorldNotify(0, 'OpenRedBag2', [playerName, data, outputNum])
                PlayerDBGSEvent.SetDBGSTrig_ByKey(PlayerDBGSEvent.Def_OSRedPacket, 1)
            elif data in IpyGameDataPY.GetFuncEvalCfg('OSRSuccess'):
                PlayerControl.WorldNotify(0, 'OpenRedBag3', [playerName, data, outputNum])
            #´óÓÚ200¶î¶ÈµÄºì°ü
            if outputNum >= IpyGameDataPY.GetFuncCfg('OpenServerRedPacketRain'):
                PlayerControl.WorldNotify(0, 'OSRedpackSfx')
    return

def CreatNewFamilyRedPacket(family, playerID, redPackID):
    '''Íⲿ½Ó¿Ú£¬Éú³ÉÏÉÃËкì°ü'''
    if not family or not playerID or not redPackID:
        return
    ipyData = IpyGameDataPY.GetIpyGameData('FamilyRedPack', redPackID)
    if not ipyData:
        return
    getType = ipyData.GetGetType()
    moneyType = ipyData.GetMoneyType()
    outputNum = ipyData.GetMoneyNum()
    
    familyID = family.GetID()
    member = family.FindMember(playerID)
    if not member:
        GameWorld.ErrLog("ÏÉÃËûÓиóÉÔ±, ÎÞ·¨·¢·ÅÏÉÃ˺ì°ü!familyID=%s,playerID=%s,redPackID=%s" % (familyID, playerID, redPackID))
        return
    
    job = member.GetJob()
    jobRank = 0
    playerName = member.GetName()
    
    redPacketRecData = __SaveNewRedRecord(familyID, playerID, playerName, job, jobRank, getType, moneyType, outputNum, 0)
    #֪ͨ
    __NotifyFamilyRedPacketInfo(family, redPacketRecData, [])
    return

## ¼Ç¼Ðºì°üÊý¾Ý
def __SaveNewRedRecord(familyID, ownerid, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt,state=State_NoSend, wishStr=''):
    global g_allRecordDict
    global g_osRedCnt
    job = job + jobRank * 10   #¸öλÊÇjob ʮλ°ÙλÊÇjobrank
    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    recordList = universalRecMgr.GetTypeList(recordType)
    if getType == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):
        if not __CheckOSRedPacketCnt(recordList):
            return
        if g_osRedCnt:
            g_osRedCnt += 1
    
    recData = recordList.AddRec()
    
    
    #ºì°üΨһID ´Ó1¿ªÊ¼ÀÛ¼Æ ³¬¹ý20ÒÚÔòÖØпªÊ¼
    # ºì°üΨһID
    DB_RedPacketID = "FamilyRedPacketID"
    redPacketID = PlayerDBGSEvent.GetDBGSTrig_ByKey(DB_RedPacketID) + 1
    if redPacketID >= ChConfig.Def_UpperLimit_DWord:
        redPacketID = 1
    PlayerDBGSEvent.SetDBGSTrig_ByKey(DB_RedPacketID, redPacketID)
    
    curTimeNum = int(time.time())
    recData.SetTime(curTimeNum)
    recData.SetValue1(redPacketID) #ºì°üΨһID
    recData.SetValue2(familyID)  #¼Ò×åID   
    recData.SetValue3(moneyType + outputNum * 10) #×ܶî¶È*10+½ðÇ®ÀàÐÍ
    recData.SetValue4(state) #ÊÇ·ñÒÑ·¢
    recData.SetValue5(curTimeNum) 
    recData.SetStrValue1('%s|%s|%s|%s'%(ownerid,playerName,job,getType)) #´´½¨ÕßID|´´½¨ÕßÃû×Ö|´´½¨ÕßÖ°Òµ|;¾¶
    recData.SetStrValue2(str(packetCnt))#¿ÉÇÀ×ܸöÊý
    recData.SetStrValue3(wishStr)#×£¸£Óï
    g_allRecordDict[redPacketID] = recData
    GameWorld.Log("    Éú³Éеĺì°üfamilyID=%s, redPacketID =%s£¡ownerid=%s, ownername=%s,getType=%s,moneyType=%s,outputNum=%s,packetCnt=%s" % (familyID, redPacketID, ownerid, playerName, getType, moneyType, outputNum, packetCnt))
    return recData


def __CheckOSRedPacketCnt(recordList):
    global g_grabDataDict
    global g_allRecordDict
    global g_osRedCnt
    ##¿ª·þºì°ü¸öÊýÊÇ·ñ´ïÉÏÏÞ
    openServerRedPacketCnt = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCnt')
    if g_osRedCnt and g_osRedCnt < openServerRedPacketCnt + 10:
        return True
    OpenServerRedPacketType = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType')
    allCnt = recordList.Count()

    curCnt = 0
    delRedPacketIDList = []
    for index in xrange(allCnt):
        universalRecData = recordList.At(index)
        strValue1 = universalRecData.GetStrValue1()
        strValue1List = strValue1.split('|')
        getWay = int(strValue1List[3])
        if getWay != OpenServerRedPacketType:
            continue
        redPacketID = universalRecData.GetValue1()
        curCnt += 1
        if len(delRedPacketIDList) < 10:
            delRedPacketIDList.append(redPacketID)
        elif g_osRedCnt:
            break
    if not delRedPacketIDList:
        return True
    if not g_osRedCnt:
        g_osRedCnt = curCnt

    if g_osRedCnt < openServerRedPacketCnt + 10:
        return True

    delCnt = 0
    for index in xrange(recordList.Count()):
        dataIndex = index - delCnt
        universalRecData = recordList.At(dataIndex)
        delRedPacketID = universalRecData.GetValue1()
        if delRedPacketID in delRedPacketIDList:
            recordList.Delete(dataIndex)
            delCnt +=1
            g_grabDataDict.pop(delRedPacketID, 0)
            g_allRecordDict.pop(delRedPacketID, 0)
    g_osRedCnt -= delCnt
    
        
    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    recordList = universalRecMgr.GetTypeList(recordType)
    delCnt = 0
    for index in xrange(recordList.Count()):
        dataIndex = index - delCnt
        universalRecData = recordList.At(dataIndex)
        if universalRecData.GetValue1() in delRedPacketIDList:
            recordList.Delete(dataIndex)
            delCnt +=1
            
    #֪ͨ
    NotifyDelRedPacketInfo(delRedPacketIDList)
    return True

def __DelGrabRecord():
    #ɾ³ý¶àÓàÇÀÐÅÏ¢
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    allRecordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
    allCnt = allRecordList.Count()
    redPacketIDList = []
    for index in xrange(allCnt):
        universalRecData = allRecordList.At(index)
        redPacketID = universalRecData.GetValue1()
        redPacketIDList.append(redPacketID)
    
    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord
    recordList = universalRecMgr.GetTypeList(recordType)
    delCnt = 0
    for index in xrange(recordList.Count()):
        dataIndex = index - delCnt
        universalRecData = recordList.At(dataIndex)
        if universalRecData.GetValue1() not in redPacketIDList:
            recordList.Delete(dataIndex)
            delCnt +=1
    GameWorld.Log('    ɾ³ý¶àÓàÇÀºì°üÐÅÏ¢ delCnt=%s'%delCnt)
    return

isdel = False
if not isdel:
    __DelGrabRecord()
    isdel = True
    


def SendFamilyRedPacket(msgList):
    '''·¢ÏµÍ³ÔùË͵ĺì°ü'''
    playerID, redPacketID, packetCnt = msgList
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
    if not curPlayer:
        return
    
    recDataList = __FindGrabRecData(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord,redPacketID)
    
    if not recDataList:
        return
    recData=recDataList[0]
    strValue1 = recData.GetStrValue1()
    strValue1List = strValue1.split('|')
    ownID = int(strValue1List[0])
    getWay = int(strValue1List[3])
    
    ipyData = IpyGameDataPY.GetIpyGameDataByCondition('FamilyRedPack', {'GetType':getWay})
    if not ipyData:
        return
    if ipyData.GetLeaderOwn():
        if not PlayerFamily.GetPlayerHasFamilyPow(curPlayer, ChConfig.Def_PurviewDictKey_CanSendRedPacket):
            GameWorld.DebugLog('    ·¢ÏµÍ³ÔùË͵ĺì°ü ȨÏÞ²»×㣡', playerID)
            return
        if playerID != ownID:
            strValue1List[0] = str(playerID)
            StrValue1 = '|'.join(strValue1List)
            recData.SetStrValue1(StrValue1)
            
    elif playerID != ownID:
        GameWorld.DebugLog('    ·¢ÏµÍ³ÔùË͵ĺì°ü ²»ÊDZ¾ÈË£¡', playerID)
        return
    
    recData.SetValue4(State_NoGot)
    recData.SetStrValue2(str(packetCnt))
    #¸üÐÂʱ¼ä
    curTimeNum = int(time.time())
    recData.SetValue5(curTimeNum)
    if recData.GetValue2() == 0:
        family = None
    else:
        family = curPlayer.GetFamily()
        if family == None:
            return
    __NotifyFamilyRedPacketInfo(family, recData, [])
    return


## ÇÀºì°ü
def DoGrabFamilyRedPacket(curPlayer, msgList):
    global g_grabDataDict
    redPacketID, OSCanGrabCnt = msgList
    
    playerID= curPlayer.GetPlayerID()
    job = curPlayer.GetJob()
    jobRank = PlayerControl.GetJobRank(curPlayer)
    job = jobRank * 10 + job
    playerName = curPlayer.GetName()
    
    
    recDataList = __FindGrabRecData(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord, redPacketID)
    if not recDataList:
        GameWorld.Log('    δÕÒµ½¸ÃÏÉÃ˺ì°ü¼Ç¼redPacketID=%s'%redPacketID)
        return
    redPacketRecData = recDataList[0]
    state = redPacketRecData.GetValue4()
    if state in [State_NoSend]:
        GameWorld.DebugLog("    ¸ÃÏÉÃ˺ì°ü»¹Î´·¢ËÍ£¡",playerID)
        return
    familyID = redPacketRecData.GetValue2()
    if familyID:
        curFamily = curPlayer.GetFamily()
        if curFamily == None:
            return
    else:
        curFamily = None
    
    value3 = redPacketRecData.GetValue3()
    moneyType, totalMoney =value3%10, value3/10
    packetCnt = int(redPacketRecData.GetStrValue2())
    
    #ÕҸúì°üµÄÇÀÐÅÏ¢
    grabRecordDict = __GetGrabRecord(redPacketID)
    if playerID in grabRecordDict or len(grabRecordDict) >= packetCnt:
        GameWorld.DebugLog("    ¸ÃÍæ¼ÒÒÑÇÀ¹ý´Ëºì°ü£¡",playerID)
        __NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict)
        return
    
    outNum = sum([a[0] for a in grabRecordDict.values()]) #Òѱ»ÇÀµÄÇ®
    remainNum = totalMoney - outNum #Ê£ÓàµÄÇ®
    remainPacketCnt = packetCnt-len(grabRecordDict)
    if remainNum < remainPacketCnt:
        GameWorld.Log(' ¸Ãºì°üÊ£ÓàµÄÇ®²»¹»·¢ packetCnt =%s,totalMoney=%s,outNum=%s,remainMoney=%s,grabRecordDict=%s'%(packetCnt, totalMoney,outNum,remainNum, grabRecordDict))
        return
    strValue1 = redPacketRecData.GetStrValue1()
    strValue1List = strValue1.split('|')
    getWay = int(strValue1List[3])
    owerID = int(strValue1List[0])
    isSelf = owerID == playerID
    if getWay == IpyGameDataPY.GetFuncCfg('OpenServerRedPacketType'):
        #¿ª·þºì°üÐèÒªÅжϴÎÊý
        if not isSelf and OSCanGrabCnt <= 0:
            GameWorld.DebugLog('    ÇÀ¿ª·þºì°ü£¬´ÎÊý²»×㣡£¡')
            return
        getNumformula = IpyGameDataPY.GetFuncCompileCfg('OpenRedRacketOutNum')
    else:
        getNumformula = IpyGameDataPY.GetFuncCompileCfg('FamilyRedRacketOutNum')
    
    getMoney = eval(getNumformula) if remainPacketCnt > 1 else remainNum
    GameWorld.DebugLog("    ¸ÃÍæ¼ÒÇÀµ½ºì°ü=%s£¡"%getMoney, playerID)
    grabRecordDict[playerID] = [getMoney, playerName, job]
    #ÐÂÔöÒ»ÌõÇÀµÄ¼Ç¼
    recType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord
    valueList = [redPacketID, playerID, job, moneyType, getMoney]
    strValueList = [playerName]
    PlayerUniversalGameRec.MapServer_UniversalGameRec(None, recType, valueList, strValueList)
    #{playerid:[ÇÀµ½µÄÇ®,Ãû×Ö,job]}
    g_grabDataDict[redPacketID] = grabRecordDict
    
    if len(grabRecordDict) == packetCnt:
        redPacketRecData.SetValue4(State_HasAllGot)
        
        #֪ͨ¸ÃÍæ¼Òºì°üÇÀ½á¹û
        __NotifyFamilyRedPacketInfo(curFamily, redPacketRecData, grabRecordDict.keys())
    else:
        NotifyRedPacketInfo(curPlayer, [redPacketRecData, grabRecordDict.keys()])
        
    __NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict)
    
    #¸øÇ®
    result = str([moneyType, getMoney, getWay, isSelf])
    curPlayer.MapServer_QueryPlayerResult(0, 0, "GrabFamilyRedPacketResult", result, len(result))
    return getMoney

    
    
## »ñÈ¡ÇÀºì°ü¼Ç¼
def __GetGrabRecord(redPacketID):
    if redPacketID in g_grabDataDict:
        return g_grabDataDict[redPacketID]
    
    recDataList = __FindGrabRecData(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord, redPacketID)
    if not recDataList:
        return {}
    grabRecordDict = {}
    for recData in recDataList: #{playerid:[ÇÀµ½µÄÇ®,Ãû×Ö,job]}
        grabRecordDict[recData.GetValue2()] = [recData.GetValue5(), recData.GetStrValue1(), recData.GetValue3()]
    
    return grabRecordDict

def __FindGrabRecData(recordType, redPacketID):
    global g_allRecordDict
    if recordType == ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord:
        if redPacketID in g_allRecordDict:
            frecData = g_allRecordDict[redPacketID]
            if frecData:
                return [frecData]
            
    
    recDataList = []
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    allRecordList = universalRecMgr.GetTypeList(recordType)
    allCnt = allRecordList.Count()
    for index in xrange(allCnt):
        recData = allRecordList.At(index)
        if recData.GetValue1() == redPacketID:
            recDataList.append(recData)
            if recordType == ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord:
                g_allRecordDict[redPacketID] = recData
                break
    return recDataList

## ¼ì²éºì°üÊÇ·ñ¹ýÆÚ
def __CheckGrabRecData():
    global g_grabDataDict
    global g_allRecordDict
    global g_osRedCnt
    g_osRedCnt = 0
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    allRecordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
    allCnt = allRecordList.Count()
    curTimeNum = int(time.time())
    
    rangeTime = 24*60*60
    backMoneyDict = {}
    delRedPacketIDList = []
    familyIDList = []
    delCnt = 0
    for index in xrange(allCnt):
        dataIndex = index - delCnt
        universalRecData = allRecordList.At(dataIndex)
        saveTime = universalRecData.GetValue5()
        GameWorld.DebugLog("    ¼ì²éºì°üÊÇ·ñ¹ýÆÚ curTime=%s,saveTime=%s,rangeTime=%s,redPacketID=%s"%(curTimeNum, saveTime, curTimeNum -saveTime,universalRecData.GetValue1()))
        if curTimeNum -saveTime > rangeTime:#¹ýÆÚ
            redPacketID = universalRecData.GetValue1()
            
            strValue1 = universalRecData.GetStrValue1()
            strValue1List = strValue1.split('|')
            playerID = strValue1List[0]
            if playerID:
                playerID = int(playerID)
                grabRecordDict = __GetGrabRecord(redPacketID)
                outNum = sum([a[0] for a in grabRecordDict.values()]) #Òѱ»ÇÀµÄÇ®
                value3 = universalRecData.GetValue3()
                moneyType, totalMoney =value3%10, value3/10
                remainMoney = totalMoney - outNum #Ê£ÓàµÄÇ®
                #GameWorld.DebugLog('    outNum=%s,remainMoney=%s,moneyType=%s'%(outNum,remainMoney,moneyType))
                if moneyType ==1 and remainMoney:
                    backMoneyDict[playerID] = backMoneyDict.get(playerID, 0) + remainMoney
            
            delRedPacketIDList.append(redPacketID)
            familyID=universalRecData.GetValue2()
            if familyID not in familyIDList:
                familyIDList.append(familyID)
            
            allRecordList.Delete(dataIndex)
            delCnt +=1
            
    if not delRedPacketIDList:
        return
    for redID in delRedPacketIDList:
        g_grabDataDict.pop(redID, 0)
        g_allRecordDict.pop(redID, 0)
    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord
    recordList = universalRecMgr.GetTypeList(recordType)

    delCnt = 0
    for index in xrange(recordList.Count()):
        dataIndex = index - delCnt
        universalRecData = recordList.At(dataIndex)
        if universalRecData.GetValue1() in delRedPacketIDList:
            recordList.Delete(dataIndex)
            delCnt +=1
            

    NotifyDelRedPacketInfo(delRedPacketIDList)

        
    #·µ»ØÍæ¼Òδ±»ÁìÈ¡µÄÏÉÓñ
    if backMoneyDict:
        for playerID, moneyNum in backMoneyDict.items():
            PlayerCompensation.SendMailByKey('RedPackBack', [playerID], [], [], moneyNum)
    
    return
def DelRedPackByFamilyID(delfamilyID):
    global g_grabDataDict
    global g_allRecordDict
    #ɾ³ýij¸ö¼Ò×åµÄºì°ü¼Ç¼
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    allRecordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord)
    allCnt = allRecordList.Count()
    delRedPacketIDList = []
    delCnt = 0
    for index in xrange(allCnt):
        dataIndex = index - delCnt
        universalRecData = allRecordList.At(dataIndex)
        familyID=universalRecData.GetValue2()
        if delfamilyID != familyID:
            continue
        redPacketID = universalRecData.GetValue1()
        delRedPacketIDList.append(redPacketID)
        allRecordList.Delete(dataIndex)
        delCnt +=1
    if not delRedPacketIDList:
        return
    for redID in delRedPacketIDList:
        g_grabDataDict.pop(redID, 0)
        g_allRecordDict.pop(redID, 0)
    recordList = universalRecMgr.GetTypeList(ShareDefine.Def_UniversalGameRecType_FamilyRedPacketGrabRecord)
    delCnt = 0
    for index in xrange(recordList.Count()):
        dataIndex = index - delCnt
        universalRecData = recordList.At(dataIndex)
        if universalRecData.GetValue1() in delRedPacketIDList:
            recordList.Delete(dataIndex)
            delCnt +=1
    #NotifyDelRedPacketInfo(delRedPacketIDList)
    return

## ºì°ü±ä¸ü֪ͨµ¥¸öºì°ü¸ø¶ÔÓ¦Õ½ÃËËùÓгÉÔ±
def __NotifyFamilyRedPacketInfo(family, redPacketRecData, grabHeroIDList):
    syncPacketDataList = [redPacketRecData, grabHeroIDList]
#    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord
#    universalRecMgr = GameWorld.GetUniversalRecMgr()
#    recordList = universalRecMgr.GetTypeList(recordType)
#    for index in xrange(recordList.Count()):
#        recData = recordList.At(index)
#        familyID = recData.GetValue2()
#        if familyID and family and family.GetID() != familyID:
#            continue
#        if redPacketID:
#            if recData.GetValue1() == redPacketID:
#                syncPacketDataList = [recData, grabHeroIDList]
#                break
#        else:
#            syncPacketDataList.append(recData)
    if not syncPacketDataList:
        return
    playerManager = GameWorld.GetPlayerManager()
    if not family:
        for i in xrange(0, playerManager.GetActivePlayerCount()):
            curPlayer = playerManager.GetActivePlayerAt(i)
            if curPlayer == None or not curPlayer.GetInitOK():
                continue
            NotifyRedPacketInfo(curPlayer, syncPacketDataList)
    else:
        for i in xrange(0, family.GetCount()):
            notifyMember = family.GetAt(i)
            notifyPlayer = playerManager.FindPlayerByID(notifyMember.GetPlayerID())
            if notifyPlayer == None:
                continue
            NotifyRedPacketInfo(notifyPlayer, syncPacketDataList)
    return

## ֪ͨºì°üÐÅÏ¢
# ֪ͨÍæ¼Ò±¾Õ½ÃËËùÓкì°ü»òµ¥¸öºì°ü
def NotifyRedPacketInfo(curPlayer, packetDataList=[]):
    if PlayerControl.GetIsTJG(curPlayer):
        return
    if not packetDataList:
        syncPacketDataList = []
        recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord
        universalRecMgr = GameWorld.GetUniversalRecMgr()
        recordList = universalRecMgr.GetTypeList(recordType)
        for index in xrange(recordList.Count()):
            recData = recordList.At(index)
            familyID = recData.GetValue2()
            if familyID and curPlayer.GetFamilyID() != familyID:
                continue
            grabRecordDict = __GetGrabRecord(recData.GetValue1())
            syncPacketDataList.append([recData, grabRecordDict.keys()])
    else:
        syncPacketDataList = [packetDataList]
    if not syncPacketDataList:
        return
    joinFamilyTime = PlayerFamily.GetPlayerJoinFamilyTime(curPlayer)
    sendPack = ChPyNetSendPack.tagGCFamilyRedPacketInfo()
    sendPack.Clear()
    sendPack.IsAll = int(packetDataList==[])
    sendPack.RedPacketInfo = []
    
    for packetData, grabHeroIDList in syncPacketDataList:
        #ÏÉÃ˺ì°üֻ֪ͨÍæ¼Ò½øÈëÏÉÃ˺óÉú³ÉµÄºì°ü
        #GameWorld.Log('1111packetData.GetValue2()=%s,joinFamilyTime=%s,packetData.GetValue5()=%s'%(packetData.GetValue2(),joinFamilyTime,packetData.GetValue5()))
        if packetData.GetValue2() and joinFamilyTime and packetData.GetValue5() < joinFamilyTime:
            continue
        
        packetInfo = ChPyNetSendPack.tagFRedPacketInfo()
        packetInfo.Clear()
        packetInfo.RedPacketID = packetData.GetValue1()
        strValue1 = packetData.GetStrValue1()
        strValue1List = strValue1.split('|')
        if len(strValue1List) != 4:
            return
        playerID, playerName, job, getWay = strValue1List
        packetInfo.PlayerID = int(playerID)
        packetInfo.Name = playerName
        packetInfo.Time = packetData.GetTime()
        packetInfo.PlayeJob = int(job)
        value3 = packetData.GetValue3()
        packetInfo.MoneyType = value3 % 10
        packetInfo.MoneyNum = value3 / 10
        packetInfo.GetWay = int(getWay)
        state = packetData.GetValue4()

        if curPlayer.GetPlayerID() in grabHeroIDList:
            state = State_HasGot
        packetInfo.State = state
        packetInfo.PacketCnt = int(packetData.GetStrValue2())
        
        packetInfo.Wish = packetData.GetStrValue3()
        sendPack.RedPacketInfo.append(packetInfo)
    
    sendPack.Count = len(sendPack.RedPacketInfo)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    #GameWorld.Log('ÏÉÃ˺ì°ü֪ͨ IsAll=%s,Count=%s,syncPacketDataList=%s,redPacketID=%s'%(sendPack.IsAll,sendPack.Count,syncPacketDataList,redPacketID))
    return 


def __NotifyGrabRedPacketInfo(curPlayer, redPacketID, grabRecordDict):
    '''֪ͨÇÀºì°üÐÅÏ¢'''
    sendPack = ChPyNetSendPack.tagGCFamilyRedPacketGrabInfo()
    sendPack.Clear()
    sendPack.RedPacketID = redPacketID
    #grabRecordDict = __GetGrabRecord(redPacketID) #{playerid:[ÇÀµ½µÄÇ®,Ãû×Ö,job]}
    sendPack.Count = len(grabRecordDict)
    sendPack.GrabInfo = []
    for playerID, info in grabRecordDict.items():
        money, name, job = info
        grabInfo = ChPyNetSendPack.tagFGrabRedPacketInfo()
        grabInfo.Name = name
        grabInfo.PlayeJob = job
        grabInfo.MoneyNum = money
        sendPack.GrabInfo.append(grabInfo)
    NetPackCommon.SendFakePack(curPlayer, sendPack)
    return

def NotifyDelRedPacketInfo(delRedPacketIDList):
    ##֪ͨºì°üɾ³ýÐÅÏ¢
    sendPack = ChPyNetSendPack.tagGCRedPacketDel()
    sendPack.Clear()
    sendPack.DelRedPacketID = delRedPacketIDList
    sendPack.Cnt = len(delRedPacketIDList)
    playerManager = GameWorld.GetPlayerManager()
    for i in xrange(0, playerManager.GetActivePlayerCount()):
        curPlayer = playerManager.GetActivePlayerAt(i)
        if curPlayer == None or not curPlayer.GetInitOK():
            continue
        NetPackCommon.SendFakePack(curPlayer, sendPack)
    return