#!/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
import datetime

'''
ºì°üÔݶ¨ÓÐЧÆÚ24Сʱ£¬¹ýÌìÇå³ý¹ýÆڵĺì°ü£¬Èç¹ûÊÇÍæ¼Ò·¢·ÅµÄ·µ»¹Î´ÁìÈ¡µÄ»õ±Ò
ÉÏÏßͬ²½ËùÓкì°üÐÅÏ¢£¬ºì°ü±ä»¯ÊµÊ±¹ã²¥È«·þÔÚÏßÍæ¼Ò
'''
#Def_UniversalGameRecType_FamilyRedPacketAllRecord
#Time      ´´½¨ºì°üʱ¼ä£¬·Çºì°üʵ¼Ê¿ª·ÅÁìȡʱ¼ä£¬Èç¹ûºì°ü±íÓÐÅäÖÃϵͳ·¢·Åʱ¼ä£¬Ôò¸Ãʱ¼ä´æÅä±íʱ¼ä£¬Ã»ÓеĻ°´æ´´½¨Ê±µÄ·þÎñÆ÷ʱ¼ä
#value1    ºì°üΨһID£¬¸ÃIDΪʵÀýID£¬·ÇÅä±íµÄºì°üID
#value2    ¼Ò×åID£¬0´ú±íÈ«·þºì°ü
#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_redPackCountDict = {} #ÓÐÏÞÖÆ×î´óºì°ü¸öÊýµÄÀàÐͶÔÓ¦µ±Ç°ºì°üÊý {ÀàÐÍ×é¶ÔÓ¦¼Ç¼±àºÅ:µ±Ç°¸öÊý, ...}

DBKey_RedPacketSend = "RedPacketSend_%s" # ϵͳ¶¨Ê±ºì°üÊÇ·ñÒÑ·¢·Å£¬ ²ÎÊýºì°üID

## Íæ¼ÒµÇ¼
#  @param None
#  @return None
def OnPlayerLogin(curPlayer):
    NotifyRedPacketInfo(curPlayer)
    return


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

##---------------------------------------- ½ÚÈÕºì°ü -----------------------------------------------

def OnResetFeastRedPacket(ipyData, dayIndex):
    ## ÖØÖýÚÈÕºì°ü״̬
    
    if not ipyData:
        return
    
    dayRedPackIDList = ipyData.GetRedPacketIDList()
    GameWorld.Log("ÖØÖýÚÈÕºì°ü·¢·Å״̬: dayRedPackIDList=%s, dayIndex=%s" % (dayRedPackIDList, dayIndex))
    if dayIndex < 0 or dayIndex >= len(dayRedPackIDList):
        GameWorld.ErrLog("µ±Ç°½ÚÈÕÌìË÷ÒýûÓÐÅäÅäÖÃϵͳºì°üID! dayRedPackIDList=%s, dayIndex=%s" % (dayRedPackIDList, dayIndex))
        return
    
    for redPackID in dayRedPackIDList[dayIndex]:
        GameWorld.Log("    ÖØÖýÚÈÕºì°ü·¢·Å״̬: redPackID=%s" % redPackID)
        if PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID):
            PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID, 0)
            
    return

def __GetTodayRedPacketByTimeList():
    key = "TodayRedPacketByTime"
    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
    TodayRedPacketByTimeInfo = IpyGameDataPY.GetConfigEx(key)
    if TodayRedPacketByTimeInfo and TodayRedPacketByTimeInfo[0] == openServerDay:
        #GameWorld.DebugLog("ÒѾ­¼ÓÔعý±¾ÈÕϵͳ¶¨Ê±·¢·ÅµÄºì°ü! openServerDay=%s" % openServerDay)
        return TodayRedPacketByTimeInfo[1]
    
    redPacketByTimeList = []
    serverTime = GameWorld.GetServerTime()
    
    GameWorld.Log("===== ¼ÓÔؽñÌìϵͳ¶¨Ê±·¢·Åºì°üÐÅÏ¢ ===== openServerDay=%s" % openServerDay)
    
    ipyDataMgr = IpyGameDataPY.IPY_Data()
    for index in xrange(ipyDataMgr.GetFamilyRedPackCount()):
        ipyData = ipyDataMgr.GetFamilyRedPackByIndex(index)
        redPackID = ipyData.GetID()
        openTimeStr = ipyData.GetPacketOpenTime()
        if not openTimeStr:
            #GameWorld.DebugLog("·Ç¶¨Ê±·¢·ÅµÄºì°ü!redPackID=%s" % (redPackID))
            continue
        
        openDateTime = datetime.datetime.strptime("%s:00" % openTimeStr, ChConfig.TYPE_Time_Format)
        if openDateTime.year != serverTime.year or openDateTime.month != serverTime.month or openDateTime.day != serverTime.day:
            #GameWorld.DebugLog("·Ç½ñÈÕ¶¨Ê±·¢·ÅµÄºì°ü!redPackID=%s" % (redPackID))
            continue
        
        endDateTime = None
        validMinutes = ipyData.GetValidMinutes()
        if validMinutes:
            endDateTime = openDateTime +  + datetime.timedelta(minutes=validMinutes)
            
        redPacketByTimeList.append([redPackID, openDateTime, endDateTime])
        
        GameWorld.Log("    Ôö¼Ó±¾ÈÕ¶¨Ê±·¢·Åϵͳºì°üÐÅÏ¢: redPackID=%s, %s" % (redPackID, openTimeStr))
        
    TodayRedPacketByTimeInfo = IpyGameDataPY.SetConfigEx(key, [openServerDay, redPacketByTimeList])
    GameWorld.Log("±¾ÈÕϵͳ¶¨Ê±·¢·ÅµÄºì°ü¼ÓÔØÍê±Ï!")
    GameWorld.Log("=============================================================")
    return TodayRedPacketByTimeInfo[1]

