#!/usr/bin/python
# -*- coding: GBK -*-
#-------------------------------------------------------------------------------
#
##@package GM.Commands.Hero
#
# @todo:Î佫ӢÐÛ
# @author hxp
# @date 2025-06-11
# @version 1.0
#
# ÏêϸÃèÊö: Î佫ӢÐÛ
#
#-------------------------------------------------------------------------------
#"""Version = 2025-06-11 11:00"""
#-------------------------------------------------------------------------------

import PlayerHero
import ShareDefine
import IpyGameDataPY
import PlayerControl
import ItemControler
import PlayerOnline
import GameWorld
import ChConfig
import random

## GMÃüÁîÖ´ÐÐÈë¿Ú
#  @param curPlayer µ±Ç°Íæ¼Ò
#  @param msgList ²ÎÊýÁбí
#  @return None
#  @remarks º¯ÊýÏêϸ˵Ã÷.
def OnExec(curPlayer, msgList):
    
    if not msgList:
        GameWorld.DebugAnswer(curPlayer, "Î佫ÖØÖÃ: Hero 0 ±³°üλÖÃ")
        GameWorld.DebugAnswer(curPlayer, "Î佫µÈ¼¶: Hero l ±³°üλÖà ÉèÖõȼ¶")
        GameWorld.DebugAnswer(curPlayer, "Î佫ÉýÐÇ: Hero s ±³°üλÖà ÉýxÐÇ")
        GameWorld.DebugAnswer(curPlayer, "Î佫ͻÆÆ: Hero b ±³°üλÖà ÉèÖõȼ¶")
        GameWorld.DebugAnswer(curPlayer, "Î佫¾õÐÑ: Hero a ±³°üλÖà ÉèÖõȼ¶")
        GameWorld.DebugAnswer(curPlayer, "Î佫ͼ¼ø: Hero t Î佫ID ͼ¼øÐǼ¶ ͼ¼øÍ»ÆƵȼ¶")
        GameWorld.DebugAnswer(curPlayer, "ÖØÖÃͼ¼ø: Hero t 0")
        GameWorld.DebugAnswer(curPlayer, "ÖØÖÃÖØÉú: Hero r")
        GameWorld.DebugAnswer(curPlayer, "Î佫Ƥ·ô: Hero sk Î佫ID Ƥ·ôË÷Òý ÊÇ·ñ½âËø")
        GameWorld.DebugAnswer(curPlayer, "Çå¿ÕÎ佫: ClearPack 35")
        GameWorld.DebugAnswer(curPlayer, "ÐÂÔöÎ佫: MakeItemCount Ó¢ÐÛID [¸öÊý]")
        GameWorld.DebugAnswer(curPlayer, "ÕóÈÝÉÏÕó: Hero f ÕóÈÝID [Î佫ID ...]")
        GameWorld.DebugAnswer(curPlayer, "ÕóÈÝÎ佫: Hero h ÕóÈÝID Î佫ID µÈ¼¶ ÐǼ¶ Í»ÆƵȼ¶ ¾õÐѵȼ¶ Ƥ·ô")
        GameWorld.DebugAnswer(curPlayer, "ÕóÈÝÂú¼¶: Hero h ÕóÈÝID 1")
        return
    
    PlayerOnline.GetOnlinePlayer(curPlayer).RefreshRoleAttr()
    
    value = msgList[0]
    value2 = msgList[1] if len(msgList) > 1 else 0
    
    # ÕóÈÝÉÏÕó
    if value == "f":
        __oneKeyLineup(curPlayer, msgList)
        return
    
    # ÕóÈÝÎ佫
    if value == "h":
        __lineupHero(curPlayer, msgList)
        return
    
    # ͼ¼ø
    if value == "t":
        if not value2:
            heroIDList = []
            ipyDataMgr = IpyGameDataPY.IPY_Data()
            for index in range(ipyDataMgr.GetHeroCount()):
                ipyData = ipyDataMgr.GetHeroByIndex(index)
                heroIDList.append(ipyData.GetHeroID())
        else:
            heroIDList = [value2]
            
        if value2 == 0:
            syncHeroIDList = []
            for heroID in heroIDList:
                if not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID):
                    continue
                syncHeroIDList.append(heroID)
                PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, 0)
            GameWorld.DebugAnswer(curPlayer, "ÖØÖÃͼ¼øOK!")
        else:
            heroID = value2
            syncHeroIDList = [heroID]
            bookStarLV = msgList[2] if len(msgList) > 2 else 0
            bookBreakLV = msgList[3] if len(msgList) > 3 else 0
            if (bookStarLV or bookStarLV) and not PlayerHero.GetHeroBookInitState(curPlayer, heroID):
                PlayerHero.SetHeroBookInitState(curPlayer, heroID, 1)
            PlayerHero.SetHeroBookStarLV(curPlayer, heroID, bookStarLV)
            PlayerHero.SetHeroBookBreakLV(curPlayer, heroID, bookBreakLV)
            GameWorld.DebugAnswer(curPlayer, "ÉèÖÃÎ佫(%s)ͼ¼øÐǼ¶(%s),Í»ÆÆ(%s)" % (heroID, bookStarLV, bookBreakLV))
            
        PlayerHero.Sync_HeroInfo(curPlayer, syncHeroIDList)
        return
    
    # ÖØÉú
    if value == "r":
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroAwakeRebirthCnt, 0)
        PlayerHero.Sync_PlayerHeroInfo(curPlayer)
        return
    
    # Ƥ·ô
    if value == "sk":
        heroID = value2
        skinIndex = msgList[2] if len(msgList) > 2 else 0
        isActive = msgList[3] if len(msgList) > 3 else 0
        PlayerHero.ActiveHeroSkin(curPlayer, heroID, skinIndex, isActive)
        return
    
    itemIndex = value2
    heroItem = PlayerHero.GetHeroItem(curPlayer, itemIndex)
    if not heroItem:
        GameWorld.DebugAnswer(curPlayer, "²»´æÔÚÎ佫: itemIndex=%s" % itemIndex)
        return
    
    if value == 0:
        PlayerHero.InitHeroItem(heroItem.GetItem())
        heroItem.Sync_Item()
        GameWorld.DebugAnswer(curPlayer, "ÖØÖÃÎ佫: itemIndex=%s" % (itemIndex))
        return
    
    # µÈ¼¶
    if value == "l":
        heroLV = msgList[2] if len(msgList) > 2 else 1
        LVMax = PlayerHero.GetHeroLVMax(heroItem)
        heroLV = min(LVMax, heroLV)
        heroItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, heroLV)
        GameWorld.DebugAnswer(curPlayer, "ÉèÖÃÎ佫µÈ¼¶: %s,itemIndex=%s" % (heroLV, itemIndex))
        return
    
    # ÐǼ¶
    if value == "s":
        addStar = msgList[2] if len(msgList) > 2 else 1
        curStar = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
        starMax = PlayerHero.GetHeroStarMax(heroItem)
        if curStar >= starMax:
            GameWorld.DebugAnswer(curPlayer, "Î佫ÒÑÂúÐÇ: %s,itemIndex=%s" % (curStar, itemIndex))
            return
        updStar = min(curStar + addStar, starMax)
        PlayerHero.DoHeroUpdStar(curPlayer, heroItem, updStar)
        GameWorld.DebugAnswer(curPlayer, "¸üÐÂÎ佫ÐǼ¶: %s,itemIndex=%s" % (updStar, itemIndex))
        return
    
    # Í»ÆÆ
    if value == "b":
        breakLV = msgList[2] if len(msgList) > 2 else 0
        PlayerHero.SetHeroBreakLV(heroItem, breakLV)
        GameWorld.DebugAnswer(curPlayer, "ÉèÖÃÎ佫ͻÆÆ: %s,itemIndex=%s" % (breakLV, itemIndex))
        return
    
    # ¾õÐÑ
    if value == "a":
        awakeLV = msgList[2] if len(msgList) > 2 else 0
        PlayerHero.SetHeroAwakeLV(heroItem, awakeLV)
        GameWorld.DebugAnswer(curPlayer, "ÉèÖÃÎ佫¾õÐÑ: %s,itemIndex=%s" % (awakeLV, itemIndex))
        return
    
    return

