#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package Player.PlayerActTask
#
# @todo:»î¶¯ÈÎÎñ
# @author hxp
# @date 2024-06-04
# @version 1.0
#
# ÏêϸÃèÊö: »î¶¯ÈÎÎñ
#
#-------------------------------------------------------------------------------
#"""Version = 2024-06-04 18:00"""
#-------------------------------------------------------------------------------

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

def OnPlayerLogin(curPlayer):
    
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ActTask, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        isReset = __CheckPlayerActTaskAction(curPlayer, actNum)
        # »î¶¯ÖÐͬ²½»î¶¯ÐÅÏ¢
        if not isReset and actInfo.get(ShareDefine.ActKey_State) and curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskID % actNum):
            Sync_ActTaskActionInfo(curPlayer, actNum)
            Sync_ActTaskPlayerValueInfo(curPlayer, actNum)
            Sync_ActTaskPlayerInfo(curPlayer, actNum)
            
    return

def OnDay(curPlayer):
    OnCheckRelateFuncAct(curPlayer)
    return

def OnCheckRelateFuncAct(curPlayer, openFuncIDList=None):
    ## ¼ì²é¹ØÁª¹¦ÄÜID¿ªÆôµÄ»î¶¯
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ActTask, {}).values():
        if not actInfo.get(ShareDefine.ActKey_State):
            continue
        cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
        ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
        if not ipyData:
            continue
        if not hasattr(ipyData, "GetRelateFuncID"):
            continue
        relateFuncID = ipyData.GetRelateFuncID()
        if not relateFuncID:
            continue
        if openFuncIDList and relateFuncID not in openFuncIDList:
            continue
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        __CheckPlayerActTaskAction(curPlayer, actNum)
        
    return

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

def __CheckPlayerActTaskAction(curPlayer, actNum):
    ## ¼ì²éÍæ»î¶¯Êý¾ÝÐÅÏ¢
    
    playerID = curPlayer.GetPlayerID()
    
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_ActTask, actNum)
    actID = actInfo.get(ShareDefine.ActKey_ID, 0)
    state = actInfo.get(ShareDefine.ActKey_State, 0)
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
    
    playerActID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskID % actNum) # Íæ¼ÒÉíÉϵĻID
    lastTempID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskTempID % actNum)
    
    funcActInfo = GameWorld.GetActRelateFuncInfo(curPlayer, "ActTask", actInfo, playerActID)
    if funcActInfo:
        isInAct, actID = funcActInfo
        if not isInAct:
            return
        
    # »î¶¯ID ÏàͬµÄ»°²»´¦Àí
    if actID == playerActID:
        GameWorld.DebugLog("ÈÎÎñ»î¶¯ID²»±ä£¬²»´¦Àí£¡ actNum=%s,actID=%s" % (actNum, actID), playerID)
        return
    GameWorld.DebugLog("ÈÎÎñ»î¶¯ÖØÖÃ! actNum=%s,actID=%s,playerActID=%s,state=%s,lastTempID=%s" 
                       % (actNum, actID, playerActID, state, lastTempID), playerID)
    if lastTempID:
        __ResetTaskValueByTemplateID(curPlayer, actNum, lastTempID)
        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskID % actNum, actID)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskRound % actNum, 0)
    
    if state:
        ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
        if ipyData:
            templateID = ipyData.GetTemplateID()
            __ResetTaskValueByTemplateID(curPlayer, actNum, templateID)
            
        Sync_ActTaskActionInfo(curPlayer, actNum)
        Sync_ActTaskPlayerValueInfo(curPlayer, actNum)
        Sync_ActTaskPlayerInfo(curPlayer, actNum)
        
    return True

def __ResetTaskValueByTemplateID(curPlayer, actNum, templateID):
    ## ÖØÖûÏà¹ØÈÎÎñÊý¾Ý¼Ç¼
    
    # ½ø¶ÈÖµ
    for taskType in ChConfig.ActTaskTypeList:
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskValue % (actNum, taskType), 0)
        
    # ÈÎÎñÁì½±¼Ç¼
    taskAwardKeyNum = __GetTaskAwardRecordKeyNumMax(templateID, 10)
    for keyNum in range(taskAwardKeyNum + 1):
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskAward % (actNum, keyNum), 0)
        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskTempID % actNum, templateID)
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskRound % actNum, 1)
    return

