#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerSuccess
#
# @todo:³É¾Íϵͳ
# @author hxp
# @date 2025-10-17
# @version 1.0
#
# ÏêϸÃèÊö: ³É¾Íϵͳ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-10-17 21:00"""
#-------------------------------------------------------------------------------

import ChConfig
import GameWorld
import ShareDefine
import NetPackCommon
import PlayerControl
import ChPyNetSendPack
import ItemControler
import IpyGameDataPY
import PyGameData
import ObjPool

#³É¾Í½±ÀøÊÇ·ñÒÑÁìÈ¡
def GetSuccHasGot(curPlayer, succID):
    return GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_SuccessAward, succID)
def SetSuccHasGot(curPlayer, succID, hasGot=True):
    GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_SuccessAward, succID, hasGot)
    return 
    
#³É¾ÍÍê³É½ø¶È
def GetSuccValue(curPlayer, succType, conds):
    condition = "" if not conds else str(list(conds)).replace(" ", "")[1:-1]
    return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_SuccessValue % (succType, condition))
def SetSuccValue(curPlayer, succType, conds, value):
    condition = "" if not conds else str(list(conds)).replace(" ", "")[1:-1]
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_SuccessValue % (succType, condition), value)
    return

def SuccOnLogin(curPlayer):
    SyncSuccessInfo(curPlayer)
    SyncSuccessAwardRecord(curPlayer)
    return

def ResetSuccessByType(curPlayer, succType, ignoreFinish=True):
    #ÖØÖÃijÀàÐͳɾͽø¶È£¬Ò»°ãÓÃÓÚÏÈÖØÖôÎÊýÔÙÖØмÆÊý£¬»òÕ߻Àà
    ipyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("Success", succType)
    if not ipyDataList:
        return
    for ipyData in ipyDataList:
        succID = ipyData.GetSuccID()
        if ignoreFinish and GetSuccHasGot(curPlayer, succID):
            continue
        conds = ipyData.GetCondition()
        SetSuccValue(curPlayer, succType, conds, 0)
    return

#def UpdateSuccessProgressByConditions(curPlayer, successType, conditionCountDict):
#    ## ¸ù¾Ý¶àÖÖÌõ¼þ¸üнø¶È£¬Èç×°±¸¶àÆ·ÖʵÄ
#    ipyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("Success", successType)
#    if not ipyDataList:
#        return
#    updIDList = []
#    updsuccDataList = []
#    updConditionDict = {}
#    
#    for condition, newCount in conditionCountDict.items():
#        addCondList = [] # ²»Í¬µÄ³É¾ÍIDÌõ¼þ¿ÉÄÜÏàͬ£¬Ö»ÊÇ×î´ó½ø¶È²»Í¬£¬¹Ê´«ÈëµÄÌõ¼þ¼ÆÊýÕë¶ÔÏàͬ³É¾ÍÌõ¼þÖ»ÄÜÀÛ¼ÓÒ»´Î
#        for ipyData in ipyDataList:
#            succID = ipyData.GetSuccID()
#            conds = ipyData.GetCondition()
#            needCnt = ipyData.GetNeedCnt()
#            
#            tupleCond = tuple(conds) # ×÷Ϊ×ÖµäkeyÓÃ
#            
#            if tupleCond not in updConditionDict:
#                updConditionDict[tupleCond] = [conds, 0, 0] # [Ìõ¼þ, ¸üÐÂÖµ, ×î´ó½ø¶ÈÖµ]
#            updInfo = updConditionDict[tupleCond]
#            if updInfo[2] < needCnt:
#                updInfo[2] = needCnt
#                
#            if not __CheckCanAddSuccess(curPlayer, ipyData, list(condition)):
#                continue
#            
#            if succID not in updIDList:
#                updIDList.append(succID)
#                updsuccDataList.append(ipyData)
#                
#            if tupleCond not in addCondList:
#                addCondList.append(tupleCond)
#                updConditionDict[tupleCond][1] = updConditionDict[tupleCond][1] + newCount # ¸üнø¶ÈÖµ
#                
#    # ûÓÐÕÒµ½¸üÐÂÄ¿±ê²»´¦Àí
#    #GameWorld.DebugLog("    updConditionDict=%s" % updConditionDict)
#    #GameWorld.DebugLog("    updIDList=%s" % updIDList)
#    if not updIDList:
#        return
#    
#    # ÏȸüгɾͼǼֵºóÔÙÅжÏÍê³ÉÓë·ñ
#    for cond, updCnt, maxCnt in updConditionDict.values():
#        if not updCnt:
#            continue
#        updCnt = min(maxCnt, updCnt)
#        if GetSuccValue(curPlayer, successType, cond) == updCnt:
#            continue
#        SetSuccValue(curPlayer, successType, cond, updCnt)
#    SyncSuccessInfo(curPlayer, syncTypeCondList)
#    return