def __oneKeyLineup(curPlayer, msgList):
    ## ÕóÈÝÉÏÕó: Hero f ÕóÈÝID [Î佫ID ...]
    lineupID = msgList[1] if len(msgList) > 1 else 0
    heroIDList = []
    for heroID in msgList[2:]: # È¥ÖØ£¬µ¥ÕóÈÝÎ佫ID²»ÄÜÖظ´
        if heroID not in heroIDList:
            heroIDList.append(heroID)
    if lineupID not in ShareDefine.LineupList:
        GameWorld.DebugAnswer(curPlayer, "²»´æÔÚ¸ÃÕóÈÝ: %s" % lineupID)
        return
    
    if not heroIDList:
        GameWorld.DebugAnswer(curPlayer, "ûÓÐÖ¸¶¨ÕóÈÝÎ佫IDÁбí!")
        return
    
    for heroID in heroIDList:
        if not GameWorld.GetGameData().GetItemByTypeID(heroID):
            GameWorld.DebugAnswer(curPlayer, "²»´æÔÚ¸ÃÎ佫: %s" % heroID)
            return
        
    shapeType = 0
    haveHeroIDList = []
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    # Ö±½ÓÖØÖþÉÕóÐÍ
    syncItemDict = {}
    for index in range(curPack.GetCount()):
        heroItem = curPack.GetAt(index)
        if not heroItem or heroItem.IsEmpty():
            continue
        heroID = heroItem.GetItemTypeID()
        if heroID in heroIDList and heroID not in haveHeroIDList:
            haveHeroIDList.append(heroID)
        lineupCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroLineup)
        if not lineupCount:
            continue
        item = heroItem.GetItem()
        for lpIndex in range(lineupCount)[::-1]:
            lineupValue = item.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
            if PlayerHero.GetLineupValue(lineupValue)[0] != lineupID:
                continue
            item.DelUserAttr(ShareDefine.Def_IudetHeroLineup, lineupValue)
            syncItemDict[index] = heroItem
            
    # ¸øûÓеÄÎ佫
    for heroID in heroIDList:
        if heroID in haveHeroIDList:
            continue
        if not ItemControler.GivePlayerItem(curPlayer, heroID, 1, False):
            break
        
    # ¸üÐÂÐÂÕóÐÍ
    heroItemDict = {}
    updHeroIDList = []
    for index in range(curPack.GetCount()):
        heroItem = curPack.GetAt(index)
        if not heroItem or heroItem.IsEmpty():
            continue
        heroID = heroItem.GetItemTypeID()
        if heroID not in heroIDList:
            continue
        if heroID in updHeroIDList:
            # ÒѾ­ÉϹý¸ÃÎ佫ÁË
            continue
        updHeroIDList.append(heroID)
        posNum = heroIDList.index(heroID) + 1
        item = heroItem.GetItem()
        lineupValue = PlayerHero.ComLineupValue(lineupID, shapeType, posNum)
        item.AddUserAttr(ShareDefine.Def_IudetHeroLineup, lineupValue)
        if index not in syncItemDict:
            syncItemDict[index] = heroItem
        heroItemDict[index] = posNum
        
    for syncItem in syncItemDict.values():
        syncItem.Sync_Item()
        
    lineup = PlayerOnline.GetOnlinePlayer(curPlayer).GetLineup(lineupID)
    lineup.UpdLineup(heroItemDict, shapeType)
    GameWorld.DebugAnswer(curPlayer, "ÕóÈÝ(%s)ÉÏÕóOK: %s" % (lineupID, heroItemDict))
    return

