#!/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):
            Sync_ActTaskActionInfo(curPlayer, actNum)
            Sync_ActTaskPlayerValueInfo(curPlayer, actNum)
            Sync_ActTaskPlayerInfo(curPlayer, actNum)
            
    return

def RefreshActTaskActionInfo(actNum):
    ## ÊÕµ½GameServerͬ²½µÄ»î¶¯ÐÅÏ¢£¬Ë¢Ð»ÐÅÏ¢
    playerManager = GameWorld.GetPlayerManager()
    for index in xrange(playerManager.GetPlayerCount()):
        curPlayer = playerManager.GetPlayerByIndex(index)
        if curPlayer.GetID() == 0:
            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)
    
    # »î¶¯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)
    
    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)
    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 AddActTaskValue(curPlayer, taskType, addValue):
    ## Ôö¼ÓÈÎÎñ»î¶¯½ø¶ÈÖµ
    
    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
        
        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 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
    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])
    
    Sync_ActTaskPlayerInfo(curPlayer, actNum)
    
    GameWorld.DebugLog("ÁìÈ¡ÈÎÎñ»î¶¯½±Àø£¡ actNum=%s,cfgID=%s,taskID=%s,awardItemList=%s" % (actNum, cfgID, taskID, awardItemList))
    
    for itemID, itemCount, isAuctionItem in awardItemList:
        ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, isAuctionItem, [IPY_GameWorld.rptItem], event=["ActTask", False, {}])
        
    return

def Sync_ActTaskPlayerInfo(curPlayer, actNum):
    ## ֪ͨ»î¶¯Íæ¼ÒÐÅÏ¢
    templateID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_ActTaskTempID % actNum)
    keyNumMax = __GetTaskAwardRecordKeyNumMax(templateID)
    
    clientPack = ChPyNetSendPack.tagMCActTaskPlayerInfo()
    clientPack.ActNum = 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 = ChConfig.ActTaskTypeList
        
    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
    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
    
    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.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