local Reborn_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local recast_pb = require 'Proto.recast_pb'
local smelt_pb = require 'Proto.smelt_pb'
local recycle_fragment_handle_pb = require "Proto.recycle_fragment_handle_pb"

local HorseSoulLevelGeneralItem = DataSheetManager.ConstData:GetDataByID("HorseSoulLevelGeneralItem").IntValue
local HorseSoulLevelGeneralItemExp = DataSheetManager.ConstData:GetDataByID("HorseSoulLevelGeneralItemExp").IntValue
local SecondTypeGoldFragment = LuaConst.ItemMaterialsType.GoldFragment
local DataSheetManagerItemData = DataSheetManager.ItemData

Reborn_Model.TimeDelayInterval = 0.8

Reborn_Model.RebornToggleIndex = {
    Smelt = 0,
    Recast = 1,
    SoulCrystal = 2,
    RecycleFragment = 3,
}

Reborn_Model.RebornType = {
    Hero = recast_pb.RecastTypeHero,
    Weapon = recast_pb.RecastTypeWeapon,
    Horse = recast_pb.RecastTypeHorse,
    Treasure = recast_pb.RecastTypeTreasure,
    HorseSoul = recast_pb.RecastTypeHorseSoul,
    GodBeast = recast_pb.RecastTypeBeast,
}

Reborn_Model.SmeltType = {
    Equip = smelt_pb.Equip,     -- 装备熔炼
    Crystal = smelt_pb.Crystal, -- 魂晶熔炼
}

function Reborn_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageSmelt, private.SmeltResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageRecast, private.RecastResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageRecycleFragment, private.RecycleFragmentResponse)
    EventSystem.Regist(EventID.BagItem_Update, Reborn_Model.SyncRFMaterialDic)
    private.rfInfo = {}
    private.rfMaterialDic = {} -- 用于具体数据的存储 方便type区分，减少刷新逻辑 
    --[[
        private.rfMaterialDic = 
        {
            Reborn_Model.RFMaterialType.Hero = 
            {
                Id = 
                {
                    Id = Id, -- 背包里的唯一Id
                    cfgId = cfgId,
                    intelligence = intelligence,
                    materialType = materialType,
                }
            }
        }
    --]]
    private.rfMaterialList = {} -- value 为 {Id = XXX, cfgId = XXX, rfMaterialType = XXX} 仅仅用于排序
end

--region 重生相关
function Reborn_Model.GetRecastCostByTypeAndId(type, id)
    local RebornTypeEnum = MDL.Reborn.RebornType
    if type == RebornTypeEnum.Hero then
        local breakLevel = MDL.HeroStar.GetHeroStarLevel(id)
        local breakData = DataSheetManager.HeroStar:GetDataByHeroID_Star(id, breakLevel)
        return breakData.RebirthItemID, breakData.RebirthItemNum
    elseif type == RebornTypeEnum.Weapon then
        local breakLevel = MDL.HeroSelect.GetHeroInfo(id).magicWeaponLevel
        local breakData = DataSheetManager.MagicWeaponStar:GetDataByMagicWeaponID_Star(id, breakLevel)
        return breakData.RebirthItemID, breakData.RebirthItemNum
    elseif type == RebornTypeEnum.Horse then
        local breakLevel = MDL.WarHorse.GetInfoByID(id).HorseInfo.starLevel
        local breakData = DataSheetManager.HorseStar:GetDataByHorseID_Star(id, breakLevel)
        return breakData.RebirthItemID, breakData.RebirthItemNum
    elseif type == RebornTypeEnum.Treasure then
        local breakLevel = MDL.Treasure.GetTreasureInfo(id).TreasureInfo.starLevel
        local breakData = DataSheetManager.TreasureStar:GetDataByTreasureID_Star(id, breakLevel)
        return breakData.RebirthItemID, breakData.RebirthItemNum
    elseif type == RebornTypeEnum.HorseSoul then
        local RebirthItemID, RebirthItemNum = 4,0   -- 默认消耗道具是元宝，数量0
        local soulInfo = MDL.HorseSoul.GetSoulInfoById(id)
        if soulInfo.star > 0 then
            local soulStarData = DataSheetManager.HorseSoulStarData:GetDataByHorseSoulStarAttrID_Star(soulInfo.soulData.HorseSoulStarAttrID, soulInfo.star)
            RebirthItemID = soulStarData.RebirthItemID
            RebirthItemNum = RebirthItemNum + soulStarData.RebirthItemNum
        end

        if soulInfo.levelInfo.level > 0 then
            local soulLevelData = DataSheetManager.HorseSoulLevelData:GetDataByHorseSoulLevelAttrID_Level(soulInfo.soulData.HorseSoulLevelAttrID, soulInfo.levelInfo.level)
            if soulLevelData.RebirthItemID > 0 and soulLevelData.RebirthItemNum > 0 then
                RebirthItemID = soulLevelData.RebirthItemID
                RebirthItemNum = RebirthItemNum + soulLevelData.RebirthItemNum
            end
        end

        return RebirthItemID, RebirthItemNum
    elseif type == RebornTypeEnum.GodBeast then
        local starLevel = MDL.GodBeast.GetGodBeastInfoByID(id).starLevel
        local breakData = DataSheetManager.GodBeastStar:GetDataByID_Star(id, starLevel)
        return breakData.RebirthItemID, breakData.RebirthItemNum
    end
end

function Reborn_Model.GetRecastRewardListByTypeAndId(type, id)
    if type == Reborn_Model.RebornType.Hero then
        return private.GetHeroRecastRewardList(id)
    elseif type == Reborn_Model.RebornType.Weapon then
        return private.GetWeaponRecastRewardList(id)
    elseif type == Reborn_Model.RebornType.Horse then
        return private.GetHorseRecastRewardList(id)
    elseif type == Reborn_Model.RebornType.Treasure then
        return private.GetTreasureRecastRewardList(id)
    elseif type == Reborn_Model.RebornType.HorseSoul then
        return private.GetHorseSoulRecastRewardList(id)
    elseif type == Reborn_Model.RebornType.GodBeast then
        return private.GetGodBeastRecastRewardList(id)
    end
end

