#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerActGarbageSorting
#
# @todo:À¬»ø·ÖÀà»î¶¯
# @author hxp
# @date 2021-05-13
# @version 1.0
#
# ÏêϸÃèÊö: À¬»ø·ÖÀà»î¶¯
#
#-------------------------------------------------------------------------------
#"""Version = 2021-05-13 19:30"""
#-------------------------------------------------------------------------------

import PyGameData
import ShareDefine
import PlayerControl
import IpyGameDataPY
import ItemControler
import ChPyNetSendPack
import NetPackCommon
import GameWorld
import ChConfig
import ItemCommon
import PlayerBillboard

def OnPlayerLogin(curPlayer):
    
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        isReset = __CheckPlayerGarbageSortingAction(curPlayer, actNum)
        if not isReset:
            # »î¶¯ÖÐͬ²½»î¶¯ÐÅÏ¢
            if actInfo.get(ShareDefine.ActKey_State):
                Sync_GarbageSortingActionInfo(curPlayer, actNum)
                Sync_GarbageTaskInfo(curPlayer, actNum)
    return

def RefreshGarbageSortingActionInfo(actNum):
    ## ÊÕµ½GameServerͬ²½µÄ»î¶¯ÐÅÏ¢£¬Ë¢Ð»ÐÅÏ¢
    playerManager = GameWorld.GetPlayerManager()
    for index in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(index)
        if not GameWorld.IsNormalPlayer(curPlayer):
            continue
        __CheckPlayerGarbageSortingAction(curPlayer, actNum)
    return

def __CheckPlayerGarbageSortingAction(curPlayer, actNum):
    ## ¼ì²éÍæ¼Ò»î¶¯Êý¾ÝÐÅÏ¢
    
    playerID = curPlayer.GetPlayerID()
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
    actID = actInfo.get(ShareDefine.ActKey_ID, 0)
    state = actInfo.get(ShareDefine.ActKey_State, 0)
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
    
    playerActID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageSortingID % actNum) # Íæ¼ÒÉíÉϵĻID
    
    # »î¶¯ID ÏàͬµÄ»°²»´¦Àí
    if actID == playerActID:
        GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ID²»±ä£¬²»´¦Àí£¡actNum=%s,actID=%s" % (actNum, actID), playerID)
        return
    
    actWorldLV = actInfo.get(ShareDefine.ActKey_WorldLV, 0)
    
    GameWorld.DebugLog("À¬»ø·ÖÀàÖØÖÃ! actNum=%s,actID=%s,playerActID=%s,state=%s,cfgID=%s" 
                       % (actNum, actID, playerActID, state, cfgID), playerID)
    
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageSortingID % actNum, actID)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageSortingWorldLV % actNum, actWorldLV)
    for taskID in ChConfig.GarbageTaskList:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID), 0)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID), 0)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValue % actNum, 0)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageGJSeconds % actNum, 0)
    
    # Çå³ýÀ¬»ø±³°üÎïÆ·¡¢ÖØÖû·±£Öµ
    ItemControler.ClearPack(curPlayer, ShareDefine.rptGarbage)
    PlayerControl.SetPlayerCurrency(curPlayer, ShareDefine.TYPE_Price_Environment, 0)
    
    Sync_GarbageSortingActionInfo(curPlayer, actNum)
    Sync_GarbageTaskInfo(curPlayer, actNum)
    return True