def UptateSuccessProgress(curPlayer, successType, newCnt, condition=[]):
    ipyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("Success", successType)
    if not ipyDataList:
        return
    
    curCnt = None
    for ipyData in ipyDataList:
        if not __CheckCanAddSuccess(curPlayer, ipyData, condition):
            continue
        curCnt = GetSuccValue(curPlayer, successType, ipyData.GetCondition())
        break
    
    if curCnt == None or newCnt <= curCnt:
        #GameWorld.DebugLog("²»ÐèÒª¸üгɾÍÖµ: curCnt=%s" % (curCnt))
        return
    #updateµÄÐèÒªÁ¢¼´¸üУ¡£¡
    DoAddSuccessProgress(curPlayer, successType, newCnt - curCnt, condition, False)
    return

def __CheckCanAddSuccess(curPlayer, ipyData, condition):
    ## ¼ì²é¿É·ñÌí¼Ó½ø¶È
    succID = ipyData.GetSuccID()
    # ÒÑÍê³ÉµÄ²»ÔÙ¼ì²é
    if GetSuccHasGot(curPlayer, succID):
        return
    
    successType = ipyData.GetSuccType()
    conds = ipyData.GetCondition()
    if not conds:
        # ÎÞÌõ¼þµÄĬÈÏ¿ÉÌí¼Ó
        return True
    
    if not condition:
        return
    
    # ´«½øÀ´µÄÌõ¼þÂú×ãÅäÖõÄÌõ¼þÁбíÖеÄÒ»¸ö¾ÍÐеijɾÍÀàÐÍ
    if successType in ShareDefine.ContainSuccessTypeList:
        if condition[0] not in conds:
            return
        
    # ´«½øÀ´µÄÌõ¼þÊÇÅäÖÃÌõ¼þµÄÕûÊý±¶µÄ³É¾ÍÀàÐÍ
    elif successType in ShareDefine.MultipleSuccessTypeList:
        if not (condition[0] / conds[0] and condition[0] % conds[0] == 0):
            #±ØÐëÊÇÌõ¼þµÄ±¶Êý
            return
        
    else:
        if len(conds) != len(condition):
            return
        # ²»Ïòϼì²éÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµµÈÓÚ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
        if successType in ShareDefine.UnDownCheckSuccessTypeList:
            if conds != condition:
                return
        # ¿ÉÏòÏÂÔö¼Ó½ø¶ÈµÄ, ½öÅäÖÃÖµ <= ¸ÃÖµµÄ¿ÉÔö¼Ó½ø¶È
        else:
            isbreak = False
            undowncheckIndexList = [] # ²»Ïòϼì²éµÄÌõ¼þË÷Òý
            if successType in ShareDefine.PartUnDownCheckSuccessTypeInfo:
                undowncheckIndexList = ShareDefine.PartUnDownCheckSuccessTypeInfo[successType]
            for i, num in enumerate(conds):
                if i in undowncheckIndexList:
                    if num != condition[i]:
                        isbreak = True
                        break
                if num > condition[i]:
                    isbreak = True
                    break
            if isbreak:
                return
            
    return True