def OnRedPacketMinuteProcess():
    ## ÿ·ÖÖÓ´¦Àí£¬¶¨Ê±·¢·Åϵͳºì°ü
    
    todayRedPacketByTimeList = __GetTodayRedPacketByTimeList()
    if not todayRedPacketByTimeList:
        return
    
    serverTime = GameWorld.GetServerTime()
    
    for redPacketOpenInfo in todayRedPacketByTimeList:
        redPackID, openDateTime, endDateTime = redPacketOpenInfo
        
        if serverTime < openDateTime or (endDateTime and serverTime >= endDateTime):
            #GameWorld.DebugLog("·Çºì°ü·¢·Åʱ¶Î!  redPackID=%s, openDateTime=%s, endDateTime=%s" % (redPackID, openDateTime, endDateTime))
            continue
        
        if PlayerDBGSEvent.GetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID):
            #GameWorld.DebugLog("ºì°üÒÑ·¢·Å¹ý! redPackID=%s" % (redPackID))
            continue
        CreateSystemRedPacket(redPackID)
        
    return

def Sync_FeastRedPacket(ipyData, curPlayer=None):
    ## ͬ²½½ÚÈÕºì°ü»î¶¯ÐÅÏ¢
    
    if not ipyData:
        return
    
    openServerDay = PlayerDBGSEvent.GetDBGSTrig_ByKey(PlayerDBGSEvent.Def_ServerDay) + 1
    feastPack = ChPyNetSendPack.tagGCFeastRedPacketInfo()
    feastPack.StartDate = GameWorld.GetOperationActionDateStr(ipyData.GetStartDate(), openServerDay)
    feastPack.EndtDate = GameWorld.GetOperationActionDateStr(ipyData.GetEndDate(), openServerDay)
    feastPack.LimitLV = ipyData.GetLVLimit()
    feastPack.ResetType = ipyData.GetResetType()
    feastPack.RedPacketDayList = []
    for redPacketIDList in ipyData.GetRedPacketIDList():
        dayInfo = ChPyNetSendPack.tagGCFeastRedPacketDay()
        dayInfo.RedPacketIDList = redPacketIDList
        dayInfo.RedPacketCount = len(dayInfo.RedPacketIDList)
        feastPack.RedPacketDayList.append(dayInfo)
    feastPack.RedPacketDays = len(feastPack.RedPacketDayList)
    
    if not curPlayer:
        # È«·þ¹ã²¥ÔÚÏßÍæ¼Ò
        playerManager = GameWorld.GetPlayerManager()
        for i in xrange(playerManager.GetActivePlayerCount()):
            curPlayer = playerManager.GetActivePlayerAt(i)
            if curPlayer == None or not curPlayer.GetInitOK():
                continue
            NetPackCommon.SendFakePack(curPlayer, feastPack)
    else:
        NetPackCommon.SendFakePack(curPlayer, feastPack)
    return

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

def CreateSystemRedPacket(redPackID):
    ## ·¢·Åϵͳºì°ü
    ipyData = IpyGameDataPY.GetIpyGameData('FamilyRedPack', redPackID)
    if not ipyData:
        return
    getType = ipyData.GetGetType()
    moneyType = ipyData.GetMoneyType()
    outputNum = ipyData.GetMoneyNum()
    packetCnt = ipyData.GetPacketCnt()
    openTime = ipyData.GetPacketOpenTime() # Èç¹ûÓÐÖ¸¶¨·¢·Åʱ¼äµÄ
    sysCreateTime = GameWorld.ChangeTimeStrToNum("%s:00" % openTime) if openTime else None
    
    state = State_NoGot # ÔÝÖ±½ÓÉ趨ÒÑ·¢·Å
    if ipyData.GetPacketOpenTime():
        PlayerDBGSEvent.SetDBGSTrig_ByKey(DBKey_RedPacketSend % redPackID, 1)
        GameWorld.DebugLog("¶¨Ê±·¢·ÅµÄºì°ü£¬ÉèÖÃÒÑ·¢·Å! redPackID=%s" % redPackID)
        
    job = 0
    jobRank = 0
    playerName = ""
    playerID = 0
    family = None
    
    __SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, sysCreateTime=sysCreateTime)
    return