def __GetTaskAwardRecordKeyNumMax(templateID, defKeyNum=2):
    ## »ñÈ¡×î´óÈÎÎñ½±Àø¼Ç¼key±àºÅ
    taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
    if taskIpyDataList:
        taskIDMax = 0
        for taskIpyData in taskIpyDataList:
            if taskIpyData.GetTaskID() > taskIDMax:
                taskIDMax = taskIpyData.GetTaskID()
        return taskIDMax / 31
    return defKeyNum

def UpdActTaskValue(curPlayer, taskType, updValue):
    ## ¸üÐÂÈÎÎñ»î¶¯½ø¶ÈÖµ
    
    playerID = curPlayer.GetPlayerID()
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ActTask, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        if not actInfo.get(ShareDefine.ActKey_State):
            continue
        if not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskID % actNum):
            continue
        cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
        ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
        if not ipyData:
            continue
        templateID = ipyData.GetTemplateID()
        
        taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
        if not taskIpyDataList:
            continue
        
        needValueMax = 0
        for taskIpyData in taskIpyDataList:
            if taskIpyData.GetTaskType() != taskType:
                continue
            needValue = taskIpyData.GetNeedValue()
            if needValue > needValueMax:
                needValueMax = needValue
                
        curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskValue % (actNum, taskType))
        if updValue == curValue or needValueMax <= 0:
            continue
        
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskValue % (actNum, taskType), updValue)
        GameWorld.DebugLog("¸üÐÂÈÎÎñ»î¶¯ÈÎÎñ½ø¶ÈÖµ: actNum=%s,taskType=%s,updValue=%s" % (actNum, taskType, updValue), playerID)
        Sync_ActTaskPlayerValueInfo(curPlayer, actNum, [taskType])
        
    return
    
def AddActTaskValue(curPlayer, taskType, addValue=1):
    ## Ôö¼ÓÈÎÎñ»î¶¯½ø¶ÈÖµ
    
    playerID = curPlayer.GetPlayerID()
    for actInfo in PyGameData.g_operationActionDict.get(ShareDefine.OperationActionName_ActTask, {}).values():
        actNum = actInfo.get(ShareDefine.ActKey_ActNum, 0)
        if not actInfo.get(ShareDefine.ActKey_State):
            continue
        if not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskID % actNum):
            continue
        cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
        ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
        if not ipyData:
            continue
        roundMax = ipyData.GetRoundMax()
        templateID = ipyData.GetTemplateID()
        
        taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
        if not taskIpyDataList:
            continue
        
        needValueMax = 0
        for taskIpyData in taskIpyDataList:
            if taskIpyData.GetTaskType() != taskType:
                continue
            needValue = taskIpyData.GetNeedValue()
            if needValue > needValueMax:
                needValueMax = needValue
                
        curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskValue % (actNum, taskType))
        if roundMax > 1:
            needValueMax *= roundMax
        if curValue >= needValueMax:
            continue
        
        updValue = min(needValueMax, curValue + addValue)
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskValue % (actNum, taskType), updValue)
        GameWorld.DebugLog("¸üÐÂÈÎÎñ»î¶¯ÈÎÎñ½ø¶ÈÖµ: actNum=%s,taskType=%s,addValue=%s,updValue=%s" 
                           % (actNum, taskType, addValue, updValue), playerID)
        Sync_ActTaskPlayerValueInfo(curPlayer, actNum, [taskType])
        
    return