function private.GetTreasureRecastRewardList(treasureId)
    local rewardTable = {}
    local treasureTotalInfo = MDL.Treasure.GetTreasureInfo(treasureId)
    local treasureInfo = treasureTotalInfo.TreasureInfo
    local treasureStar = treasureInfo.starLevel
    local treasureStage = treasureInfo.starStage
    local rebirthLevel = treasureTotalInfo.TreasureData.RebirthStarLevel
    for i, v in DataSheetManager.TreasureStar:GetDataByTreasureID_Star(treasureId) do
        local dataStar = v.Star
        if dataStar >= rebirthLevel then
            if dataStar > treasureStar then
                break
            end
            for index, value in ipairs(v.ItemRepeat) do
                if dataStar == treasureStar and index > treasureStage then
                    break
                end
                local itemTable = DataSheetManager.TreasureStarItem:GetDataByItemRepeatID(value).Item_Table
                Reborn_Model.CombineItemList(rewardTable, itemTable)
            end
        end
    end
    table.sort(rewardTable, private.SortTreasureRecastReward)
    return rewardTable
end

function private.SortTreasureRecastReward(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local aFirstType = aItemData.FirstType
    local bFirstType = bItemData.FirstType
    if aFirstType ~= bFirstType then
        --武将碎片要排在最前
        if aFirstType == LuaConst.ItemType.Treasure then
            return true
        elseif bFirstType == LuaConst.ItemType.Treasure then
            return false
        else
            return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
        end
    else
        return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    end
end

function private.GetHorseRecastRewardList(horseId)
    local rewardTable = {}
    local horseTotalInfo = MDL.WarHorse.GetInfoByID(horseId)
    local horseInfo = horseTotalInfo.HorseInfo
    local horseStar = horseInfo.starLevel
    local horseStage = horseInfo.starStage
    local rebirthLevel = horseTotalInfo.ConfigInfo.RebirthStarLevel
    for i, v in DataSheetManager.HorseStar:GetDataByHorseID_Star(horseId) do
        local dataStar = v.Star
        if dataStar >= rebirthLevel then
            if dataStar > horseStar then
                break
            end
            for index, value in ipairs(v.ItemRepeat) do
                if dataStar == horseStar and index > horseStage then
                    break
                end
                local itemTable = DataSheetManager.HorseStarItem:GetDataByItemRepeatID(value).Item_Table
                Reborn_Model.CombineItemList(rewardTable, itemTable)
            end
        end
    end
    table.sort(rewardTable, private.SortHorseRecastReward)
    return rewardTable
end

function private.SortHorseRecastReward(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local aFirstType = aItemData.FirstType
    local bFirstType = bItemData.FirstType
    if aFirstType ~= bFirstType then
        --武将碎片要排在最前
        if aFirstType == LuaConst.ItemType.Horse then
            return true
        elseif bFirstType == LuaConst.ItemType.Horse then
            return false
        else
            return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
        end
    else
        return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    end
end

function private.GetWeaponRecastRewardList(heroId)
    local rewardTable = {}
    local heroInfo = MDL.HeroSelect.GetHeroInfo(heroId)
    local weaponStar = heroInfo.magicWeaponLevel
    local weaponStage = heroInfo.magicWeaponStar
    local rebirthLevel = DataSheetManager.MagicWeaponData:GetDataByMagicWeaponID(heroId).RebirthStarLevel
    for i, v in DataSheetManager.MagicWeaponStar:GetDataByMagicWeaponID_Star(heroId) do
        local dataStar = v.Star
        if dataStar >= rebirthLevel then
            if dataStar > weaponStar then
                break
            end
            for index, value in ipairs(v.Item_Table) do
                if dataStar == weaponStar and index > weaponStage then
                    break
                end
                local itemTable = DataSheetManager.MagicWeaponStarItem:GetDataByItemRepeatID(value.ItemRepeat).Item_Table
                Reborn_Model.CombineItemList(rewardTable, itemTable)
            end
        end
    end
    -- 统计锻造返回道具
    local templateID = CTL.DivineWeapon.GetForgeTemplateID(heroId)
    if templateID ~= 0 then
        for _, lineType in pairs (CTL.DivineWeapon.ForgeLineType) do
            local pointID = MDL.DivineWeapon.GetForgeLineMaxActivatePointID(heroId, lineType)
            if pointID > 0 then
                --后面用id-1，会出现空的情况，用try
                local isHasCfg, pointData = DataSheetManager.MagicWeaponFoundry:TryGetDataByID_PointID(templateID, pointID)
                while (pointData ~= nil)
                do
                    local succ, itemRepeatData = DataSheetManager.MagicWeaponFoundryItemRepeat:TryGetDataByItemRepeatID(pointData.ItemRepeat)
                    if succ then
                        Reborn_Model.CombineItemList(rewardTable, itemRepeatData.Item_Table)
                    end
                    isHasCfg, pointData = DataSheetManager.MagicWeaponFoundry:TryGetDataByID_PointID(templateID, pointData.PointID - 1)
                end
            end
        end
    end
    -- 统计彩金铸魂返回道具
    local heroData = DataSheetManager.HeroNum:GetDataByID(heroId)
    if heroData.HeroQuality == LuaConst.QualityColor.DarkGold then
        local forgeSoulSkill = DataSheetManager.MagicWeaponForgeSoulData:GetDataByMagicWeaponID(heroId).ForgeSoulSkill
        for _, skillId in ipairs(forgeSoulSkill) do
            local lv = MDL.DivineWeaponForgeSoul.GetWeaponForgeSoulSkillLv(heroId, skillId)
            local succ, cfg = DataSheetManager.MagicWeaponForgeSoulSkill:TryGetDataByForgeSoulSkillID_ForgeSoulSkillLevel(skillId, lv)
            while (succ)
            do
                Reborn_Model.CombineItemList(rewardTable, cfg.Item_Table)
                lv = lv - 1
                succ, cfg = DataSheetManager.MagicWeaponForgeSoulSkill:TryGetDataByForgeSoulSkillID_ForgeSoulSkillLevel(skillId, lv)
            end
        end
    end

    table.sort(rewardTable, private.SortWeaponRecastReward)
    return rewardTable
end

function private.SortWeaponRecastReward(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local aFirstType = aItemData.FirstType
    local bFirstType = bItemData.FirstType
    if aFirstType ~= bFirstType then
        --武将碎片要排在最前
        if aFirstType == LuaConst.ItemType.WeaponFragment then
            return true
        elseif bFirstType == LuaConst.ItemType.WeaponFragment then
            return false
        else
            return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
        end
    else
        return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    end
end

function private.GetHeroRecastRewardList(heroId)
    local rewardTable = {}
    local heroStar = MDL.HeroStar.GetHeroStarLevel(heroId)
    local heroStage = MDL.HeroStar.GetHeroStageLevel(heroId)
    local rebirthLevel = DataSheetManager.HeroNum:GetDataByID(heroId).RebirthStarLevel
    for i, v in DataSheetManager.HeroStar:GetDataByHeroID_Star(heroId) do
        local dataStar = v.Star
        if dataStar >= rebirthLevel then
            if dataStar > heroStar then
                break
            end
            for index, value in ipairs(v.Item_Table) do
                if dataStar == heroStar and index > heroStage then
                    break
                end
                local itemTable = DataSheetManager.HeroStarItemRepeat:GetDataByItemRepeatID(value.ItemRepeat).Item_Table
                Reborn_Model.CombineItemList(rewardTable, itemTable)
            end
        end
    end
    -- 添加武将修炼的返还
    Reborn_Model.CombineItemList(rewardTable, CTL.HeroStrenthen.GetRebornMaterialList(heroId))
    table.sort(rewardTable, private.SortHeroRecastReward)
    return rewardTable
end

function private.SortHeroRecastReward(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local aFirstType = aItemData.FirstType
    local bFirstType = bItemData.FirstType
    if aFirstType ~= bFirstType then
        --武将碎片要排在最前
        if aFirstType == LuaConst.ItemType.HeroFragment then
            return true
        elseif bFirstType == LuaConst.ItemType.HeroFragment then
            return false
        else
            return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
        end
    else
        return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    end
end

function private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local qualityA = aItemData.Color
    local qualityB = bItemData.Color
    if qualityA ~= qualityB then
        return qualityA >= qualityB
    else
        return aItemId < bItemId
    end
end

function Reborn_Model.GetRecastDataListByType(type)
    if type == Reborn_Model.RebornType.Hero then
        return private.GetHeroRecastDataList()
    elseif type == Reborn_Model.RebornType.Weapon then
        return private.GetWeaponRecastDataList()
    elseif type == Reborn_Model.RebornType.Horse then
        return private.GetHorseRecastDataList()
    elseif type == Reborn_Model.RebornType.Treasure then
        return private.GetTreasureRecastDataList()
    elseif type == Reborn_Model.RebornType.HorseSoul then
        return private.GetHorseSoulRecastDataList()
    elseif type == Reborn_Model.RebornType.GodBeast then
        return private.GetGodBeastRecastDataList()
    end
end

function private.GetHeroRecastDataList()
    local list = {}
    for i, v in ipairs(MDL.HeroSelect.GetHasHeroList()) do
        local heroId = v.heroId
        if (not CTL.Formation.IsHeroInFormation(heroId)) and (not MDL.AssistanceFight.IsHeroOnAssistancePos(heroId)) and (not MDL.HeroAwaken.GetIsHeroAwaken(heroId))  then
            local starLevel = v.starLevel
            local strengthenInfo = v.StrengthenInfo
            if starLevel > 0 or v.starStage > 0 or (strengthenInfo and strengthenInfo.StrengthenLevel > 0) then
                table.insert(list, v)
            end
        end
    end
    table.sort(list, private.SortRecastHero)
    return list
end

function private.GetWeaponRecastDataList()
    local list = {}
    for i, v in ipairs(MDL.HeroSelect.GetHasHeroList()) do
        local heroId = v.heroId
        if v.isMagicWeaponActive then
            if (not CTL.Formation.IsHeroInFormation(heroId)) and (not MDL.AssistanceFight.IsHeroOnAssistancePos(heroId)) and (not MDL.HeroAwaken.GetIsHeroAwaken(heroId)) then
                if v.magicWeaponLevel > 0 or v.magicWeaponStar > 0 then
                    table.insert(list, v)
                end
            end
        end
    end
    table.sort(list, private.SortRecastWeapon)
    return list
end

function private.GetHorseRecastDataList()
    local list = {}
    for i, v in pairs(MDL.WarHorse.GetActiveHorseInfoDic()) do
        if v.HeroID == nil then
            local horseInfo = v.HorseInfo
            if horseInfo.starLevel > 0 or horseInfo.starStage > 0 then
                table.insert(list, v)
            end
        end
    end
    table.sort(list, private.SortRecastHorse)
    return list
end

function private.GetTreasureRecastDataList()
    local list = {}
    for i, v in pairs(MDL.Treasure.GetTreasureInfoList()) do
        if v.EquipHeroId == nil then
            local treasureInfo = v.TreasureInfo
            if treasureInfo.starLevel > 0 or treasureInfo.starStage > 0 then
                table.insert(list, v)
            end
        end
    end
    table.sort(list, private.SortRecastTreasure)
    return list
end

function private.SortRecastHero(heroInfoA, heroInfoB)
    local aHeroId = heroInfoA.heroId
    local bHeroId = heroInfoB.heroId
    local aHeroQuality = DataSheetManager.HeroNum:GetDataByID(aHeroId).HeroQuality
    local bHeroQuality = DataSheetManager.HeroNum:GetDataByID(bHeroId).HeroQuality
    if aHeroQuality ~= bHeroQuality then
        return aHeroQuality >= bHeroQuality
    else
        local aBreakLevel = heroInfoA.starLevel
        local bBreakLevel = heroInfoB.starLevel
        if aBreakLevel ~= bBreakLevel then
            return aBreakLevel >= bBreakLevel
        else
            return aHeroId < bHeroId
        end
    end
end

function private.SortRecastWeapon(heroInfoA, heroInfoB)
    local aHeroId = heroInfoA.heroId
    local bHeroId = heroInfoB.heroId
    local aHeroQuality = DataSheetManager.HeroNum:GetDataByID(aHeroId).HeroQuality
    local bHeroQuality = DataSheetManager.HeroNum:GetDataByID(bHeroId).HeroQuality
    if aHeroQuality ~= bHeroQuality then
        return aHeroQuality >= bHeroQuality
    else
        local aBreakLevel = heroInfoA.magicWeaponLevel
        local bBreakLevel = heroInfoB.magicWeaponLevel
        if aBreakLevel ~= bBreakLevel then
            return aBreakLevel >= bBreakLevel
        else
            return aHeroId < bHeroId
        end
    end
end

function private.SortRecastHorse(horseInfoA, horseInfoB)
    local aHorseId = horseInfoA.ID
    local bHorseId = horseInfoB.ID
    local aHorseQuality = DataSheetManager.HorseData:GetDataByHorseID(aHorseId).HorseQuality
    local bHorseQuality = DataSheetManager.HorseData:GetDataByHorseID(bHorseId).HorseQuality
    if aHorseQuality ~= bHorseQuality then
        return aHorseQuality >= bHorseQuality
    else
        local aBreakLevel = horseInfoA.HorseInfo.starLevel
        local bBreakLevel = horseInfoB.HorseInfo.starLevel
        if aBreakLevel ~= bBreakLevel then
            return aBreakLevel >= bBreakLevel
        else
            return aHorseId < bHorseId
        end
    end
end

function private.SortRecastTreasure(treasureInfoA, treasureInfoB)
    local aTreasureId = treasureInfoA.TreasureID
    local bTreasureId = treasureInfoB.TreasureID
    local aTreasureQuality = DataSheetManager.TreasureData:GetDataByTreasureID(aTreasureId).TreasureQuality
    local bTreasureQuality = DataSheetManager.TreasureData:GetDataByTreasureID(bTreasureId).TreasureQuality
    if aTreasureQuality ~= bTreasureQuality then
        return aTreasureQuality >= bTreasureQuality
    else
        local aBreakLevel = treasureInfoA.TreasureInfo.starLevel
        local bBreakLevel = treasureInfoB.TreasureInfo.starLevel
        if aBreakLevel ~= bBreakLevel then
            return aBreakLevel >= bBreakLevel
        else
            return aTreasureId < bTreasureId
        end
    end
end
--endregion

function private.SortSmeltRewards(a, b)
    local itemA = DataSheetManager.ItemData:GetDataByID(a.ItemID)
    local itemB = DataSheetManager.ItemData:GetDataByID(b.ItemID)
    local priorityA = itemA.RewardShowPriority
    local priorityB = itemB.RewardShowPriority
    if priorityA ~= priorityB then
        return priorityA > priorityB
    else
        return a.ItemID < b.ItemID
    end
end

function Reborn_Model.GetSmeltRewardByList(smeltEquipDict)
    local rewardTable = {}
    for id, v in pairs(smeltEquipDict) do
        local data = MDL.Equipment.GetEquipmentInfoByID(id)
        Reborn_Model.CombineItemList(rewardTable, data.EquipData.Item_Table)
    end
    table.sort(rewardTable, private.SortSmeltRewards)
    return rewardTable
end

function Reborn_Model.CombineItemList(sourceList, addList)
    for i, v in ipairs(addList) do
        local addItemId = v.ItemID
        local isExistItem = false
        for index, value in ipairs(sourceList) do
            if addItemId == value.ItemID then
                value.ItemNum = value.ItemNum + v.ItemNum
                isExistItem = true
                break
            end
        end
        if not isExistItem then
            table.insert(sourceList, {ItemID = addItemId, ItemNum = v.ItemNum})
        end
    end
end

function Reborn_Model.SmeltReq(equipIdDict, smeltType)
    local msg = smelt_pb.SmeltReq()
    msg.smeltType = smeltType
    for id, v in pairs(equipIdDict) do
        table.insert(msg.equipsId, id)
    end
    NetManager.SendMessage(MessageEnums.MessageSmelt, msg)
    EventSystem.Dispatch(EventID.UI_Reborn_ConfirmButtonEffect)
end

function private.SmeltResp(msgResp)
    EventSystem.Dispatch(EventID.UI_Reborn_Smelt_EquipSmeltSuccess)
end

function Reborn_Model.RecastReq(typeId, recastId)
    local msg = recast_pb.RecastReq()
    msg.typeId = typeId
    msg.recastId = recastId
    NetManager.SendMessage(MessageEnums.MessageRecast, msg)
    EventSystem.Dispatch(EventID.UI_Reborn_ConfirmButtonEffect)
    private.curRecastReqType =typeId 
end

function private.RecastResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_Reborn_Recast_RecastSuccess, private.curRecastReqType)
    end
end

------------------ Start 纳灵相关 Start ------------------
Reborn_Model.RecycleFragmentType = {
    None = recycle_fragment_handle_pb.RFNone,       -- 空状态
    Man = recycle_fragment_handle_pb.RFMan,         -- 人之灵
    Earth = recycle_fragment_handle_pb.RFEarth,     -- 地之灵
    Heaven = recycle_fragment_handle_pb.RFHeaven,   -- 天失灵
}

Reborn_Model.RFMaterialType = {
    Hero = 1,
    DivineWeapon = 2,
    ForgeWeapon = 3,
    WarHorse = 4,
    Treasure = 5,
    Stratagem = 6,
    GodBeast = 7,
}

--金色万能碎片物品Id
Reborn_Model.GoldFragmentItemID = {
    [Reborn_Model.RFMaterialType.Hero] = 301,
    [Reborn_Model.RFMaterialType.DivineWeapon] = 302,
    [Reborn_Model.RFMaterialType.WarHorse] = 303,
    [Reborn_Model.RFMaterialType.Treasure] = 304,
    [Reborn_Model.RFMaterialType.GodBeast] = 305,
}

Reborn_Model.GoldFragmentIntelligence = 20 --金色碎片对应的资质
--用于排序
Reborn_Model.FragmentType = {
    RegularFragment = 0,     -- 普通碎片
    GoldFragment = 1,        -- 万能碎片
}

local function SortMaterial(a, b)
    local dataA = private.rfMaterialDic[a.materialType][a.Id]
    local dataB = private.rfMaterialDic[b.materialType][b.Id]
    if dataA.intelligence == dataB.intelligence then
        if dataA.fragmentType == dataB.fragmentType then
            if dataA.materialType == dataB.materialType then
                if dataA.cfgId == dataB.cfgId then
                    return a.Id < b.Id
                else
                    return dataA.cfgId < dataB.cfgId
                end
            else
                return dataA.materialType < dataB.materialType
            end
        else
            return dataA.fragmentType < dataB.fragmentType
        end
    else
        return dataA.intelligence < dataB.intelligence
    end
end

function Reborn_Model.RecycleFragmentRequest(recycleFragmentType, itemIdDic)
    local msg = recycle_fragment_handle_pb.RecycleFragmentReq()
    msg.optId = recycleFragmentType
    for id, count in pairs(itemIdDic) do
        local itemInfo = recycle_fragment_handle_pb.RFItemInfos()
        local materialData = Reborn_Model.GetMaterialDataById(id)
        local itemCfgData = DataSheetManager.ItemData:GetDataByID(materialData.cfgId)
        itemInfo.id = id
        itemInfo.count = count
        itemInfo.bagTyp = itemCfgData.BagType
        table.insert(msg.itemInfos, itemInfo)
    end
    NetManager.SendMessage(MessageEnums.MessageRecycleFragment, msg)
end

function private.RecycleFragmentResponse(msgResp)
end

function Reborn_Model.SyncRecycleFragment(msg)
    -- 先刷新右侧列表
    EventSystem.Dispatch(EventID.RecycleFragment_RefreshItem, true)

    local delayTime = 0
    -- 人之灵数据
    if not private.rfInfo.Man then
        private.rfInfo.Man = {}
    end
    -- 灵区升级
    if private.rfInfo.Man.Level ~= msg.man.level then
        delayTime = Reborn_Model.TimeDelayInterval
        EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Man, true)
    else
        if private.rfInfo.Man.CurExp ~= msg.man.curExp or private.rfInfo.Man.Node ~= msg.man.node then
            delayTime = Reborn_Model.TimeDelayInterval
            EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Man, false)
        end
    end
    private.rfInfo.Man.Level = msg.man.level
    private.rfInfo.Man.CurExp = msg.man.curExp
    private.rfInfo.Man.Node = msg.man.node
    
    -- 地之灵数据
    if not private.rfInfo.Earth then
        private.rfInfo.Earth = {}
    end
    -- 灵区升级
    if private.rfInfo.Earth.Level ~= msg.earth.level then
        delayTime = Reborn_Model.TimeDelayInterval
        EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Earth, true)
    else
        if private.rfInfo.Earth.CurExp ~= msg.earth.curExp or private.rfInfo.Earth.Node ~= msg.earth.node then
            delayTime = Reborn_Model.TimeDelayInterval
            EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Earth, false)
        end
    end
    private.rfInfo.Earth.Level = msg.earth.level
    private.rfInfo.Earth.CurExp = msg.earth.curExp
    private.rfInfo.Earth.Node = msg.earth.node

    -- 天之灵数据
    if not private.rfInfo.Heaven then
        private.rfInfo.Heaven = {}
    end
        -- 灵区升级
    if private.rfInfo.Heaven.Level ~= msg.heaven.level then
        delayTime = Reborn_Model.TimeDelayInterval
        EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Heaven, true)
    else
        if private.rfInfo.Heaven.CurExp ~= msg.heaven.curExp or private.rfInfo.Heaven.Node ~= msg.heaven.node then
            delayTime = Reborn_Model.TimeDelayInterval
            EventSystem.Dispatch(EventID.RecycleFragment_AreaLevelUp, Reborn_Model.RecycleFragmentType.Heaven, false)
        end
    end
    private.rfInfo.Heaven.Level = msg.heaven.level
    private.rfInfo.Heaven.CurExp = msg.heaven.curExp
    private.rfInfo.Heaven.Node = msg.heaven.node

    -- 纳灵升级
    if private.rfInfo.Level and private.rfInfo.Level ~= msg.level then
        if delayTime > 0 then
            if private.rfLevelUpDelay then
                TimerUtil.Remove(private.rfLevelUpDelay)
                private.rfLevelUpDelay = nil
            end
            private.rfLevelUpDelay = TimerUtil.Interval(private.RefreshRFLevelUpEvent, delayTime, 1)
        else
            private.RefreshRFLevelUpEvent()
        end
        delayTime = delayTime + Reborn_Model.TimeDelayInterval
    end
    private.rfInfo.Level = msg.level
    -- 纳灵解锁
    if private.rfInfo.IsOpen == false and msg.isOpen == true then
        MDL.Unlock.Update()
    end
    private.rfInfo.IsOpen = msg.isOpen

    -- 纳灵刷新
    if delayTime > 0 then
        if private.refreshAreaDelay then
            TimerUtil.Remove(private.refreshAreaDelay)
            private.refreshAreaDelay = nil
        end
        private.refreshAreaDelay = TimerUtil.Interval(private.RefreshAreaEvent, delayTime, 1)
    else
        private.RefreshAreaEvent()
    end
    -- 区域等级、纳灵等级变化时 计算一次红点
    CTL.Reborn.CalculateRFRedPoint()