def FinishDelayAddSuccessProgress(curPlayer, tick, isFinish=True):
    # ½«¹¥»÷ÀàµÄ³É¾ÍÒ»´ÎÖ´ÐУ¬¼õÉÙÔËÐÐÁ¿

    if not isFinish:
        # ¶þ´ÎÑÓ³Ù´¦Àí
        if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_Success) \
           < ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_Success]:
            return
        
        curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_Success, tick) 
    
    playerID = curPlayer.GetID()
    if playerID not in PyGameData.g_delaySuccessDict:
        return
    
    successDict = PyGameData.g_delaySuccessDict.pop(playerID)
    for sucessInfo, cnt in successDict.items():
        DoAddSuccessProgress(curPlayer, sucessInfo[0], cnt, list(sucessInfo[1]), False)
        
    return

def DoAddSuccessProgress(curPlayer, successType, addCnt, condition=[], delayCalc=True):
    if GameWorld.IsCrossServer():
        return
    
    playerID = curPlayer.GetID()
    if delayCalc:
        if playerID not in PyGameData.g_delaySuccessDict:
            PyGameData.g_delaySuccessDict[playerID] = {}
        # ×îÖÕ´¦Àí¼õÉÙ¼ÆËãÁ¿£¬¶Ìʱ¼ä¶à´ÎÀÛ¼Ó»ã×ÜÒ»´Î¼ÆËã
        successTuple = (successType, tuple(condition))
        if successTuple not in PyGameData.g_delaySuccessDict[playerID]:
            PyGameData.g_delaySuccessDict[playerID][successTuple] = addCnt
        else:
            PyGameData.g_delaySuccessDict[playerID][successTuple] = PyGameData.g_delaySuccessDict[playerID][successTuple] + addCnt
        return
    
    if condition and type(condition) != type([]):
        GameWorld.ErrLog('DoAddSuccessProgress type=%s, condition=%s ´íÎó£¡' % (type, condition))
        return
    if successType not in ShareDefine.SuccessTypeList:
        return
    
    ipyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("Success", successType)
    if not ipyDataList:
        GameWorld.DebugLog("ÕÒ²»µ½³É¾ÍÊý¾ÝsuccessType=%s" % successType)
        return
    
    maxCnt = 0 # ±¾´Î¿ÉÒÔ¸üе½µÄ×î´óÖµ
    updConditionList = [] # Ðè¸üнø¶ÈÖµµÄkey±àºÅÁбí
    for ipyData in ipyDataList:
        
        if not __CheckCanAddSuccess(curPlayer, ipyData, condition):
            continue
        
        conds = ipyData.GetCondition()
        if conds not in updConditionList:
            updConditionList.append(conds)
            
        needCnt = ipyData.GetNeedCnt()
        if maxCnt < needCnt:
            maxCnt = needCnt
            
    # ûÓÐÕÒµ½¸üÐÂÄ¿±ê²»´¦Àí
    if not updConditionList or maxCnt <= 0:
        return
    
    syncTypeCondList = []
    for conds in updConditionList:
        curCnt = GetSuccValue(curPlayer, successType, conds)
        updCnt = min(maxCnt, curCnt + addCnt)
        SetSuccValue(curPlayer, successType, conds, updCnt)
        syncTypeCondList.append([successType, conds])
    SyncSuccessInfo(curPlayer, syncTypeCondList)
    return