def AddActGarbageTaskProgress(curPlayer, taskID, addValue=1, valueInfo=None, isTJG=False):
    ## Ôö¼ÓÀ¬»øÊÕ¼¯ÈÎÎñ½ø¶È
    # @param valueInfo: taskID ¶ÔÓ¦µÄ×Ô¶¨ÒåÀ©Õ¹ÐÅÏ¢Öµ
    if addValue <= 0:
        return
    
    giveGarbageItemList = []
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        if not actInfo.get(ShareDefine.ActKey_State):
            #GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯Î´¿ªÆô! actNum=%s" % actNum)
            continue
        
        if taskID == ChConfig.Def_GarbageTask_CTG:
            cfgID = actInfo.get(ShareDefine.ActKey_CfgID, 0)
            if not cfgID:
                continue
            
            ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
            if not ipyData:
                continue
            
            coinType = valueInfo
            ctgTypeEffValue = ipyData.GetCTGTypeEffValue()
            if not ctgTypeEffValue & pow(2, coinType):
                #GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯³äÖµÀàÐͶԸûÎÞЧ! actNum=%s,coinType=%s,ctgTypeEffValue=%s" 
                #                   % (actNum, coinType, ctgTypeEffValue), curPlayer.GetPlayerID())
                continue
            
        taskIpyData = IpyGameDataPY.GetIpyGameData("ActGarbageTask", taskID)
        if not taskIpyData:
            continue
        maxFinishCount = taskIpyData.GetFinishTimeMax()
        maxValue = ChConfig.Def_UpperLimit_DWord
        if maxFinishCount:
            maxValue = min(maxValue, taskIpyData.GetFinishNeedValue() * maxFinishCount)
            
        curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
        updValue = min(curValue + addValue, maxValue)
        if curValue >= maxValue:
            #GameWorld.DebugLog("¸ÃÀ¬»ø·ÖÀà»î¶¯ÈÎÎñÒÑ´ïµ½×î´ó½ø¶ÈÖµ!actNum=%s,taskID=%s,curValue(%s) >= maxValue(%s)" 
            #                   % (actNum, taskID, curValue, maxValue))
            continue
        
        #GameWorld.DebugLog("Ôö¼ÓÀ¬»ø·ÖÀà»î¶¯ÈÎÎñ½ø¶È: actNum=%s,taskID=%s,curValue=%s,addValue=%s,updValue=%s" 
        #                   % (actNum, taskID, curValue, addValue, updValue))
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID), updValue)
        
        # Íê³Éʱ×Ô¶¯²úÉúÀ¬»ø
        if taskIpyData.GetAutoProduce():
            giveItemList = __DoCheckFinishGarbageTask(curPlayer, actNum, taskID, taskIpyData, isTJG)
            if giveItemList:
                giveGarbageItemList += giveItemList
                continue
            
        Sync_GarbageTaskInfo(curPlayer, actNum, taskID)
        
    return giveGarbageItemList

def __DoCheckFinishGarbageTask(curPlayer, actNum, taskID, taskIpyData=None, isTJG=False):
    ## ¼ì²éÍê³ÉÀ¬»øÊÕ¼¯ÈÎÎñ
    
    if not taskIpyData:
        taskIpyData = IpyGameDataPY.GetIpyGameData("ActGarbageTask", taskID)
    if not taskIpyData:
        return
    curFinishCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID))
    maxFinishCount = taskIpyData.GetFinishTimeMax()
    if maxFinishCount and curFinishCount >= maxFinishCount:
        GameWorld.DebugLog("¸ÃÀ¬»ø·ÖÀà»î¶¯ÈÎÎñÒÑ´ïµ½×î´óÍê³É´ÎÊý!actNum=%s,taskID=%s,curFinishCount=%s" % (actNum, taskID, curFinishCount))
        return
    
    curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
    updFinishCount = curValue / taskIpyData.GetFinishNeedValue()
    if maxFinishCount:
        updFinishCount = min(maxFinishCount, updFinishCount)
    addFinishCount = updFinishCount - curFinishCount
    if addFinishCount <= 0:
        #GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ÈÎÎñδÍê³É£¬ÎÞ·¨ÁìÈ¡!actNum=%s,taskID=%s,curValue=%s,curFinishCount=%s,updFinishCount=%s" 
        #                   % (actNum, taskID, curValue, curFinishCount, updFinishCount))
        return
    
    # ¸øÀ¬»øÊÕ¼¯½±Àø
    giveItemDict = {}
    rateList = taskIpyData.GetProduceGarbageRateList()
    for _ in xrange(addFinishCount):
        itemInfo = GameWorld.GetResultByRandomList(rateList)
        if not itemInfo:
            continue
        itemID, itemCount, isAuctionItem = itemInfo
        befItemCount = giveItemDict[itemID][1] if itemID in giveItemDict else 0
        giveItemDict[itemID] = [itemID, befItemCount + itemCount, isAuctionItem]
    giveItemList = giveItemDict.values()
    
    if not giveItemList:
        return
    
    #´Ë¹¦ÄÜÔݲ»ÑéÖ¤±³°ü
    #if not ItemControler.CheckPackSpaceEnough(curPlayer, giveItemList):
    #    return
    
    #GameWorld.DebugLog("À¬»ø·ÖÀà»î¶¯ÈÎÎñÍê³É£¬¸ø½±Àø! actNum=%s,taskID=%s,curValue=%s,curFinishCount=%s,addFinishCount=%s,updFinishCount=%s" 
    #                   % (actNum, taskID, curValue, curFinishCount, addFinishCount, updFinishCount))
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID), updFinishCount)
    
    if not isTJG:
        for itemID, itemCnt, isAuctionItem in giveItemList:
            ItemControler.GivePlayerItem(curPlayer, itemID, itemCnt, isAuctionItem, [])
            
    Sync_GarbageTaskInfo(curPlayer, actNum, taskID)
    return giveItemList