end

-- 同步各个系统碎片变化(需要在各个系统突破的回调中 调用)
-- 优化 具体系统只刷新自身的 不刷新与系统无关的 当 rfMaterialType 为空时 刷新全部
function Reborn_Model.SyncRFMaterialDic(rfMaterialType)
    local isAllReachMaxStar = false
    -- 判断武将碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.Hero or (not rfMaterialType) then
        isAllReachMaxStar = true
        private.ClearMaterialData(Reborn_Model.RFMaterialType.Hero)
        for _, v in DataSheetManager.HeroNum:GetEnumerator() do
            if CTL.HeroStar.IsHeroReachMaxStar(v.ID) then
                private.AddMaterialData(v.PieceItem, v.HeroIntelligence, Reborn_Model.RFMaterialType.Hero)
            else
                if isAllReachMaxStar and v.HeroIntelligence == Reborn_Model.GoldFragmentIntelligence then
                    isAllReachMaxStar = false
                end
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.Hero)
            end
        end
        if isAllReachMaxStar then
            private.AddMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.Hero], Reborn_Model.GoldFragmentIntelligence, Reborn_Model.RFMaterialType.Hero)
        else
            private.DelMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.Hero], Reborn_Model.RFMaterialType.Hero)
        end
    end
    -- 判断神兵突破碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.DivineWeapon or (not rfMaterialType) then
        isAllReachMaxStar = true
        private.ClearMaterialData(Reborn_Model.RFMaterialType.DivineWeapon)
        for _, v in DataSheetManager.MagicWeaponData:GetEnumerator() do
            local heroInfo = MDL.HeroSelect.GetHeroInfo(v.MagicWeaponID)
            if heroInfo and heroInfo.magicWeaponLevel == MDL.DivineWeapon.GetBreakMax(v.MagicWeaponID) then
                private.AddMaterialData(v.PieceItem, v.MagicWeaponTalent, Reborn_Model.RFMaterialType.DivineWeapon)
            else
                if isAllReachMaxStar and v.MagicWeaponTalent == Reborn_Model.GoldFragmentIntelligence then
                    isAllReachMaxStar = false
                end
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.DivineWeapon)
            end
        end
        if isAllReachMaxStar then
            private.AddMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.DivineWeapon], Reborn_Model.GoldFragmentIntelligence, Reborn_Model.RFMaterialType.DivineWeapon)
        else
            private.DelMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.DivineWeapon], Reborn_Model.RFMaterialType.DivineWeapon)
        end
    end
    -- 判断神兵铸图碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.ForgeWeapon or (not rfMaterialType) then
        private.ClearMaterialData(Reborn_Model.RFMaterialType.ForgeWeapon)
        for _, v in DataSheetManager.MagicWeaponData:GetEnumerator() do
            if CTL.DivineWeapon.IsDivineWeaponForgeMax(v.MagicWeaponID) and CTL.DivineWeaponForgeSoul.IsWeaponForgeSoulMax(v.MagicWeaponID) then
                private.AddMaterialData(v.FoundryItem, v.MagicWeaponTalent, Reborn_Model.RFMaterialType.ForgeWeapon)
            else
                private.DelMaterialData(v.FoundryItem, Reborn_Model.RFMaterialType.ForgeWeapon)
            end
        end
    end
    -- 判断坐骑碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.WarHorse or (not rfMaterialType) then
        isAllReachMaxStar = true
        private.ClearMaterialData(Reborn_Model.RFMaterialType.WarHorse)
        for _, v in DataSheetManager.HorseData:GetEnumerator() do
            local activeInfo = MDL.WarHorse.GetInfoByID(v.HorseID)
            if activeInfo and activeInfo.HorseInfo.starLevel == CTL.WarHorse.GetBreakMax(v.HorseID) then
                private.AddMaterialData(v.PieceItem, v.HorseTalent, Reborn_Model.RFMaterialType.WarHorse)
            else
                if isAllReachMaxStar and v.HorseTalent == Reborn_Model.GoldFragmentIntelligence then
                    isAllReachMaxStar = false
                end
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.WarHorse)
            end
        end
        if isAllReachMaxStar then
            private.AddMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.WarHorse], Reborn_Model.GoldFragmentIntelligence, Reborn_Model.RFMaterialType.WarHorse)
        else
            private.DelMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.WarHorse], Reborn_Model.RFMaterialType.WarHorse)
        end
    end
    -- 判断宝物碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.Treasure or (not rfMaterialType) then
        isAllReachMaxStar = true
        private.ClearMaterialData(Reborn_Model.RFMaterialType.Treasure)
        for i, v in DataSheetManager.TreasureData:GetEnumerator() do
            if MDL.Treasure.GetTreasureInfo(v.TreasureID) and CTL.Treasure.GetNextBreakItemData(v.TreasureID) == nil then
                private.AddMaterialData(v.PieceItem, v.TreasureTalent, Reborn_Model.RFMaterialType.Treasure)
            else
                if isAllReachMaxStar and v.TreasureTalent == Reborn_Model.GoldFragmentIntelligence then
                    isAllReachMaxStar = false
                end
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.Treasure)
            end
        end
        if isAllReachMaxStar then
            private.AddMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.Treasure], Reborn_Model.GoldFragmentIntelligence, Reborn_Model.RFMaterialType.Treasure)
        else
            private.DelMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.Treasure], Reborn_Model.RFMaterialType.Treasure)
        end
    end
    -- 判断计略
    if rfMaterialType == Reborn_Model.RFMaterialType.Stratagem or (not rfMaterialType) then
        private.ClearMaterialData(Reborn_Model.RFMaterialType.Stratagem)
        for _, v in DataSheetManager.StratagemData:GetEnumerator() do
            local stratagemInfo = MDL.Stratagem.GetStratagemInfo(v.ID)
            if stratagemInfo then
                local levelId = stratagemInfo.Learn.CurrLvID
                local pointId = stratagemInfo.Learn.CurrPointID
                local maxCount = DataSheetManager.StratagemLearn:GetDataLengthByID_LevelID_PointId(v.ID, levelId)
                if levelId == CTL.Stratagem.GetStratagemMaxLevel(v.ID) and pointId >= maxCount then
                    private.AddMaterialData(v.PieceItem, v.StratagemTalent, Reborn_Model.RFMaterialType.Stratagem)
                else
                    private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.Stratagem)
                end
            else
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.Stratagem)
            end
        end
    end
    -- 判断神兽碎片
    if rfMaterialType == Reborn_Model.RFMaterialType.GodBeast or (not rfMaterialType) then
        isAllReachMaxStar = true
        private.ClearMaterialData(Reborn_Model.RFMaterialType.GodBeast)
        for _, v in DataSheetManager.GodBeastData:GetEnumerator() do
            local activeInfo = MDL.GodBeast.GetGodBeastInfoByID(v.ID)
            if activeInfo and MDL.GodBeast.GetBreakStateInfo(v.ID) == MDL.GodBeast.BreakState.max then
                private.AddMaterialData(v.PieceItem, v.GodBeastTalent, Reborn_Model.RFMaterialType.GodBeast)
            else
                if isAllReachMaxStar and v.GodBeastTalent == Reborn_Model.GoldFragmentIntelligence then
                    isAllReachMaxStar = false
                end
                private.DelMaterialData(v.PieceItem, Reborn_Model.RFMaterialType.GodBeast)
            end
        end
        if isAllReachMaxStar then
            private.AddMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.GodBeast], Reborn_Model.GoldFragmentIntelligence, Reborn_Model.RFMaterialType.GodBeast)
        else
            private.DelMaterialData(Reborn_Model.GoldFragmentItemID[Reborn_Model.RFMaterialType.GodBeast], Reborn_Model.RFMaterialType.GodBeast)
        end
    end
    -- 计算 rfMaterialList 用于后面排序使用
    local index = 1
    for _, materialType in pairs(Reborn_Model.RFMaterialType) do
        local materialDic = private.rfMaterialDic[materialType]
        if materialDic then
            for _, materialData in pairs(materialDic) do
                if private.rfMaterialList[index] then
                    private.rfMaterialList[index].Id = materialData.Id
                    private.rfMaterialList[index].cfgId = materialData.cfgId
                    private.rfMaterialList[index].materialType = materialData.materialType
                else
                    table.insert(private.rfMaterialList, {Id = materialData.Id, cfgId = materialData.cfgId, materialType = materialData.materialType})
                end
                index = index + 1
            end
        end
    end
    for i = index, #private.rfMaterialList do
        table.remove(private.rfMaterialList)
    end
    table.sort(private.rfMaterialList, SortMaterial)
    EventSystem.Dispatch(EventID.RecycleFragment_RefreshItem)
    -- 有可纳灵的物品变化时 计算一次红点
    CTL.Reborn.CalculateRFRedPoint()