## Éú³Éкì°ü
def MapServer_CreatRedPacket(msgList):
    playerID, getType, packetCnt, moneyType, outputNum, wishStr, state, data, isFamilyRedPacket = msgList
    curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
    if not curPlayer:
        return
    if not isFamilyRedPacket:
        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 = 0
    playerName = curPlayer.GetName()
    __SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt, state, wishStr, data=data)
    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()
    
    __SaveNewRedRecord(family, playerID, playerName, job, jobRank, getType, moneyType, outputNum, 0)
    return

## ¼Ç¼Ðºì°üÊý¾Ý
def __SaveNewRedRecord(family, ownerid, playerName, job, jobRank, getType, moneyType, outputNum, packetCnt,state=State_NoSend, wishStr='', sysCreateTime=None, data=0):
    global g_allRecordDict
    global g_redPackCountDict
    recordType = ShareDefine.Def_UniversalGameRecType_FamilyRedPacketAllRecord
    universalRecMgr = GameWorld.GetUniversalRecMgr()
    recordList = universalRecMgr.GetTypeList(recordType)
    for maxCountKeyNum, getTypeList in ShareDefine.RedPackMaxCountDict.items():
        if getType in getTypeList:
            if not __CheckOSRedPacketCnt(recordList, maxCountKeyNum, getTypeList):
                return
            g_redPackCountDict[maxCountKeyNum] = g_redPackCountDict.get(maxCountKeyNum, 0) + 1
            GameWorld.DebugLog("µ±Ç°ºì°üÊý: g_redPackCountDict=%s" % g_redPackCountDict)
            break
        
    familyID = family.GetID() if family else 0
    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(sysCreateTime if sysCreateTime else 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))
    
    #֪ͨ
    __NotifyFamilyRedPacketInfo(family, recData, [])
    if getType == ShareDefine.RedPackType_OpenServer:
        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])
            
    if not familyID:
        #´óÓÚ200¶î¶ÈµÄºì°ü
        getTypeRainDict = IpyGameDataPY.GetFuncEvalCfg('OpenServerRedPacketRain', 2, {})
        if str(getType) in getTypeRainDict:
            PlayerControl.WorldNotify(0, getTypeRainDict[str(getType)])  
        elif outputNum >= IpyGameDataPY.GetFuncCfg('OpenServerRedPacketRain'):
            PlayerControl.WorldNotify(0, 'OSRedpackSfx', [getType])   
            
    return recData


def __CheckOSRedPacketCnt(recordList, maxCountKeyNum, getTypeList):
    global g_grabDataDict
    global g_allRecordDict
    global g_redPackCountDict
    ##¿ª·þºì°ü¸öÊýÊÇ·ñ´ïÉÏÏÞ
    curRedCnt = g_redPackCountDict.get(maxCountKeyNum, 0)
    openServerRedPacketCnt = IpyGameDataPY.GetFuncCfg('OpenServerRedPacketCnt', 1) # Ö±½ÓÓÿª·þºì°üÕâ¸öÅäÖÃ×÷ΪͨÓÃÅäÖÃ
    if curRedCnt and curRedCnt < openServerRedPacketCnt + 10:
        return True
    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 not in getTypeList:
            continue
        redPacketID = universalRecData.GetValue1()
        curCnt += 1
        if len(delRedPacketIDList) < 10:
            delRedPacketIDList.append(redPacketID)
        elif curRedCnt:
            break
    if not delRedPacketIDList:
        return True
    if not curRedCnt:
        curRedCnt = curCnt

    if curRedCnt < 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)
    curRedCnt -= 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, reqGetWay, canGrabCnt = msgList
    
    playerID= curPlayer.GetPlayerID()
    job = curPlayer.GetJob()
    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 not isSelf and canGrabCnt != -1 and canGrabCnt <= 0:
        GameWorld.DebugLog('    ÇÀ¿ª·þºì°ü£¬´ÎÊý²»×㣡£¡')
        return
    if reqGetWay != getWay:
        GameWorld.ErrLog("ÁìÈ¡µÄºì°üÀàÐͲ»Ò»Ö£¬ÎÞ·¨ÁìÈ¡! reqGetWay=%s,getWay=%s" % (reqGetWay, getWay))
        return
    if getWay == ShareDefine.RedPackType_OpenServer:
        getNumformula = IpyGameDataPY.GetFuncCompileCfg('OpenRedRacketOutNum')
    elif getWay in ShareDefine.FeastRedPackType:
        getNumformula = IpyGameDataPY.GetFuncCompileCfg('FeastRedPacket', 2)
    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_redPackCountDict
    g_redPackCountDict = {}
    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