def OnGetActTaskAward(curPlayer, taskID, actNum):
    ## ÁìÈ¡»î¶¯½±Àø
    
    actNum = GameWorld.ToIntDef(actNum)
    
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_ActTask, actNum)
    if not actInfo:
        GameWorld.DebugLog("ûÓиÃÈÎÎñ»î¶¯£¡ actNum=%s" % actNum)
        return
    
    if not actInfo.get(ShareDefine.ActKey_State):
        GameWorld.DebugLog("·ÇÈÎÎñ»î¶¯ÖУ¡ actNum=%s" % actNum)
        return
    
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
    ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
    if not ipyData:
        return
    roundMax = ipyData.GetRoundMax()
    templateID = ipyData.GetTemplateID()
    
    taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
    if not taskIpyDataList:
        return
    
    findIpyData = None
    for taskIpyData in taskIpyDataList:
        if taskIpyData.GetTaskID() == taskID:
            findIpyData = taskIpyData
            break
        
    if not findIpyData:
        GameWorld.DebugLog("ÕÒ²»µ½¶ÔÓ¦»î¶¯ÈÎÎñ½±Àø! actNum=%s,cfgID=%s,templateID=%s,taskID=%s" % (actNum, cfgID, templateID, taskID))
        return
    awardItemList = findIpyData.GetAwardItemList()
    taskType = findIpyData.GetTaskType()
    needValue = findIpyData.GetNeedValue()
    curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskValue % (actNum, taskType))
    if curValue < needValue:
        GameWorld.DebugLog("»î¶¯ÈÎÎñδÍê³É£¬ÎÞ·¨ÁìÈ¡! actNum=%s,cfgID=%s,templateID=%s,taskID=%s,curValue=%s < %s" 
                           % (actNum, cfgID, templateID, taskID, curValue, needValue))
        return
    
    awardIndex = taskID
    
    if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_ActTaskAward, awardIndex, True, [actNum]):
        GameWorld.DebugLog("ÈÎÎñ»î¶¯¸ÃÈÎÎñÒÑÁì½±! actNum=%s,cfgID=%s,taskID=%s" % (actNum, cfgID, taskID))
        return
    
    if not ItemControler.CheckPackSpaceEnough(curPlayer, awardItemList):
        return
    
    GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_ActTaskAward, awardIndex, 1, True, [actNum])
    
    roundNum = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskRound % actNum)
    GameWorld.DebugLog("ÁìÈ¡ÈÎÎñ»î¶¯½±Àø£¡ actNum=%s,cfgID=%s,roundNum=%s,taskID=%s,awardItemList=%s" % (actNum, cfgID, roundNum, taskID, awardItemList))
    
    for itemID, itemCount, isAuctionItem in awardItemList:
        ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem], event=["ActTask", False, {}])
    ItemControler.NotifyGiveAwardInfo(curPlayer, awardItemList, "ActTask")
    
    # ¼ì²é½øÈëÏÂÒ»ÂÖ
    if roundMax > 1 and roundNum < roundMax:
        roundFinish = True
        taskMaxValueInfo = {}
        for taskIpyData in taskIpyDataList:
            rTaskID = taskIpyData.GetTaskID()
            rTaskType = taskIpyData.GetTaskType()
            rNeedValue = taskIpyData.GetNeedValue()
            if rNeedValue > taskMaxValueInfo.get(rTaskType, 0):
                taskMaxValueInfo[rTaskType] = rNeedValue
            rAwardIndex = rTaskID
            if not GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_ActTaskAward, rAwardIndex, True, [actNum]):
                roundFinish = False
                GameWorld.DebugLog("»¹ÓÐÈÎÎñδÁìÈ¡£¬²»½øÈëÏÂÒ»ÂÖ´Î! actNum=%s,cfgID=%s,roundNum=%s,rTaskID=%s" % (actNum, cfgID, roundNum, rTaskID))
                break
            
        if roundFinish:
            nextRound = roundNum + 1
            GameWorld.DebugLog("±¾ÂÖÈÎÎñÁìÈ¡Íê±Ï£¬½øÈëÏÂÒ»ÂÖ! nextRound=%s" % (nextRound))
            for rTaskType, rMaxValue in taskMaxValueInfo.items():
                curValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskValue % (actNum, taskType))
                updValue = max(0, curValue - rMaxValue)
                PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskValue % (actNum, taskType), updValue)
                GameWorld.DebugLog("    ¸üÐÂÐÂÒ»ÂÖÈÎÎñÖµ! rTaskType=%s,rMaxValue=%s,curValue=%s,updValue=%s" 
                                   % (rTaskType, rMaxValue, curValue, updValue))
            Sync_ActTaskPlayerValueInfo(curPlayer, actNum, taskMaxValueInfo.keys())
            
            # ÈÎÎñÁì½±¼Ç¼
            taskAwardKeyNum = __GetTaskAwardRecordKeyNumMax(templateID, 10)
            for keyNum in range(taskAwardKeyNum + 1):
                PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskAward % (actNum, keyNum), 0)
            GameWorld.DebugLog("    ÖØÖÃÐÂÒ»ÂÖÁì½±¼Ç¼! taskAwardKeyNum=%s" % (taskAwardKeyNum))
            
            PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_ActTaskRound % actNum, nextRound)
            
    Sync_ActTaskPlayerInfo(curPlayer, actNum)
    return