end

function private.AddMaterialData(cfgId, intelligence, materialType)
    -- 计算经验
    local rfExpData = DataSheetManager.RecycleFragmentExp:GetDataByRecycleFragmentTalent(intelligence)
    local exp = 0
    if materialType == Reborn_Model.RFMaterialType.Hero then
        exp = rfExpData.HeroExp
    elseif materialType == Reborn_Model.RFMaterialType.DivineWeapon then
        exp = rfExpData.MagicWeaponExp
    elseif materialType == Reborn_Model.RFMaterialType.ForgeWeapon then
        exp = rfExpData.FoundryExp
    elseif materialType == Reborn_Model.RFMaterialType.WarHorse then
        exp = rfExpData.HorseExp
    elseif materialType == Reborn_Model.RFMaterialType.Treasure then
        exp = rfExpData.TreasureExp
    elseif materialType == Reborn_Model.RFMaterialType.Stratagem then
        exp = rfExpData.StratagemExp
    elseif materialType == Reborn_Model.RFMaterialType.GodBeast then
        exp = rfExpData.GodBeastExp
    end

    local materialDic = private.rfMaterialDic[materialType]
    local itemList = MDL.Bag.GetItemsByCfgId(cfgId)
    local itemDataCfg = DataSheetManagerItemData:GetDataByID(cfgId)
    local fragmentType
    if itemDataCfg.SecondType == SecondTypeGoldFragment then
        fragmentType = MDL.Reborn.FragmentType.GoldFragment
    else
        fragmentType = MDL.Reborn.FragmentType.RegularFragment
    end
    for _, item in ipairs(itemList) do
        local count = MDL.Bag.GetOneCellItemCount(cfgId, item.Id)
        materialDic[item.Id] = {Id = item.Id, cfgId = cfgId, intelligence = intelligence, materialType = materialType, quality = rfExpData.RecycleFragmentQuality, itemExp = exp, itemCount = count, fragmentType = fragmentType}
    end
