private void Refresh()
        {
            UnitData data1 = (UnitData)null;

            if (UnityEngine.Object.op_Implicit((UnityEngine.Object)UnitEnhanceV3.Instance))
            {
                data1 = UnitEnhanceV3.Instance.CurrentUnit;
            }
            if (data1 == null)
            {
                data1 = MonoSingleton <GameManager> .Instance.Player.FindUnitDataByUniqueID((long)GlobalVars.SelectedUnitUniqueID);
            }
            if (data1 == null && AbilityDetailWindow.BindObject != null)
            {
                data1 = AbilityDetailWindow.BindObject;
            }
            if (data1 == null)
            {
                DebugUtility.LogError("Not found bind unit data.");
            }
            else
            {
                AbilityData  abilityData  = data1.GetAbilityData((long)GlobalVars.SelectedAbilityUniqueID);
                AbilityParam abilityParam = MonoSingleton <GameManager> .Instance.GetAbilityParam((string)GlobalVars.SelectedAbilityID);

                QuestClearUnlockUnitDataParam[]      unlockedSkills          = data1.UnlockedSkills;
                List <QuestClearUnlockUnitDataParam> unlockUnitDataParamList = new List <QuestClearUnlockUnitDataParam>();
                QuestClearUnlockUnitDataParam[]      allUnlockUnitDatas      = MonoSingleton <GameManager> .Instance.MasterParam.GetAllUnlockUnitDatas();

                if (allUnlockUnitDatas != null)
                {
                    for (int index = 0; index < allUnlockUnitDatas.Length; ++index)
                    {
                        // ISSUE: object of a compiler-generated type is created
                        // ISSUE: variable of a compiler-generated type
                        AbilityDetailWindow.\u003CRefresh\u003Ec__AnonStorey2F5 refreshCAnonStorey2F5 = new AbilityDetailWindow.\u003CRefresh\u003Ec__AnonStorey2F5();
                        // ISSUE: reference to a compiler-generated field
                        refreshCAnonStorey2F5.param = allUnlockUnitDatas[index];
                        // ISSUE: reference to a compiler-generated field
                        // ISSUE: reference to a compiler-generated field
                        // ISSUE: reference to a compiler-generated field
                        // ISSUE: reference to a compiler-generated method
                        if (refreshCAnonStorey2F5.param.type == QuestClearUnlockUnitDataParam.EUnlockTypes.Skill && refreshCAnonStorey2F5.param.uid == data1.UnitID && refreshCAnonStorey2F5.param.parent_id == abilityParam.iname && (unlockedSkills == null || Array.FindIndex <QuestClearUnlockUnitDataParam>(unlockedSkills, new Predicate <QuestClearUnlockUnitDataParam>(refreshCAnonStorey2F5.\u003C\u003Em__2F6)) == -1))
                        {
                            // ISSUE: reference to a compiler-generated field
                            unlockUnitDataParamList.Add(refreshCAnonStorey2F5.param);
                        }
                    }
                }
                RarityParam rarityParam = MonoSingleton <GameManager> .Instance.GetRarityParam((int)data1.UnitParam.raremax);

                int num = Math.Min((int)rarityParam.UnitLvCap + (int)rarityParam.UnitAwakeLvCap, abilityParam.GetRankCap());
                DataSource.Bind <UnitData>(((Component)this).get_gameObject(), data1);
                DataSource.Bind <AbilityData>(((Component)this).get_gameObject(), abilityData);
                AbilityParam data2 = abilityParam;
                if (AbilityDetailWindow.IsEnableSkillChange)
                {
                    string key = data1.SearchAbilityReplacementSkill(abilityParam.iname);
                    if (!string.IsNullOrEmpty(key))
                    {
                        data2 = MonoSingleton <GameManager> .Instance.GetAbilityParam(key);
                    }
                }
                DataSource.Bind <AbilityParam>(((Component)this).get_gameObject(), data2);
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SkillTemplate, (UnityEngine.Object)null))
                {
                    List <SkillParam> skillParamList = new List <SkillParam>();
                    if (abilityData != null && abilityData.LearningSkills != null)
                    {
                        for (int index1 = 0; index1 < abilityData.LearningSkills.Length; ++index1)
                        {
                            if (abilityData.LearningSkills[index1].locklv <= num)
                            {
                                string str1 = abilityData.LearningSkills[index1].iname;
                                if (unlockedSkills != null)
                                {
                                    for (int index2 = 0; index2 < unlockedSkills.Length; ++index2)
                                    {
                                        if (unlockedSkills[index2].old_id == str1)
                                        {
                                            str1 = unlockedSkills[index2].new_id;
                                            break;
                                        }
                                    }
                                }
                                if (AbilityDetailWindow.IsEnableSkillChange)
                                {
                                    string str2 = data1.SearchReplacementSkill(str1);
                                    if (!string.IsNullOrEmpty(str2))
                                    {
                                        str1 = str2;
                                    }
                                }
                                skillParamList.Add(MonoSingleton <GameManager> .Instance.GetSkillParam(str1));
                            }
                        }
                        if (unlockedSkills != null)
                        {
                            for (int index = 0; index < unlockedSkills.Length; ++index)
                            {
                                if (unlockedSkills[index].add && unlockedSkills[index].parent_id == abilityData.AbilityID)
                                {
                                    skillParamList.Add(MonoSingleton <GameManager> .Instance.GetSkillParam(unlockedSkills[index].new_id));
                                }
                            }
                        }
                    }
                    else
                    {
                        for (int index = 0; index < abilityParam.skills.Length; ++index)
                        {
                            if (abilityParam.skills[index].locklv <= num)
                            {
                                skillParamList.Add(MonoSingleton <GameManager> .Instance.GetSkillParam(abilityParam.skills[index].iname));
                            }
                        }
                    }
                    if (abilityData == data1.MasterAbility && data1.CollaboAbility != null)
                    {
                        using (List <SkillData> .Enumerator enumerator = data1.CollaboAbility.Skills.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                SkillData current = enumerator.Current;
                                skillParamList.Add(current.SkillParam);
                            }
                        }
                    }
                    for (int index = 0; index < skillParamList.Count; ++index)
                    {
                        GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.SkillTemplate);
                        DataSource.Bind <SkillParam>(gameObject, skillParamList[index]);
                        gameObject.get_transform().SetParent(this.SkillLayoutParent, false);
                        gameObject.SetActive(true);
                    }
                    for (int index = 0; index < unlockUnitDataParamList.Count; ++index)
                    {
                        GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.SkillLockedTemplate);
                        DataSource.Bind <SkillParam>(gameObject, MonoSingleton <GameManager> .Instance.GetSkillParam(unlockUnitDataParamList[index].new_id));
                        DataSource.Bind <QuestClearUnlockUnitDataParam>(gameObject, unlockUnitDataParamList[index]);
                        gameObject.get_transform().SetParent(this.SkillLayoutParent, false);
                        gameObject.SetActive(true);
                    }
                }
                GameParameter.UpdateAll(((Component)this).get_gameObject());
            }
        }
        private void Refresh()
        {
            UnitData data1 = (UnitData)null;

            if (UnityEngine.Object.op_Implicit((UnityEngine.Object)UnitEnhanceV3.Instance))
            {
                data1 = UnitEnhanceV3.Instance.CurrentUnit;
            }
            if (data1 == null)
            {
                data1 = MonoSingleton <GameManager> .Instance.Player.FindUnitDataByUniqueID((long)GlobalVars.SelectedUnitUniqueID);
            }
            if (data1 == null && AbilityDetailWindow.BindUnit != null)
            {
                data1 = AbilityDetailWindow.BindUnit;
            }
            if (data1 == null && AbilityDetailWindow.BindAbility == null)
            {
                DebugUtility.LogError("Not found bind unit data.");
            }
            else
            {
                if (AbilityDetailWindow.BindAbility != null)
                {
                    DataSource.Bind <AbilityParam>(((Component)this).get_gameObject(), AbilityDetailWindow.BindAbility);
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SkillTemplate, (UnityEngine.Object)null))
                    {
                        List <AbilityDetailWindow.ViewContentParam> viewContentParams = new List <AbilityDetailWindow.ViewContentParam>();
                        if (AbilityDetailWindow.BindAbility.skills != null)
                        {
                            for (int index = 0; index < AbilityDetailWindow.BindAbility.skills.Length; ++index)
                            {
                                SkillParam skillParam = MonoSingleton <GameManager> .Instance.GetSkillParam(AbilityDetailWindow.BindAbility.skills[index].iname);

                                AbilityDetailWindow.AddSkillParam(viewContentParams, skillParam, (SkillDeriveParam)null);
                            }
                        }
                        for (int index = 0; index < viewContentParams.Count; ++index)
                        {
                            GameObject      gameObject          = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.SkillTemplate);
                            SkillDeriveList componentInChildren = (SkillDeriveList)gameObject.GetComponentInChildren <SkillDeriveList>();
                            componentInChildren.Setup(viewContentParams[index].m_SkillParam, viewContentParams[index].m_SkillDeriveParams);
                            gameObject.get_transform().SetParent(this.SkillLayoutParent, false);
                            gameObject.SetActive(true);
                            this.m_SkillDeriveList.Add(componentInChildren);
                        }
                    }
                }
                else
                {
                    AbilityData  data2        = data1.GetAbilityData((long)GlobalVars.SelectedAbilityUniqueID);
                    AbilityParam abilityParam = MonoSingleton <GameManager> .Instance.GetAbilityParam((string)GlobalVars.SelectedAbilityID);

                    QuestClearUnlockUnitDataParam[]      unlockedSkills          = data1.UnlockedSkills;
                    List <QuestClearUnlockUnitDataParam> unlockUnitDataParamList = new List <QuestClearUnlockUnitDataParam>();
                    QuestClearUnlockUnitDataParam[]      allUnlockUnitDatas      = MonoSingleton <GameManager> .Instance.MasterParam.GetAllUnlockUnitDatas();

                    if (allUnlockUnitDatas != null)
                    {
                        for (int index = 0; index < allUnlockUnitDatas.Length; ++index)
                        {
                            QuestClearUnlockUnitDataParam param = allUnlockUnitDatas[index];
                            if (param.type == QuestClearUnlockUnitDataParam.EUnlockTypes.Skill && param.uid == data1.UnitID && param.parent_id == abilityParam.iname && (unlockedSkills == null || Array.FindIndex <QuestClearUnlockUnitDataParam>(unlockedSkills, (Predicate <QuestClearUnlockUnitDataParam>)(p => p.iname == param.iname)) == -1))
                            {
                                unlockUnitDataParamList.Add(param);
                            }
                        }
                    }
                    if (data2 != null && data2.Param != null && data2.IsDeriveBaseAbility)
                    {
                        data2 = data2.DerivedAbility;
                    }
                    RarityParam rarityParam = MonoSingleton <GameManager> .Instance.GetRarityParam((int)data1.UnitParam.raremax);

                    int num = Math.Min((int)rarityParam.UnitLvCap + (int)rarityParam.UnitAwakeLvCap, abilityParam.GetRankCap());
                    DataSource.Bind <UnitData>(((Component)this).get_gameObject(), data1);
                    DataSource.Bind <AbilityData>(((Component)this).get_gameObject(), data2);
                    AbilityParam data3 = abilityParam;
                    if (AbilityDetailWindow.IsEnableSkillChange)
                    {
                        string key = data1.SearchAbilityReplacementSkill(abilityParam.iname);
                        if (!string.IsNullOrEmpty(key))
                        {
                            data3 = MonoSingleton <GameManager> .Instance.GetAbilityParam(key);
                        }
                    }
                    DataSource.Bind <AbilityParam>(((Component)this).get_gameObject(), data3);
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.SkillTemplate, (UnityEngine.Object)null))
                    {
                        List <AbilityDetailWindow.ViewContentParam> viewContentParams = new List <AbilityDetailWindow.ViewContentParam>();
                        if (data2 != null && data2.LearningSkills != null)
                        {
                            for (int index1 = 0; index1 < data2.LearningSkills.Length; ++index1)
                            {
                                if (data2.LearningSkills[index1].locklv <= num)
                                {
                                    string str1 = data2.LearningSkills[index1].iname;
                                    if (unlockedSkills != null)
                                    {
                                        for (int index2 = 0; index2 < unlockedSkills.Length; ++index2)
                                        {
                                            if (unlockedSkills[index2].old_id == str1)
                                            {
                                                str1 = unlockedSkills[index2].new_id;
                                                break;
                                            }
                                        }
                                    }
                                    if (AbilityDetailWindow.IsEnableSkillChange)
                                    {
                                        string str2 = data1.SearchReplacementSkill(str1);
                                        if (!string.IsNullOrEmpty(str2))
                                        {
                                            str1 = str2;
                                        }
                                    }
                                    SkillData[] deriveSkills = data2.FindDeriveSkills(str1);
                                    if (deriveSkills.Length > 0)
                                    {
                                        foreach (SkillData skillData in deriveSkills)
                                        {
                                            AbilityDetailWindow.AddSkillParam(viewContentParams, skillData.SkillParam, skillData.DeriveParam);
                                        }
                                    }
                                    else
                                    {
                                        AbilityDetailWindow.AddSkillParam(viewContentParams, MonoSingleton <GameManager> .Instance.GetSkillParam(str1), (SkillDeriveParam)null);
                                    }
                                }
                            }
                            if (unlockedSkills != null)
                            {
                                for (int index = 0; index < unlockedSkills.Length; ++index)
                                {
                                    if (unlockedSkills[index].add && unlockedSkills[index].parent_id == data2.AbilityID)
                                    {
                                        AbilityDetailWindow.AddSkillParam(viewContentParams, MonoSingleton <GameManager> .Instance.GetSkillParam(unlockedSkills[index].new_id), (SkillDeriveParam)null);
                                    }
                                }
                            }
                        }
                        else
                        {
                            for (int index = 0; index < abilityParam.skills.Length; ++index)
                            {
                                if (abilityParam.skills[index].locklv <= num)
                                {
                                    AbilityDetailWindow.AddSkillParam(viewContentParams, MonoSingleton <GameManager> .Instance.GetSkillParam(abilityParam.skills[index].iname), (SkillDeriveParam)null);
                                }
                            }
                        }
                        if (data1.MasterAbility != null && data1.CollaboAbility != null)
                        {
                            AbilityData abilityData = data1.MasterAbility;
                            if (data1.MasterAbility.IsDeriveBaseAbility)
                            {
                                abilityData = data1.MasterAbility.DerivedAbility;
                            }
                            if (abilityData == data2)
                            {
                                using (List <SkillData> .Enumerator enumerator = data1.CollaboAbility.Skills.GetEnumerator())
                                {
                                    while (enumerator.MoveNext())
                                    {
                                        SkillData current = enumerator.Current;
                                        AbilityDetailWindow.AddSkillParam(viewContentParams, current.SkillParam, (SkillDeriveParam)null);
                                    }
                                }
                            }
                        }
                        for (int index = 0; index < viewContentParams.Count; ++index)
                        {
                            GameObject      gameObject          = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.SkillTemplate);
                            SkillDeriveList componentInChildren = (SkillDeriveList)gameObject.GetComponentInChildren <SkillDeriveList>();
                            componentInChildren.Setup(viewContentParams[index].m_SkillParam, viewContentParams[index].m_SkillDeriveParams);
                            gameObject.get_transform().SetParent(this.SkillLayoutParent, false);
                            gameObject.SetActive(true);
                            this.m_SkillDeriveList.Add(componentInChildren);
                        }
                        for (int index = 0; index < unlockUnitDataParamList.Count; ++index)
                        {
                            GameObject gameObject = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.SkillLockedTemplate);
                            DataSource.Bind <SkillParam>(gameObject, MonoSingleton <GameManager> .Instance.GetSkillParam(unlockUnitDataParamList[index].new_id));
                            DataSource.Bind <QuestClearUnlockUnitDataParam>(gameObject, unlockUnitDataParamList[index]);
                            gameObject.get_transform().SetParent(this.SkillLayoutParent, false);
                            gameObject.SetActive(true);
                        }
                        for (int index = 0; index < viewContentParams.Count; ++index)
                        {
                            if (viewContentParams[index].m_SkillDeriveParams != null && viewContentParams[index].m_SkillDeriveParams.Count >= 1)
                            {
                                this.m_ShowBaseToggle.set_interactable(true);
                                break;
                            }
                        }
                    }
                }
                GameParameter.UpdateAll(((Component)this).get_gameObject());
            }
        }