def GetSuccessAward(curPlayer, succID):
    ipyData = IpyGameDataPY.GetIpyGameDataByCondition("Success", {"SuccID":succID})
    if not ipyData:
        return
    
    if GetSuccHasGot(curPlayer, succID):
        GameWorld.DebugLog("¸Ã³É¾Í½±ÀøÒѾ­ÁìÈ¡¹ý! succID=%s" % succID)
        return
    
    succType = ipyData.GetSuccType()
    conds = ipyData.GetCondition()
    needCnt = ipyData.GetNeedCnt()
    curValue = GetSuccValue(curPlayer, succType, conds)
    if curValue < needCnt:
        GameWorld.DebugLog("¸Ã³É¾ÍδÍê³É! succID=%s,curValue=%s < %s" % (succID, curValue, needCnt))
        return
    
    SetSuccHasGot(curPlayer, succID)
    SyncSuccessAwardRecord(curPlayer, [succID], True)
    
    awardItemList = ipyData.GetAwardItemList()
    if awardItemList:
        ItemControler.GivePlayerItemOrMail(curPlayer, awardItemList, event=["SuccessAward", False, {}])
    return

def SyncSuccessInfo(curPlayer, syncTypeCondList=None, isSendZero=False):
    if not syncTypeCondList:
        syncTypeCondList = []
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        for index in range(ipyDataMgr.GetSuccessCount()):
            ipyData = ipyDataMgr.GetSuccessByIndex(index)
            # ÒÑÁìÈ¡µÄ²»·¢ 
            if GetSuccHasGot(curPlayer, ipyData.GetSuccID()):
                continue
            succType = ipyData.GetSuccType()
            conds = ipyData.GetCondition()
            tcList = [succType, conds]
            if tcList in syncTypeCondList:
                continue
            syncTypeCondList.append(tcList)
            
    successInfoList = []
    objPoolMgr = ObjPool.GetPoolMgr()
    for succType, conds in syncTypeCondList:
        curValue = GetSuccValue(curPlayer, succType, conds)
        # ²»·¢ËÍΪ0µÄÊý¾Ý
        if not isSendZero and curValue <= 0:
            continue
        succInfo = objPoolMgr.acquire(ChPyNetSendPack.tagSCSuccessInfo)
        succInfo.SuccType = succType
        succInfo.Conds = conds
        succInfo.CLen = len(succInfo.Conds)
        succInfo.CurValue = curValue
        successInfoList.append(succInfo)
        
    if not successInfoList:
        return
    
    clientPack = objPoolMgr.acquire(ChPyNetSendPack.tagSCSuccessInfoList)
    clientPack.SuccessInfoList = successInfoList
    clientPack.Count = len(clientPack.SuccessInfoList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def SyncSuccessAwardRecord(curPlayer, succIDList=[], isSyncZero=False):
    ## ֪ͨ³É¾Í¶ÔÓ¦½±ÀøÁì½±¼Ç¼
    if succIDList:
        recordIndexList = []
        for succID in succIDList:
            recordIndex = succID / 31
            if recordIndex not in recordIndexList:
                recordIndexList.append(recordIndex)
    else:
        ipyDataMgr = IpyGameDataPY.IPY_Data()
        succCnt = ipyDataMgr.GetSuccessCount()
        if not succCnt:
            return
        maxSuccID = ipyDataMgr.GetSuccessByIndex(succCnt - 1).GetSuccID()
        recordIndexList = xrange(maxSuccID / 31 + 1)
        
    objPoolMgr = ObjPool.GetPoolMgr()
    recordList = []
    for i in recordIndexList:
        awardRecord = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_SuccessAward % i)
        if not isSyncZero and not awardRecord:
            continue
        recordInfo = objPoolMgr.acquire(ChPyNetSendPack.tagSCSuccessAwardRecord)
        recordInfo.RecordIndex = i
        recordInfo.Record = awardRecord
        recordList.append(recordInfo)
        
    if not recordList:
        return
    
    clientPack = objPoolMgr.acquire(ChPyNetSendPack.tagSCSuccessAwardRecordList)
    clientPack.RecordList = recordList
    clientPack.RecordCnt = len(clientPack.RecordList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return