end

function private.DelMaterialData(cfgId, materialType)
    local materialDic = private.rfMaterialDic[materialType]
    if not materialDic then return end

    local itemList = MDL.Bag.GetItemsByCfgId(cfgId)
    for _, item in ipairs(itemList) do
        materialDic[item.Id] = nil
    end
end

function private.ClearMaterialData(materialType)
    local materialDic = private.rfMaterialDic[materialType]
    if not materialDic then 
        materialDic = {}
        private.rfMaterialDic[materialType] = materialDic
    end
    table.clear(materialDic)
end

-- 更新纳灵等级事件
function private.RefreshRFLevelUpEvent()
    EventSystem.Dispatch(EventID.RecycleFragment_RFLevelUp)
    -- 延迟展示升阶成功
    if private.rfLevelUpDelaySuccess then
        TimerUtil.Remove(private.rfLevelUpDelaySuccess)
        private.rfLevelUpDelaySuccess = nil
    end
    private.rfLevelUpDelaySuccess = TimerUtil.Interval(CTL.Reborn.OpenUIRFLevelUpSuccess, Reborn_Model.TimeDelayInterval, 1)
end

-- 更新纳灵界面事件
function private.RefreshAreaEvent()
    EventSystem.Dispatch(EventID.RecycleFragment_RefreshArea)