def GetActTaskTypeList(actNum):
    taskTypeList = []
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_ActTask, actNum)
    if not actInfo:
        return taskTypeList
    if not actInfo.get(ShareDefine.ActKey_State):
        return taskTypeList
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
    ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
    if not ipyData:
        return taskTypeList
    templateID = ipyData.GetTemplateID()
    taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
    if not taskIpyDataList:
        return taskTypeList
    for taskIpyData in taskIpyDataList:
        taskType = taskIpyData.GetTaskType()
        if taskType not in taskTypeList:
            taskTypeList.append(taskType)
    return taskTypeList

def Sync_ActTaskPlayerInfo(curPlayer, actNum):
    ## ֪ͨ»î¶¯Íæ¼ÒÐÅÏ¢
    templateID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskTempID % actNum)
    keyNumMax = __GetTaskAwardRecordKeyNumMax(templateID)
    
    clientPack = ChPyNetSendPack.tagMCActTaskPlayerInfo()
    clientPack.ActNum = actNum
    clientPack.RoundNum = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskRound % actNum)
    clientPack.AwardRecordList = []
    for keyNum in range(keyNumMax + 1):
        clientPack.AwardRecordList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskAward % (actNum, keyNum)))
    clientPack.AwardCount = len(clientPack.AwardRecordList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_ActTaskPlayerValueInfo(curPlayer, actNum, taskTypeList=None):
    ## ֪ͨ»î¶¯Íæ¼ÒÐÅÏ¢
    if taskTypeList == None:
        taskTypeList = GetActTaskTypeList(actNum)
        
    clientPack = ChPyNetSendPack.tagMCActTaskPlayerValueInfo()
    clientPack.ActNum = actNum
    clientPack.TaskValueList = []
    for taskType in taskTypeList:
        taskValueInfo = ChPyNetSendPack.tagMCActTaskPlayerValue()
        taskValueInfo.TaskType = taskType
        taskValueInfo.TaskValue = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskValue % (actNum, taskType))
        clientPack.TaskValueList.append(taskValueInfo)
    clientPack.TaskCount = len(clientPack.TaskValueList)
    NetPackCommon.SendFakePack(curPlayer, clientPack)
    return

def Sync_ActTaskActionInfo(curPlayer, actNum):
    ## ֪ͨ»î¶¯ÐÅÏ¢
    actInfo = GameWorld.GetActInfo(ShareDefine.OperationActionName_ActTask, actNum)
    if not actInfo:
        return
    if not actInfo.get(ShareDefine.ActKey_State):
        return
    playerActID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskID % actNum) # Íæ¼ÒÉíÉϵĻID
    if not playerActID:
        return
    cfgID = actInfo.get(ShareDefine.ActKey_CfgID)
    ipyData = IpyGameDataPY.GetIpyGameData("ActTask", cfgID)
    if not ipyData:
        return
    templateID = ipyData.GetTemplateID()
    taskIpyDataList = IpyGameDataPY.GetIpyGameDataList("ActTaskTemp", templateID)
    if not taskIpyDataList:
        return
    
    if hasattr(ipyData, "GetRelateFuncID") and ipyData.GetRelateFuncID():
        startDateStr, endDateStr = GameWorld.GetActRelateFuncDate(ipyData, playerActID, True)
    else:
        startDateStr, endDateStr = GameWorld.GetOperationActionDateStr(ipyData)
    actPack = ChPyNetSendPack.tagMCActTaskInfo()
    actPack.Clear()
    actPack.ActNum = actNum
    actPack.StartDate = startDateStr
    actPack.EndtDate = endDateStr
    actPack.IsDayReset = ipyData.GetIsDayReset()
    actPack.ResetType = ipyData.GetResetType()
    actPack.LimitLV = ipyData.GetLVLimit()
    actPack.RoundMax = ipyData.GetRoundMax()
    
    actPack.TaskList = []
    for taskIpyData in taskIpyDataList:
        task = ChPyNetSendPack.tagMCActTask()
        task.TaskID = taskIpyData.GetTaskID()
        task.TaskType = taskIpyData.GetTaskType()
        task.NeedValue = taskIpyData.GetNeedValue()
        task.AwardItemList = []
        for itemID, itemCount, isAuctionItem in taskIpyData.GetAwardItemList():
            itemInfo = ChPyNetSendPack.tagMCActTaskItem()
            itemInfo.ItemID = itemID
            itemInfo.ItemCount = itemCount
            itemInfo.IsBind = isAuctionItem
            task.AwardItemList.append(itemInfo)
        task.Count = len(task.AwardItemList)
        
        actPack.TaskList.append(task)
    actPack.TaskCount = len(actPack.TaskList)
    NetPackCommon.SendFakePack(curPlayer, actPack)
    return