def OnGetGuajiAwardItemDict(curPlayer, awardSeconds, useUnsecond):
    ## »ñÈ¡¹Ò»úÊÕÒæ
        
    dropItemCountDict = {}
    guajiAwardSet = IpyGameDataPY.GetFuncEvalCfg("GarbageSorting", 3) # ¹Ò»úÊÕÒæÉèÖà xÃë|x´ÎÖ´ÐÐÊýÖµ4
    if not guajiAwardSet:
        return dropItemCountDict
    doSeconds, doCount = guajiAwardSet
    
    dropRateList = IpyGameDataPY.GetFuncEvalCfg("GarbageSorting", 4) # ¹Ò»úÊÕÒæ¸ÅÂʱýͼ [[¸ÅÂÊ, [ÎïÆ·ID,¸öÊý,ÊÇ·ñÅÄÆ·]], ...]
    
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_GarbageSorting, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        
        if not actInfo.get(ShareDefine.ActKey_State):
            continue
        
        if useUnsecond:
            unSeconds = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageGJSeconds % (actNum))
            awardSeconds += unSeconds
            
            canDoCount = awardSeconds / doSeconds
            killCount = canDoCount * doCount
            
            updUnSeconds = awardSeconds % doSeconds
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageGJSeconds % (actNum), updUnSeconds)
            GameWorld.DebugLog("    ¹Ò»úÀ¬»ø·ÖÀà: actNum=%s,awardSeconds=%s,canDoCount=%s,killCount=%s,unSeconds=%s,updUnSeconds=%s" 
                               % (actNum, awardSeconds, canDoCount, killCount, unSeconds, updUnSeconds))
        else:
            canDoCount = awardSeconds / doSeconds
            killCount = canDoCount * doCount
            GameWorld.DebugLog("    ¹Ò»úÀ¬»ø·ÖÀà: actNum=%s,awardSeconds=%s,canDoCount=%s,killCount=%s" 
                               % (actNum, awardSeconds, canDoCount, killCount))
        if killCount <= 0:
            continue
        
        preRate = 0
        maxRate = dropRateList[-1][0]
        for rateInfo in dropRateList:
            rate, dropItemInfo = rateInfo
            curRate = rate - preRate
            if not curRate:
                break
            preRate = rate
            if not dropItemInfo:
                continue
            totalRate = curRate * killCount # ×ܸÅÂÊ
            dropCount = totalRate / maxRate # ¿ÉµôÂäÊý
            rateEx = totalRate % maxRate # Ê£Óà¸ÅÂÊ
            if GameWorld.CanHappen(rateEx, maxRate):
                dropCount += 1
            if not dropCount:
                continue
            dropItemID, itemCount, _ = dropItemInfo
            dropItemCount = itemCount * dropCount
            
            dropItemCountDict[dropItemID] = dropItemCountDict.get(dropItemID, 0) + dropItemCount
            GameWorld.DebugLog("    ¹Ò»úÀ¬»ø·ÖÀà²ú³ö: actNum=%s,dropItemID=%s,dropCount=%s,dropItemCount=%s,curRate=%s,totalRate=%s" 
                               % (actNum, dropItemID, dropCount, dropItemCount, curRate, totalRate))
            
    return dropItemCountDict