end
---------- Start 数据相关 Start ----------
local function PairsRFMaterialValue(tab, param)
    param.index = param.index + param.step
    local simpleData = tab[param.index]
    if not simpleData then return nil end
    
    local materialData = private.rfMaterialDic[simpleData.materialType][simpleData.Id]
    if param.qualityDic[materialData.quality] then
        return param, materialData
    end
    return PairsRFMaterialValue(tab, param) -- 递归遍历下一个
end

function Reborn_Model.GetRFMaterialIterator(qualityDic, isForwardDirection)
    if not private.rfIteratorTable then
        private.rfIteratorTable = {}
    end
    if isForwardDirection then
        private.rfIteratorTable.index = 0
        private.rfIteratorTable.step = 1
    else
        private.rfIteratorTable.index = #private.rfMaterialList + 1
        private.rfIteratorTable.step = -1
    end
    private.rfIteratorTable.qualityDic = qualityDic

    return PairsRFMaterialValue, private.rfMaterialList, private.rfIteratorTable
end

function Reborn_Model.GetRFMaterialListCount()
    return #private.rfMaterialList
end

function Reborn_Model.GetMaterialDataByCfgId(cfgId)
    for _, v in ipairs(private.rfMaterialList) do
        if v.cfgId == cfgId then
            return private.rfMaterialDic[v.materialType][v.Id]
        end
    end
    return nil