def __lineupHero(curPlayer, msgList):
    #ÕóÈÝÎ佫: Hero h ÕóÈÝID Î佫ID µÈ¼¶ ÐǼ¶ Í»ÆƵȼ¶ ¾õÐѵȼ¶ Ƥ·ô
    #ÕóÈÝÂú¼¶: Hero h ÕóÈÝID 1
    lineupID = msgList[1] if len(msgList) > 1 else 0
    heroID = msgList[2] if len(msgList) > 2 else 0
    setLV = msgList[3] if len(msgList) > 3 else None
    setStar = msgList[4] if len(msgList) > 4 else None
    setBreakLV = msgList[5] if len(msgList) > 5 else None
    setAwakeLV = msgList[6] if len(msgList) > 6 else None
    setSkinID = msgList[7] if len(msgList) > 7 else None
    
    olPlayer = PlayerOnline.GetOnlinePlayer(curPlayer)
    lineup = olPlayer.GetLineup(lineupID)
    if heroID == 1:
        setIndexList = lineup.heroItemDict.keys()
    else:
        lineupHero = lineup.GetLineupHeroByID(heroID)
        if not lineupHero:
            GameWorld.DebugAnswer(curPlayer, "¸ÃÕóÈݲ»´æÔÚ¸ÃÎ佫: %s" % heroID)
            return
        setIndexList = [lineupHero.itemIndex]
        
    curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
    for itemIndex in setIndexList:
        if itemIndex < 0 or itemIndex >= curPack.GetCount():
            continue
        heroItem = curPack.GetAt(itemIndex)
        if not heroItem or heroItem.IsEmpty():
            continue
        heroID = heroItem.GetItemTypeID()
        heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
        if not heroIpyData:
            continue
        quality = heroIpyData.GetQuality()
        qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
        if not qualityIpyData:
            continue
        singleItem = heroItem.GetItem()
        
        # Ì츳        
        if setAwakeLV != None:
            awakeLV = setAwakeLV
            if not IpyGameDataPY.GetIpyGameData("HeroQualityAwake", quality, awakeLV):
                GameWorld.DebugAnswer(curPlayer, "¾õÐѵȼ¶²»´æÔÚ:%s Æ·ÖÊ:%s" % (awakeLV, quality))
                return
        else:
            awakeLV = 0
            for aLV in range(1, 100):
                if not IpyGameDataPY.GetIpyGameDataNotLog("HeroQualityAwake", quality, aLV):
                    break
                awakeLV = aLV
        PlayerHero.SetHeroAwakeLV(heroItem, awakeLV, False)
        
        doCnt = 0
        awakeRandCnt = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
        while awakeRandCnt and doCnt <= 10:
            doCnt += 1
            selectIndex = random.randint(0, awakeRandCnt - 1)
            PlayerHero.doSelectAwakeTalent(curPlayer, itemIndex, selectIndex, False)
            awakeRandCnt = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
            
        # Í»ÆÆ
        if setBreakLV != None:
            breakLV = setBreakLV
            if not IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, breakLV):
                GameWorld.DebugAnswer(curPlayer, "Í»ÆƵȼ¶²»´æÔÚ:%s Æ·ÖÊ:%s" % (breakLV, quality))
                return
        else:
            breakLV = 0
            for bLV in range(1, 100):
                if not IpyGameDataPY.GetIpyGameDataNotLog("HeroQualityBreak", quality, bLV):
                    break
                breakLV = bLV
        PlayerHero.SetHeroBreakLV(heroItem, breakLV, False)
        
        # ÐǼ¶
        starMax = PlayerHero.GetHeroStarMax(heroItem)
        if setStar != None:
            updStar = min(setStar, starMax)
        else:
            updStar = starMax
        PlayerHero.DoHeroUpdStar(curPlayer, heroItem, updStar, False)
        
        # µÈ¼¶
        lvMax = PlayerHero.GetHeroLVMax(heroItem)
        if setLV != None:
            updHeroLV = min(setLV, lvMax)
        else:
            updHeroLV = lvMax
        singleItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, updHeroLV)
        
        # Ƥ·ô
        skinIDList = heroIpyData.GetSkinIDList()
        if setSkinID != None:
            if setSkinID not in skinIDList:
                GameWorld.DebugAnswer(curPlayer, "Ƥ·ô²»´æÔÚ:%s Æ·ÖÊ:%s" % (heroID, setSkinID))
                return
            skinIndex = skinIDList.index(setSkinID)
            singleItem.SetUserAttr(ShareDefine.Def_IudetHeroSkin, skinIndex)      
            
        heroItem.Sync_Item()
        PlayerOnline.GetOnlinePlayer(curPlayer).OnHeroItemUpate([itemIndex])
        
    GameWorld.DebugAnswer(curPlayer, "ÉèÖÃÕóÈÝÎ佫OK")
    return