#// AA 14 À¬»ø·ÖÀà»î¶¯·ÖÀàÀ¬»ø #tagCMActGarbageSorting
#
#struct    tagCMActGarbageSorting
#{
#    tagHead        Head;
#    BYTE        ActNum;        //»î¶¯±àºÅ
#    BYTE        GarbageSortingType;    //À¬»ø·ÖÀàÀàÐÍ£¬¼´ÊôÓÚÄÄÖÖÀ¬»ø
#    BYTE        ItemIndexCount;        //À¬»ø±³°üÖеÄÎïÆ·Ë÷ÒýÊý
#    BYTE        ItemIndexList[ItemIndexCount];    //À¬»ø±³°üÖеÄÎïÆ·Ë÷ÒýÁбí
#};
def OnActGarbageSorting(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    actNum = clientData.ActNum
    sortingType = clientData.GarbageSortingType
    itemIndexList = clientData.ItemIndexList
    
    playerID = curPlayer.GetPlayerID()
    
    GameWorld.DebugLog("À¬»ø·ÖÀàͶ·Å: sortingType=%s,itemIndexList=%s" % (sortingType, itemIndexList), playerID)
    
    isRight = 1
    environmentValueInfo = IpyGameDataPY.GetFuncEvalCfg("GarbageSorting", 2)
    addEnvValueTotal = 0
    garbagePack = curPlayer.GetItemManager().GetPack(ShareDefine.rptGarbage)
    for index in itemIndexList:
        if index >= garbagePack.GetCount():
            continue
        curItem = garbagePack.GetAt(index)
        if not ItemCommon.CheckItemCanUse(curItem):
            continue
        itemID = curItem.GetItemTypeID()
        itemSortingType = curItem.GetEffectByIndex(0).GetEffectValue(0)
        if sortingType == itemSortingType:
            delCount = curItem.GetCount()
            addEnvValue = environmentValueInfo[0] * delCount
        else:
            delCount = 1 # ´íÎóÖ»¿Û³ý1Ò»¸ö
            addEnvValue = environmentValueInfo[1] * delCount
            isRight = 0
            
        ItemControler.SetItemCount(curItem, max(0, curItem.GetCount() - delCount))
        addEnvValueTotal += addEnvValue
        GameWorld.DebugLog("    index=%s,itemID=%s,itemSortingType=%s,delCount=%s,addEnvValue=%s" 
                           % (index, itemID, itemSortingType, delCount, addEnvValue), playerID)
        
    if not addEnvValueTotal:
        return
    
    PlayerControl.GiveMoney(curPlayer, ShareDefine.TYPE_Price_Environment, addEnvValueTotal, isSysHint=False)
    actEnvValueTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValue % actNum) + addEnvValueTotal
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_GarbageEnvironmentValue % actNum, actEnvValueTotal)    
    GameWorld.DebugLog("    addEnvValueTotal=%s,actEnvValueTotal=%s,curEnvValue=%s" 
                       % (addEnvValueTotal, actEnvValueTotal, PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_Environment)), playerID)
    
    PlayerBillboard.UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_Environment, actEnvValueTotal)
    
    # ֪ͨ½á¹û
    clientPack = ChPyNetSendPack.tagMCActGarbageSortingResult()
    clientPack.ActNum = actNum
    clientPack.GarbageSortingType = sortingType
    clientPack.IsRight = isRight
    clientPack.AddEnvValue = addEnvValueTotal
    clientPack.HisEnvValueTotal = actEnvValueTotal
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return


#// AA 15 À¬»ø·ÖÀà»î¶¯ÊÕ¼¯ÒÑÍê³ÉµÄÈÎÎñÀ¬»ø #tagCMActGarbageGetTaskAward
#
#struct    tagCMActGarbageGetTaskAward
#{
#    tagHead        Head;
#    BYTE        ActNum;        //»î¶¯±àºÅ
#    BYTE        GarbageTaskID;    //À¬»øÈÎÎñID
#};
def OnActGarbageGetTaskAward(index, clientData, tick):
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
    actNum = clientData.ActNum
    taskID = clientData.GarbageTaskID
    __DoCheckFinishGarbageTask(curPlayer, actNum, taskID)
    return

def Sync_GarbageTaskInfo(curPlayer, actNum, taskID=0):
    ## ֪ͨÀ¬»øÊÕ¼¯ÈÎÎñÐÅÏ¢
    syncTaskIDList = [taskID] if taskID else ChConfig.GarbageTaskList
    clientPack = ChPyNetSendPack.tagMCActGarbageTaskInfo()
    clientPack.ActNum = actNum
    clientPack.HisEnvValueTotal = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageEnvironmentValue % actNum)
    clientPack.GarbageTaskList = []
    for taskID in syncTaskIDList:
        task = ChPyNetSendPack.tagMCActGarbageTask()
        task.GarbageTaskID = taskID
        task.GarbageTaskValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskValue % (actNum, taskID))
        task.GarbageTaskFinishCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_GarbageTaskFinishCount % (actNum, taskID))
        clientPack.GarbageTaskList.append(task)
    clientPack.GarbageTaskCount = len(clientPack.GarbageTaskList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_GarbageSortingActionInfo(curPlayer, actNum):
    ## ֪ͨ»î¶¯ÐÅÏ¢
    
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_GarbageSorting, actNum)
    if not actInfo.get(ShareDefine.ActKey_State):
        return
    
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
    ipyData = IpyGameDataPY.GetIpyGameData("ActGarbageSorting", cfgID)
    if not ipyData:
        return
    
    startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)
    clientPack = ChPyNetSendPack.tagMCActGarbageSortingInfo()
    clientPack.ActNum = actNum
    clientPack.StartDate = startDateStr
    clientPack.EndtDate = endDateStr
    clientPack.LimitLV = ipyData.GetLVLimit()
    clientPack.ResetType = ipyData.GetResetType()
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return