end

function Reborn_Model.GetMaterialDataById(Id)
    for _, v in ipairs(private.rfMaterialList) do
        if v.Id == Id then
            return private.rfMaterialDic[v.materialType][Id]
        end
    end
    return nil
end

function Reborn_Model.GetRecycleFragmentIsOpen()
    if private.rfInfo.IsOpen ~= nil then
        return private.rfInfo.IsOpen
    end
    return false
end

function Reborn_Model.GetRecycleFragmentLevel()
    if private.rfInfo.Level then
        return private.rfInfo.Level
    end
    return 0
end

function Reborn_Model.GetRFAreaInfoByType(rfType)
    if rfType == Reborn_Model.RecycleFragmentType.Man then
        return private.rfInfo.Man
    elseif rfType == Reborn_Model.RecycleFragmentType.Earth then
        return private.rfInfo.Earth
    elseif rfType == Reborn_Model.RecycleFragmentType.Heaven then
        return private.rfInfo.Heaven
    end
    return nil
end
------------ End 数据相关 End ------------
-------------------- End 纳灵相关 End --------------------

--region ----------------- 魂珠 ---------------------
function private.GetHorseSoulRecastRewardList(id)
    local recastRewardList = {}
    local soulInfo = MDL.HorseSoul.GetSoulInfoById(id)
    if soulInfo.star > 0 then
        local starItemNum = 0
        for i, soulStarData in DataSheetManager.HorseSoulStarData:GetDataByHorseSoulStarAttrID_Star(soulInfo.soulData.HorseSoulStarAttrID) do
            if soulStarData.Star <= soulInfo.star then
                starItemNum = starItemNum + soulStarData.NeedSoulNum
            end
        end
        table.insert(recastRewardList, {ItemID = soulInfo.cfgId, ItemNum = starItemNum})
    end

    if soulInfo.levelInfo.level > 1 then
        local breakItemID, breakItemCount = 0,0
        local exp = soulInfo.levelInfo.curExp
        for i, soulLevelData in DataSheetManager.HorseSoulLevelData:GetDataByHorseSoulLevelAttrID_Level(soulInfo.soulData.HorseSoulLevelAttrID) do
            if soulLevelData.Level <= soulInfo.levelInfo.level then
                exp = exp + soulLevelData.LevelEXP
                if soulLevelData.Level <= soulInfo.levelInfo.breakLevel and soulLevelData.Level <= soulInfo.levelInfo.level and soulLevelData.BreakType > 0 then
                    local breakData = DataSheetManager.HorseSoulBreakData:GetDataByBreakType(soulLevelData.BreakType)
                    breakItemID = breakData.BreakGeneralItem
                    breakItemCount = breakItemCount + breakData.UseItemNum
                end
            end
        end
        if breakItemID > 0 then
            table.insert(recastRewardList, {ItemID = breakItemID, ItemNum = breakItemCount})
        end
        local itemCount = math.floor(exp/HorseSoulLevelGeneralItemExp)
        table.insert(recastRewardList, {ItemID = HorseSoulLevelGeneralItem, ItemNum = itemCount})
    end

    return recastRewardList
end

function private.GetHorseSoulRecastDataList()
    local horseSoulRecastList = {}
    for i, v in ipairs(MDL.HorseSoul.GetSoulItemList()) do
        local soulInfo = MDL.HorseSoul.GetSoulInfoById(v)
        if type(soulInfo.equipHorseId) ~= "number" and soulInfo.itemData.Color >= LuaConst.QualityColor.Gold then
            if soulInfo.levelInfo.level > 1 or soulInfo.star > 0 then
                table.insert(horseSoulRecastList, soulInfo)
            end
        end
    end

    return horseSoulRecastList
end
--endregion ----------------- 魂珠 ---------------------


--神兽
function private.SortGodBeastRecastReward(rewardItemDataA, rewardItemDataB)
    local aItemId = rewardItemDataA.ItemID
    local bItemId = rewardItemDataB.ItemID
    local aItemData = DataSheetManager.ItemData:GetDataByID(aItemId)
    local bItemData = DataSheetManager.ItemData:GetDataByID(bItemId)
    local aFirstType = aItemData.FirstType
    local bFirstType = bItemData.FirstType
    if aFirstType ~= bFirstType then
        --神兽碎片要排在最前
        if aFirstType == LuaConst.ItemType.GodBeast then
            return true
        elseif bFirstType == LuaConst.ItemType.GodBeast then
            return false
        else
            return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
        end
    else
        return private.SortItemByQuality(rewardItemDataA, rewardItemDataB)
    end
end

private.GodBeastRecastRewardList = {}
function private.GetGodBeastRecastRewardList(godbeastID)
    if private.GodBeastRecastRewardList[godbeastID] then
        return private.GodBeastRecastRewardList[godbeastID]
    end
    local rewardTable = {}
    local godBeastData = MDL.GodBeast.GetGodBeastInfoByID(godbeastID)
    local starLevel = godBeastData.starLevel
    for i = 0, starLevel - 1 do
        local smallBreakTimes = MDL.GodBeast.GetBreakWheelCount(godbeastID, i)
        local breakStarData = DataSheetManager.GodBeastStar:GetDataByID_Star(godbeastID, i)
        local activeItemTb = DataSheetManager.GodBeastStarItemRepeat:GetDataByID(breakStarData.WheelCostRepeatID).Item_Table
        local breakItemID, breakItemCount = 0,0
        for i, v in ipairs(activeItemTb) do
            breakItemID = v.ItemID
            breakItemCount = v.ItemNum * smallBreakTimes
            Reborn_Model.CombineItemList(rewardTable, {{ItemID = breakItemID, ItemNum = breakItemCount}})
        end

        local activeItemTb = DataSheetManager.GodBeastStarItemRepeat:GetDataByID(breakStarData.StarCostRepeatID).Item_Table
        Reborn_Model.CombineItemList(rewardTable, activeItemTb)
    end

    local curSmallBreakTimes = MDL.GodBeast.GetCurBreakWheelCount(godbeastID)
    local breakStarData = DataSheetManager.GodBeastStar:GetDataByID_Star(godbeastID, starLevel)
    if breakStarData.WheelCostRepeatID and breakStarData.WheelCostRepeatID ~= 0 then
        local activeItemTb = DataSheetManager.GodBeastStarItemRepeat:GetDataByID(breakStarData.WheelCostRepeatID).Item_Table
        local breakItemID, breakItemCount = 0,0
        for i, v in ipairs(activeItemTb) do
            breakItemID = v.ItemID
            breakItemCount = v.ItemNum * curSmallBreakTimes
            Reborn_Model.CombineItemList(rewardTable, {{ItemID = breakItemID, ItemNum = breakItemCount}})
        end
    end

    table.sort(rewardTable, private.SortGodBeastRecastReward)
    private.GodBeastRecastRewardList[godbeastID] = rewardTable
    return rewardTable
end

function private.SortRecastGodBeast(godBeastA, godBeastB)
    local godBeastAId = godBeastA.godBeastId
    local godBeastBId = godBeastB.godBeastId
    local aGodBeastQuality = DataSheetManager.GodBeastData:GetDataByID(godBeastAId).GodBeastQuality
    local bGodBeastQuality = DataSheetManager.GodBeastData:GetDataByID(godBeastBId).GodBeastQuality
    if aGodBeastQuality ~= bGodBeastQuality then
        return aGodBeastQuality >= bGodBeastQuality
    else
        local aBreakLevel = godBeastA.starLevel
        local bBreakLevel = godBeastB.starLevel
        if aBreakLevel ~= bBreakLevel then
            return aBreakLevel >= bBreakLevel
        else
            return godBeastAId < godBeastBId
        end
    end
end

function private.GetGodBeastRecastDataList()
    local godBeastRecastList = {}
    for i, v in pairs(MDL.GodBeast.GetActiveBeastInfoDic()) do
        if not MDL.GodBeast.IsBeastInLineup(v.godBeastId) then
            local godBeastData = DataSheetManager.GodBeastData:GetDataByID(v.godBeastId)
            if v.starLevel > godBeastData.CanRebirthStarLevel or MDL.GodBeast.GetCurBreakWheelCount(v.godBeastId) > 0 then
                table.insert(godBeastRecastList, v)
            end
        end
    end
    table.sort(godBeastRecastList, private.SortRecastGodBeast)
    return godBeastRecastList
end

--清空重生计算缓存，目前仅神兽进行了缓存
function Reborn_Model.ResetRecastRewardList()
    table.clear(private.GodBeastRecastRewardList)
end

return Reborn_Model