using IVDataFormat;
using Spine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Vector3 = UnityEngine.Vector3;

public class EnhanceMgr : MonoBehaviour
{
    #region Const
    private static EnhanceMgr curMgr = null;
    #endregion Const

    #region UI
    [Header("UI")]
    [SerializeField]
    private TextMeshProUGUI txtMainT;
    [SerializeField]
    GameObject mainEnhanceBedge;
    [SerializeField]
    GameObject goldEnhanceBedge;
    [SerializeField]
    GameObject pointEnhanceBedge;

    [SerializeField]
    private Canvas canvasUI;
    [SerializeField]
    private Canvas leftWindow;
    private ButtonIV[] btnTabs;
    Image[] imgTabLineBottoms;
    Image[] imgTabLineRights;

    private GameObject[] groupTabs;

    [SerializeField]
    EScrController escrCharGoldEnhance;
    [SerializeField]
    EScrController escrCharLvPointEnhance;
    [SerializeField]
    EScrController escrAutoRerollConfig;
    [SerializeField]
    EScrController escrAwakenDungeon;


    GameObject goldMulti;
    GameObject lvPointMulti;
    GameObject AwakenImage;
    GameObject AwakenBottom;

    [SerializeField]
    ButtonIV[] goldMultiButton;
    [SerializeField]
    ButtonIV[] lvPointMultiButton;

    [SerializeField] ViewGroup tabGoldViewGroup;
    [SerializeField] ViewGroup tabLvPointViewGroup;
    [SerializeField] ViewGroup tabAwakenViewGroup;
    #endregion UI

    private int iLoading = 1;
    private bool bReLocalize = true;
    private bool bReLocalizeGold, bReLocalizeLvPoint, bReLocalizeAwaken = false;
    private bool bInitNeed = true;
    private bool bInitNeedGold = true;
    private bool bInitNeedLvPoint = true;
    private bool blnitNeedAwaken = true;
    private int iSelectedTab = -1;

    private int iLoadCos = 0;
    private Texture2D tx2dSelectedCloth = null;


    #region LeftWindow
    TextMeshProUGUI txtLeftWindow;
    GameObject myInfo;
    GameObject myAwaken;
    GameObject ChangeButtonSet;
    GameObject AutoChanging;
    GameObject AutoConfig;
    TextMeshProUGUI txtInfo;
    TextMeshProUGUI txtProgress;
    TextMeshProUGUI txtRareity;
    RareityAutoReroll[] rareityAutos;
    GameObject SelectConfig;
    ButtonIV btnAutoSpend;
    TextMeshProUGUI txtSelectConfig;
    [SerializeField]
    ButtonIV btnStoneSpend;
    TextMeshProUGUI txtChange;
    TextMeshProUGUI txtChangeCost;
    [SerializeField]
    ButtonIV btnStoneSpendAuto;
    TextMeshProUGUI txtChangeAuto;
    TextMeshProUGUI txtChangeCostAuto;

    GameObject goLeftBtnInfo;
    GameObject goLeftBack;
    #endregion

    #region PlayerInfo
    GameObject playerLevelInfo;
    TextMeshProUGUI lvTxt;
    TextMeshProUGUI lvPercentTxt;
    Slider ExpFill;
    ButtonIV btnReset;
    TextMeshProUGUI txtReset;
    TextMeshProUGUI txtPrice;
    Image imgPicon;
    #endregion


    #region Awaken
    [SerializeField]
    GameObject awakenLock;
    [SerializeField]
    GameObject awakenVerticalList;
    [SerializeField]
    GameObject awakenButtonPrefab;
    AwakenItem[] awakenButton;
    int rerollCost;
    [SerializeField]
    TextMeshProUGUI txtExam;
    [SerializeField]
    TextMeshProUGUI txtRewardList;
    //[SerializeField]
    //TextMeshProUGUI txtRewardAwakenSlotNumber;
    [SerializeField]
    TextMeshProUGUI txtRewardDia;
    [SerializeField]
    GameObject awakenAutoButton;

    [SerializeField]
    ButtonIV[] btnAbilityPreset;
    [SerializeField]
    TextMeshProUGUI txtSave;
    [SerializeField]
    TextMeshProUGUI txtEffect, txtValue;

    private eEffectType[] efcOptions;
    private bool[] bSelectedOptions;
    #endregion

    #region MyInfo

    [SerializeField]
    private IVCharSimple ivChar;

    [SerializeField]
    GameObject StatInfoT;
    TextMeshProUGUI[] charInfoNameT;
    TextMeshProUGUI[] charInfoNumberT;

    [SerializeField]
    GameObject StatInfoB;
    TextMeshProUGUI[] charInfoNameB;
    TextMeshProUGUI[] charInfoNumberB;
    #endregion


    #region Base
    public static void SLocalize(bool bmain)
    {
        if (curMgr != null)
            curMgr.Localize(bmain);
    }

    // 번역.
    private void Localize(bool bmain)
    {
        if (bmain)
        {
            txtMainT.text = LocalizationText.GetText("enhance_title");
        }
        else
        {
            bReLocalize = false;
            canvasUI.transform.Find("txtT").GetComponent<TextMeshProUGUI>().text = LocalizationText.GetText("enhance_title");

            btnTabs[0].transform.Find("txt").GetComponent<TextMeshProUGUI>().text = LocalizationText.GetText("enhance_gold");
            btnTabs[1].transform.Find("txt").GetComponent<TextMeshProUGUI>().text = LocalizationText.GetText("enhance_lvpoint");
            btnTabs[2].transform.Find("txt").GetComponent<TextMeshProUGUI>().text = LocalizationText.GetText("enhance_awaken");

            txtInfo.text = LocalizationText.GetText("awaken_auto_info");
            txtRareity.text = LocalizationText.GetText("awaken_grade_kind");
            for (int i = 0; i < rareityAutos.Length; i++)
                rareityAutos[i].Localize();

            txtSelectConfig.text = LocalizationText.GetText("awaken_ability_kind");
            txtProgress.text = LocalizationText.GetText("all_autoprocessing");

            txtChange.text = LocalizationText.GetText("all_changego");
            txtChangeAuto.text = LocalizationText.GetText("all_changego");

            txtExam.text = LocalizationText.GetText("awaken_dungeon_title");
            txtRewardList.text = LocalizationText.GetText("reward_list");
            txtSave.text = LocalizationText.GetText("all_save");

            for (int i = 0; i < charInfoNameT.Length; i++)
            {
                charInfoNameT[i].text = LocalizationText.GetText(FormatString.CombineAllString("stat_kind_top", (i + 1).ToString()));
            }
            for (int i = 0; i < charInfoNameB.Length; i++)
            {
                charInfoNameB[i].text = LocalizationText.GetText(FormatString.CombineAllString("stat_kind_bottom", (i + 1).ToString()));
            }
        }
    }

    // 설정에서 언어 변경 시 처리.
    public static void SReLocalize()
    {
        curMgr.Localize(true);
        curMgr.bReLocalize = true;
        curMgr.bReLocalizeGold = true;
        curMgr.bReLocalizeLvPoint = true;
        curMgr.bReLocalizeAwaken = true;
    }

    private void Awake()
    {
        curMgr = this;
    }

    void Start()
    {
        CheckBedge();
        StartSetAwakenPreset();
        iLoading--;
    }

    private void Init()
    {
        bInitNeed = false;
        btnTabs = canvasUI.transform.Find("tabWrapTop").GetComponentsInChildren<ButtonIV>(true);

        goldEnhanceBedge = btnTabs[0].transform.Find("badge").gameObject;
        pointEnhanceBedge = btnTabs[1].transform.Find("badge").gameObject;

        imgTabLineBottoms = new Image[btnTabs.Length];
        imgTabLineRights = new Image[btnTabs.Length];

        for (int i = 0; i < btnTabs.Length; i++)
        {
            imgTabLineBottoms[i] = btnTabs[i].transform.Find("linebottom").GetComponent<Image>();
            imgTabLineRights[i] = btnTabs[i].transform.Find("lineright").GetComponent<Image>();
        }

        groupTabs = new GameObject[btnTabs.Length];
        groupTabs[0] = canvasUI.transform.Find("SvGold").gameObject;
        groupTabs[1] = canvasUI.transform.Find("SvLvPoint").gameObject;
        groupTabs[2] = canvasUI.transform.Find("SvAwaken").gameObject;

        goldMulti = canvasUI.transform.Find("MultiGoldGroup").gameObject;
        lvPointMulti = canvasUI.transform.Find("LvPointGroup").gameObject;
        playerLevelInfo = lvPointMulti.transform.Find("PlayerLvInfo").gameObject;
        AwakenImage = canvasUI.transform.Find("AwakenImage").gameObject;
        AwakenBottom = canvasUI.transform.Find("AwakenBottom").gameObject;

        lvTxt = playerLevelInfo.transform.Find("Lvtxt").GetComponent<TextMeshProUGUI>();
        lvPercentTxt = playerLevelInfo.transform.Find("LvPercenttxt").GetComponent<TextMeshProUGUI>();
        ExpFill = playerLevelInfo.transform.Find("sliderBg").GetComponent<Slider>();
        btnReset = playerLevelInfo.transform.Find("btnReset").GetComponent<ButtonIV>();
        imgPicon = playerLevelInfo.transform.Find("picon").GetComponent<Image>();
        imgPicon.sprite = AddressableMgr.GetPlayerIcon(DataHandler.PlayData.playerIcon);
        txtReset = btnReset.transform.Find("txtReset").GetComponent<TextMeshProUGUI>();
        txtPrice = btnReset.transform.Find("txtPrice").GetComponent<TextMeshProUGUI>();

        awakenButton = new AwakenItem[6];

        txtLeftWindow = leftWindow.transform.Find("txtT").GetComponent<TextMeshProUGUI>();
        myInfo = leftWindow.transform.Find("MyInfo").gameObject;
        myAwaken = leftWindow.transform.Find("MyAwaken").gameObject;
        AutoConfig = leftWindow.transform.Find("AutoConfig").gameObject;
        txtInfo = AutoConfig.transform.Find("txtInfo").GetComponent<TextMeshProUGUI>();
        txtRareity = AutoConfig.transform.Find("RareitySet").Find("txtRareity").GetComponent<TextMeshProUGUI>();
        rareityAutos = AutoConfig.transform.Find("RareitySet").Find("rareitySelect").GetComponentsInChildren<RareityAutoReroll>(true);
        for (int i = 0; i < rareityAutos.Length; i++)
            rareityAutos[i].Init();

        SelectConfig = AutoConfig.transform.Find("SelectConfig").gameObject;
        btnAutoSpend = SelectConfig.transform.Find("btnStoneSpend (1)").GetComponent<ButtonIV>();
        txtSelectConfig = SelectConfig.transform.Find("txtSelectConfig").GetComponent<TextMeshProUGUI>();
        goLeftBack = leftWindow.transform.Find("back").gameObject;
        goLeftBtnInfo = myAwaken.transform.Find("btnInfo").gameObject;
        ChangeButtonSet = myAwaken.transform.Find("ChangeButtonSet").gameObject;
        AutoChanging = myAwaken.transform.Find("AutoChanging").gameObject;
        txtProgress = AutoChanging.transform.Find("txtProgress").GetComponent<TextMeshProUGUI>();

        txtChange = btnStoneSpend.transform.Find("txtChange").GetComponent<TextMeshProUGUI>();
        txtChangeCost = btnStoneSpend.transform.Find("txtPrice").GetComponent<TextMeshProUGUI>();

        txtChangeAuto = btnStoneSpendAuto.transform.Find("txtChange").GetComponent<TextMeshProUGUI>();
        txtChangeCostAuto = btnStoneSpendAuto.transform.Find("txtPrice").GetComponent<TextMeshProUGUI>();

        charInfoNameT = new TextMeshProUGUI[2];
        charInfoNumberT = new TextMeshProUGUI[2];
        TextMeshProUGUI[] objListT = StatInfoT.GetComponentsInChildren<TextMeshProUGUI>(true);

        for (int i = 0; i < objListT.Length; i += 2)
        {
            charInfoNameT[i / 2] = objListT[i];
            charInfoNumberT[i / 2] = objListT[i + 1];
        }

        charInfoNameB = new TextMeshProUGUI[15];
        charInfoNumberB = new TextMeshProUGUI[15];
        TextMeshProUGUI[] objListB = StatInfoB.GetComponentsInChildren<TextMeshProUGUI>(true);

        for (int i = 0; i < objListB.Length; i += 2)
        {
            charInfoNameB[i / 2] = objListB[i];
            charInfoNumberB[i / 2] = objListB[i + 1];
        }

        awakenAutoButton.transform.Find("txtAuto").GetComponent<TextMeshProUGUI>().text = LocalizationText.GetText("all_changeauto");
    }

    public static bool SCloseMenu()
    {
        return curMgr.CloseMenu();
    }

    private bool CloseMenu()
    {
        // 게임 시작 후 열린적 없음.
        if (iSelectedTab < 0)
            return false;

        // 추가 효과 자동 변경 설정.
        if (AutoConfig.activeSelf)
        {
            ExitAutoRerollConfig();
            return true;
        }

        // 추가 효과 자동 변경 진행중.
        if (autoReroll)
        {
            ForceAutoStop();
            return true;
        }

        if (canvasUI.enabled)
        {
            CloseEnhance();
            return true;
        }
        return false;
    }
#endregion Base


    #region UI
    public static void SMoveEnhance(eEventMoveType content)
    {
        curMgr.OpenEnhance();
        switch (content)
        {
            case eEventMoveType.EnhnaceGold:
                curMgr.OpenEnhance();
                curMgr.TabGold();
                break;
            case eEventMoveType.EnhancePoint:
                curMgr.OpenEnhance();
                curMgr.TabLvPoint();
                break;
            case eEventMoveType.EnhanceAwakne:
                curMgr.OpenEnhance();
                curMgr.TabAwaken();
                break;
        }
    }

    // 강화창 열기.
    public void OpenEnhance()
    {
        if (iLoading > 0)
            return;
        iLoading++;

        canvasUI.enabled = true;
        leftWindow.enabled = true;
        GameUIMgr.SRightWindowClose();
        GameUIMgr.SOpenLeftPanel(gold : true, dia : true, lvpoint : true , change : true);
        GameUIMgr.SSetMainUiOn(false);
        BattleMgr.CloseFailScroll();

        if (bInitNeed)
        {
            Init();
            ivChar.Init();
            for (int i = 0; i < awakenButton.Length; i++)
            {
                awakenButton[i] = Instantiate(awakenButtonPrefab, awakenVerticalList.transform).GetComponent<AwakenItem>();
                awakenButton[i].SetKey(i + 1);
                awakenButton[i].FirstOpen();
            }
            SetAwakenLockSlot(DataHandler.PlayAwaken.awakenUnlock[DataHandler.PlayAwaken.usePreset]);
        }

        StartCoroutine(nameof(LoadCostume));

        if (bReLocalize)
        {
            int itab = 0;
            if (iSelectedTab >= 0)
            {
                itab = iSelectedTab;
                btnTabs[iSelectedTab].interactable = true;
                iSelectedTab = -1;
            }
            Localize(false);
            if (itab == 0)
                TabGold();
            else if (itab == 1)
                TabLvPoint();
            else if (itab == 2)
                TabAwaken();
        }

        //경험치 재계산과 스텟 재계산
        RefreshPlayerExpInfo();

        SCalcMyInfoStat();

        //각성 띄워져있을떄 각성비용 재계산
        if (iSelectedTab == 2)
            RecalculateRerollCost();

        //각 항목의 Escr 새로고침
        if (iSelectedTab == 0)
        {
            bReLocalizeGold = false;

            escrCharGoldEnhance.scroller.RefreshActiveCellViews();

            myInfo.SetActive(true);
            myAwaken.SetActive(false);
        }
        else if (iSelectedTab == 1)
        {
            bReLocalizeLvPoint = false;
            escrCharLvPointEnhance.scroller.RefreshActiveCellViews();

            myInfo.SetActive(true);
            myAwaken.SetActive(false);
        }
        else if (iSelectedTab == 2)
        {
            if (!(BattleMgr.CurrentBattleType != BattleMgr.BattleType.Stage && DungeonMgr.GetDungeonKind() != DungeonMgr.DungeonKind.AwakenDG))
            {
                DungeonMgr.SetDungeonKind(DungeonMgr.DungeonKind.AwakenDG);
            }

            if (bReLocalizeAwaken)
            {
                bReLocalizeAwaken = false;
                for (int i = 0; i < awakenButton.Length; i++)
                {
                    awakenButton[i].Localize();
                }
            }
            escrAwakenDungeon.scroller.RefreshActiveCellViews();

            myInfo.SetActive(false);
            myAwaken.SetActive(true);
        }

        iLoading--;

        imgPicon.sprite = AddressableMgr.GetPlayerIcon(DataHandler.PlayData.playerIcon);

        //뱃지 확인
        CheckBedge();
        awakenLock.SetActive(!DataHandler.IsClearStage(DataHandler.GetDungeonTypeInfo(DungeonMgr.DungeonKind.AwakenDG).openStage));

        RecalculateRerollCost();

        SoundMgr.PlaySfx(SoundName.BtnPress);
        //curMgr.btnStoneSpend.interactable = (curMgr.rerollCost <= DataHandler.Goods.changeStone && slotUnlock - (6 - DataHandler.GetServerAwakenSlots().awaken) > 0);
    }

    //전투 창의 강화버튼 뱃지 체크. 체크는 골드를 정산받을때 한다.
    public static bool IsMainEnhanceBedgeOn()
    {
        return curMgr.mainEnhanceBedge.activeSelf;
    }

    //골드와 포인트쪽 뱃지 체크. 두개가 끝나면 전투창 뱃지를 체크한다.
    public static void CheckBedge()
    {
        CalcGoldEnhance();
        CalcPointEnhance();
        curMgr.EnhanceBedgeSetActive();
    }

    //골드 escr 새로고침
    public static void RefreshGoldAll()
    {
        curMgr.escrCharGoldEnhance.scroller.RefreshActiveCellViews();
    }

    //다른 곳에서 강화창 열기. 현재는 공용 컨텐츠 이동을 사용함(안 씀)
    public static void OpenEnhanceOtherWindow()
    {
        curMgr.OpenEnhance();
    }

    // 강화창 닫기.
    public static void CloseEnhance()
    {
        if (curMgr.bInitNeed)
            return;
        if (!curMgr.canvasUI.enabled)
            return;
        if (!curMgr.autoReroll)
        {
            curMgr.ivChar.gameObject.SetActive(false);

            if (curMgr.iLoading > 0)
                return;
            curMgr.iLoading++;

            curMgr.ReleaseCostume();

            DataHandler.CheckAchivement(eContent.Battle);
            curMgr.canvasUI.enabled = false;
            curMgr.leftWindow.enabled = false;
            curMgr.myInfo.SetActive(false);
            GameUIMgr.SCloseLeftPanel();
            GameUIMgr.SSetMainUiOn(true);
            MissionMgr.SRefreshMission();

            if (curMgr.iSelectedTab == 2)
            {
                curMgr.ExitAutoRerollConfig();
                curMgr.CancelAwakenPresetSet();
            }

            curMgr.iLoading--;

            SoundMgr.PlaySfx(SoundName.BtnPress);
        }
    }
    #endregion UI

    //내 정보에 표기되는 플레이어 애니메이션.
    #region Costume

    // 창을 열 때 창의 의상/무기 세팅.
    private IEnumerator LoadCostume()
    {
        ivChar.gameObject.SetActive(true);
        RectTransform rtrfchar = ivChar.GetComponent<RectTransform>();
        Vector3 v3pos = rtrfchar.anchoredPosition3D;
        v3pos.z = -10000f;
        rtrfchar.anchoredPosition3D = v3pos;

        iLoadCos += 2;
        CoverCamera.Hold();
        CoverCamera.Hold();

        AddressableMgr.LoadClothSpine(DataHandler.PlayEquipCostume.outfitId, ALoadClothComp);
        AddressableMgr.LoadWeaponSpine(DataHandler.PlayEquipCostume.weaponId, ALoadWeaponComp);
        while (iLoadCos > 0)
            yield return null;
        yield return null;
        yield return null;

        ivChar.SetCostume(tx2dSelectedCloth);

        v3pos.z = -0f;
        rtrfchar.anchoredPosition3D = v3pos;
    }

    // 창 닫을 때 의상/무기 리소스 해제.
    private void ReleaseCostume()
    {
        tx2dSelectedCloth = null;
        AddressableMgr.ReleaseClothSpine(DataHandler.PlayEquipCostume.outfitId);
        AddressableMgr.ReleaseWeaponSpine(DataHandler.PlayEquipCostume.weaponId);
    }

    private void ALoadClothComp(Texture2D obj)
    {
        tx2dSelectedCloth = obj;
        CoverCamera.Release();
        iLoadCos--;
    }

    private void ALoadWeaponComp(Skin obj)
    {
        ivChar.SetWeapon(obj);

        if (tx2dSelectedCloth != null)
            ivChar.SetCostume(tx2dSelectedCloth);

        CoverCamera.Release();
        iLoadCos--;
    }
    #endregion Costume

    #region Tab
    //골드 탭을 눌렀을때
    public void TabGold()
    {
        if (!curMgr.autoReroll)
        {
            if (iSelectedTab == 0)
                return;


            if (iSelectedTab >= 0)
            {
                btnTabs[iSelectedTab].interactable = true;
                groupTabs[iSelectedTab].SetActive(false);
                AllEnhanceActiveFalse();
            }

            Color clrwhite = Global.CLR_White;
            Color clrtrans = Global.CLR_Trans;
            imgTabLineBottoms[0].color = clrtrans;
            imgTabLineBottoms[1].color = clrwhite;
            imgTabLineBottoms[2].enabled = true;
            imgTabLineRights[0].enabled = true;
            imgTabLineRights[1].enabled = false;
            imgTabLineRights[2].color = clrtrans;

            iSelectedTab = 0;
            btnTabs[iSelectedTab].interactable = false;
            groupTabs[iSelectedTab].SetActive(true);
            goldMulti.SetActive(true);
            myInfo.SetActive(true);
            myAwaken.SetActive(false);
            AutoConfig.SetActive(false);
            txtLeftWindow.text = LocalizationText.GetText("left_myinfo");

            if (bInitNeedGold)
            {
                bInitNeedGold = false;
                bReLocalizeGold = false;

                Dictionary<int, dCharStat> datas = DataHandler.GetCharStats();
                EnhancedUI.SmallList<int> goldEnhance = new EnhancedUI.SmallList<int>();

                for (int i = 0; i < datas.Count; i++)
                {
                    if (datas[i + 1].abilityType != eEffectType.CrtRate || datas[i + 1].level != datas[i + 1].maxLv)
                        goldEnhance.Add(datas[i + 1].id);
                }
                for (int i = 0; i < datas.Count; i++)
                {
                    if (datas[i + 1].level == datas[i + 1].maxLv && datas[i + 1].abilityType == eEffectType.CrtRate)
                        goldEnhance.Add(datas[i + 1].id);
                }

                escrCharGoldEnhance.LoadDatas(goldEnhance);

            }
            else
            {
                bReLocalizeGold = false;
                escrCharGoldEnhance.scroller.RefreshActiveCellViews();
            }

            tabGoldViewGroup.Active();
            tabLvPointViewGroup.Deactive();
            tabAwakenViewGroup.Deactive();

            SCalcMyInfoStat();
            CancelAwakenPresetSet();
            EnhanceBedgeSetActive();
            SoundMgr.PlaySfx(SoundName.BtnPress);
        }
    }
    //포인트 탭을 눌렀을때
    public void TabLvPoint()
    {
        if (!curMgr.autoReroll)
        {
            if (iSelectedTab == 1)
                return;

            if (iSelectedTab >= 0)
            {
                btnTabs[iSelectedTab].interactable = true;
                groupTabs[iSelectedTab].SetActive(false);
                AllEnhanceActiveFalse();
            }

            Color clrwhite = Global.CLR_White;
            Color clrtrans = Global.CLR_Trans;
            imgTabLineBottoms[0].color = clrwhite;
            imgTabLineBottoms[1].color = clrtrans;
            imgTabLineBottoms[2].enabled = true;
            imgTabLineRights[0].enabled = false;
            imgTabLineRights[1].enabled = true;
            imgTabLineRights[2].color = clrtrans;

            iSelectedTab = 1;
            btnTabs[iSelectedTab].interactable = false;
            groupTabs[iSelectedTab].SetActive(true);
            lvPointMulti.SetActive(true);
            myInfo.SetActive(true);
            myAwaken.SetActive(false);
            AutoConfig.SetActive(false);
            txtLeftWindow.text = LocalizationText.GetText("left_myinfo");

            if (bInitNeedLvPoint)
            {
                Dictionary<int, dCharStat> datas = DataHandler.GetCharLvPoints();

                bInitNeedLvPoint = false;
                bReLocalizeLvPoint = false;
                EnhancedUI.SmallList<int> lvPointEnhance = new EnhancedUI.SmallList<int>();

                for (int i = 0; i < datas.Count; i++)
                {
                    lvPointEnhance.Add(datas[i + 1].id);
                }

                escrCharLvPointEnhance.LoadDatas(lvPointEnhance);
            }
            else
            {
                bReLocalizeLvPoint = false;
                escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
            }

            tabGoldViewGroup.Deactive();
            tabLvPointViewGroup.Active();
            tabAwakenViewGroup.Deactive();

            SCalcMyInfoStat();
            CancelAwakenPresetSet();
            EnhanceBedgeSetActive();
            SoundMgr.PlaySfx(SoundName.BtnPress);
            //레벨포인트의 플레이어 정보 갱신
            //RefreshPlayerExpInfo();
            txtReset.text = FormatString.StringFormat(LocalizationText.GetText("all_reset"));
            txtPrice.text = DataHandler.Const.lvPointResetPrice.ToString();
        }
    }

    //각성 탭을 눌렀을때
    public void TabAwaken()
    {
        if (awakenLock.activeSelf)
        {
            GameUIMgr.SOpenToast(FormatString.TextOpenStageClear(DataHandler.GetDungeonTypeInfo(DungeonMgr.DungeonKind.AwakenDG).openStage));
            SoundMgr.PlaySfx(SoundName.BtnPress);
            return;
        }

        if (iSelectedTab == 2)
            return;

        if (iSelectedTab >= 0)
        {
            btnTabs[iSelectedTab].interactable = true;
            groupTabs[iSelectedTab].SetActive(false);
            AllEnhanceActiveFalse();
        }

        if (!(BattleMgr.CurrentBattleType != BattleMgr.BattleType.Stage && DungeonMgr.GetDungeonKind() != DungeonMgr.DungeonKind.AwakenDG))
        {
            DungeonMgr.SetDungeonKind(DungeonMgr.DungeonKind.AwakenDG);
        }

        DungeonMgr.SetAutoProgress(false);

        Color clryellow = Global.CLR_TextYellow;
        imgTabLineBottoms[0].color = clryellow;
        imgTabLineBottoms[1].color = clryellow;
        imgTabLineBottoms[2].enabled = false;

        imgTabLineRights[0].enabled = false;
        imgTabLineRights[1].enabled = false;
        imgTabLineRights[2].color = clryellow;

        iSelectedTab = 2;
        btnTabs[iSelectedTab].interactable = false;
        groupTabs[iSelectedTab].SetActive(true);
        AwakenImage.SetActive(true);
        AwakenBottom.SetActive(true);
        myInfo.SetActive(false);
        myAwaken.SetActive(true);
        AutoConfig.SetActive(false);
        goLeftBack.SetActive(false);
        goLeftBtnInfo.SetActive(true);
        txtLeftWindow.text = LocalizationText.GetText("left_hiddenpower");
        RecalculateRerollCost();
        ChangeButtonSetOnoff(true);

        if (blnitNeedAwaken)
        {
            AutoConfig.SetActive(true);

            blnitNeedAwaken = false;
            if (bReLocalizeAwaken)
            {
                bReLocalizeAwaken = false;
                for (int i = 0; i < awakenButton.Length; i++)
                {
                    awakenButton[i].Localize();
                }
            }
            //EnhancedUI.SmallList<int> AwakenAbility = new EnhancedUI.SmallList<int>();
            //
            //for(int i = 0; i < 6; i++)
            //{
            //    AwakenAbility.Add(i + 1);
            //}

            Dictionary<eEffectType, int> dicdatas = DataHandler.GetExtraAbilityIds()[0];
            EnhancedUI.SmallList<int> datas = new EnhancedUI.SmallList<int>();
            bSelectedOptions = new bool[dicdatas.Count];
            efcOptions = new eEffectType[dicdatas.Count];

            int index = 0;
            foreach (var item in dicdatas)
            {
                bSelectedOptions[index] = true;
                efcOptions[index] = DataHandler.GetExtraAbility(item.Value).abilityType;
                datas.Add(index);
                index++;
            }
            escrAutoRerollConfig.LoadDatas(datas);

            //escrAutoRerollConfig.LoadDatas(AwakenAbility);
            AutoConfig.SetActive(false);

            EnhancedUI.SmallList<int> awakenDungeon = new EnhancedUI.SmallList<int>();

            for (int i = 0; i < DataHandler.GetDungeonTypeInfo(DungeonMgr.DungeonKind.AwakenDG).diffs.Length; i++)
            {
                awakenDungeon.Add(i + 1);
            }

            escrAwakenDungeon.LoadDatas(awakenDungeon);
        }
        else
        {
            if (bReLocalizeAwaken)
            {
                bReLocalizeAwaken = false;
                for (int i = 0; i < awakenButton.Length; i++)
                {
                    awakenButton[i].Localize();
                }
            }
            escrAwakenDungeon.scroller.RefreshActiveCellViews();
            escrAutoRerollConfig.scroller.RefreshActiveCellViews();
        }

        tabGoldViewGroup.Deactive();
        tabLvPointViewGroup.Deactive();
        tabAwakenViewGroup.Active();

        SoundMgr.PlaySfx(SoundName.BtnPress);
        SetSelected(DataHandler.GetServerAwakenSlots().awaken+1);

        escrAwakenDungeon.scroller.ScrollPosition = DataHandler.GetPlayerDungeonInfoKind(DungeonMgr.DungeonKind.AwakenDG).lv < 2
        ? 0 : (DataHandler.GetPlayerDungeonInfoKind(DungeonMgr.DungeonKind.AwakenDG).lv - 1) * 82;

        for (int i = 0; i < btnAbilityPreset.Length; i++)
            btnAbilityPreset[i].interactable = DataHandler.PlayAwaken.usePreset != i;
    }

    //각성의 자동변경 버튼을 눌렀을때
    public void TabAutoRerollConfig()
    {
        myAwaken.SetActive(false);
        AutoConfig.SetActive(true);
        goLeftBack.SetActive(true);
        goLeftBtnInfo.SetActive(false);
        txtChangeCostAuto.text = rerollCost.ToString();

        SoundMgr.PlaySfx(SoundName.BtnPress);
    }

    //각성의 자동변경을 닫았을때
    public void ExitAutoRerollConfig()
    {
        myAwaken.SetActive(true);
        AutoConfig.SetActive(false);
        goLeftBack.SetActive(false);
        goLeftBtnInfo.SetActive(true);

        SoundMgr.PlaySfx(SoundName.BtnPress);
    }

    //모든 탭창 비활성화. 다른 탭을 눌렀을때 겹치지 않도록 하기 위해 실행한다.
    void AllEnhanceActiveFalse()
    {
        goldMulti.SetActive(false);
        lvPointMulti.SetActive(false);
        AwakenImage.SetActive(false);
        AwakenBottom.SetActive(false);
    }

    void ChangeButtonSetOnoff(bool onoff)
    {
        ChangeButtonSet.SetActive(onoff);
        AutoChanging.SetActive(!onoff);
    }
    #endregion Tab

    
    Dictionary<int, BigInteger> goldEnhancePrice = new Dictionary<int, BigInteger>();

    int iupgradeMulti = 1;//강화 횟수

    int abilityValue = 0;
    int abilityValueInc = 1;
    BigInteger buyingCnt = 0L;
    int buyingCntInc = 1;
    int level = 1;
    int iMaxLv = 100;

    bool isUnlock = false;

    BigInteger calcmultiply = 0l;
    BigInteger calcdivide = 0l;
    BigInteger iprice = 0;
    long icurValue = 0;
    BigInteger inextValue = 0;
    #region GoldMath

    int iresetValue = 0;
    
    public static BigInteger SSingleRecalcGoldPrice(int enhenceId)
    {
        return curMgr.SingleRecalcGoldPrice(enhenceId);
    }

    public BigInteger SingleRecalcGoldPrice(int enhenceId)
    {
        dCharStat charData = DataHandler.GetCharStat(enhenceId);

        iupgradeMulti = GetMultifulGoldEnhance();//강화 횟수

        abilityValue = 0;
        abilityValueInc = 1;
        buyingCnt = 0L;
        buyingCntInc = 1;
        level = 1;

        isUnlock = false;


        abilityValue = charData.abilityValue;
        abilityValueInc = charData.abilityValueInc;
        buyingCnt = charData.buyingCount;
        buyingCntInc = charData.buyingCntInc;
        iMaxLv = charData.maxLv;
        level = charData.level;

        // 현재레벨 + 강화횟수가 만렙보다 높으면
        if (charData.level + iupgradeMulti > iMaxLv)
        {
            iupgradeMulti = iMaxLv - level;//만렙 제한
        }

        //calcmultiply = BigInteger.Pow(buyingCntInc, level);
        //calcdivide = BigInteger.Pow(dConst.RateMaxBi, level);


        // 가격 = 현재 가격 * (증가율^레벨)
        //iprice = buyingCnt * calcmultiply / calcdivide;
        //// 증가 스탯 계산
        //icurValue = abilityValue + (abilityValueInc * level);
        //// 다음 증가 스탯 계산
        //inextValue = abilityValue + (abilityValueInc * (level + 1));

        //System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();

        //watch.Start();

        // 여러번 강화할때 계산
        //if (iupgradeMulti > 1)
        //{
        //    iprice = 0L;
        //    for (int i = 0; i < iupgradeMulti; i++)
        //    {
        //        iprice += buyingCnt * BigInteger.Pow(buyingCntInc, level + i) / BigInteger.Pow(dConst.RateMaxBi, level + i);
        //    }
        //    inextValue = abilityValue + (abilityValueInc * (level + iupgradeMulti));
        //}
        //
        //    Debug.Log(FormatString.StringFormat("반복 {0}", FormatString.BigIntString1(iprice)));

        iprice = 0L;
        if (enhenceId == 1)
        {
            iprice = CalcCharLvUpPriceAccum1(level % 1000, iupgradeMulti, (double)buyingCntInc / dConst.RateMax, DataHandler.GetGoldLevelInterval(level));
        }
        else if (enhenceId == 2)
        {
            iprice = CalcCharLvUpPriceAccum1(level % 1000, iupgradeMulti, (double)buyingCntInc / dConst.RateMax, DataHandler.GetHpLevelInterval(level));
        }
        else
        {
            iprice = CalcCharLvUpPriceAccum1(level, iupgradeMulti, (double)buyingCntInc / dConst.RateMax, buyingCnt);
        }

        //    Debug.Log(FormatString.StringFormat("심연 {0}", FormatString.BigIntString1(iprice)));

        //watch.Stop();
        //UnityEngine.Debug.Log(watch.ElapsedMilliseconds + " ms");

        inextValue = abilityValue + (abilityValueInc * (level + iupgradeMulti));

        iresetValue = abilityValue + (abilityValueInc * level);

        return iprice;
    }

    public BigInteger CalcCharLvUpPriceAccum1(int curlevel, int addlevel, double buyingCntInc, BigInteger buyingCnt)
    {
        if (/*curlevel < 1 ||*/ addlevel < 1)
            return buyingCnt;
        double ftargetlv = curlevel + addlevel - 1d;
        ftargetlv = System.Math.Pow(buyingCntInc, ftargetlv) - 1d;
        double fcurlv = curlevel - 1d;
        fcurlv = System.Math.Pow(buyingCntInc, fcurlv) - 1d;
        ftargetlv -= fcurlv;
        ftargetlv *= buyingCntInc;
        ftargetlv /= (buyingCntInc - 1d);


        return buyingCnt * (BigInteger)(ftargetlv * 100) / 100;
    }

    /*
    //골드 강화 통신 실패
    private void AGoldEnhanceFail(IVServerFormat.SvError error, object request)
    {
        CoverCamera.Release();
        DataHandler.AddGold(eGoodsGetUse.Test, dataEnhance.useGoods);
        SLevelUpCharStatServer(dataEnhance.sid, -(dataEnhance.aftLv - dataEnhance.befLv), GetGoldPrice(dataEnhance.sid), iresetValue);
        escrCharGoldEnhance.scroller.RefreshActiveCellViews();
        dataEnhance = null;
    }

    // 골드 강화 통신 성공.
    private void AGoldEnhanceSucc(object result, object request)
    {
        nCharEnhanceGoldReturn data = result as nCharEnhanceGoldReturn;
        if (data == null)
        {
            AGoldEnhanceFail(new IVServerFormat.SvError(IVServerFormat.eErrorCode.NULL_OR_EMPTY), request);
            return;
        }
        //if (dataEnhance.sid == 2)
        //    Debug.Log(" hp per : " + BuffMgr.Instance.getHpPer());
        nIdLv datalv;
        datalv = data.playCharEnhanceGold;
        EnhanceMgr.SCalcMyInfoStat();
        EnhanceMgr.CheckBedge();
        EnhanceMgr.RefreshGoldAll();
        BattleMgr.StatRecalc();


        SingleRecalcGoldPrice(data.playCharEnhanceGold.sid);
        escrCharGoldEnhance.scroller.RefreshActiveCellViews();
        DataHandler.Goods.Save(DataHandler.PlayData.server);

        BattleMgr.EnhanceHeal((dataEnhance.aftLv - dataEnhance.befLv) * DataHandler.GetCharStats()[2].abilityValueInc);

        dataEnhance = null;
        CoverCamera.Release();
    }
    */
    #endregion

    int resetLvPointCost = 99999999;
    public int GetResetLvPointCost()
    {
        return resetLvPointCost;
    }

    public static void RefreshPlayerExpInfo()
    {
        if (!curMgr.canvasUI.isActiveAndEnabled)
        {
            return;
        }

        curMgr.lvTxt.text = FormatString.TextLv(DataHandler.PlayData.playerLv);
        curMgr.lvPercentTxt.text = FormatString.StringFormat("{0:N0}%", DataHandler.GetPlayerExpRate() * 100);
        curMgr.ExpFill.value = DataHandler.GetPlayerExpRate();
        if (DataHandler.Goods.Dia >= DataHandler.Const.lvPointResetPrice)
        {
            curMgr.btnReset.interactable = true;
        }
        else
        {
            curMgr.btnReset.interactable = false;
        }
    }

    public void ResetLvPointConfirm()
    {
        if (DataHandler.Goods.point >= DataHandler.PlayData.playerLv - 1)
        {
            GameUIMgr.SOpenToast(LocalizationText.GetText("reset_level_no"));
            return;
        }

        GameUIMgr.SOpenPopup2Button(LocalizationText.GetText("reset_level_q"), ResetLvPoint);
    }

    //주석은 옛날 서버연동 없을 적 코드라서 삭제해도 무방. 서버와 통신해서 레벨포인트를 리셋한다. 단, 레벨포인트가 레벨 -1 만큼 남아있으면 리셋 금지.
    public void ResetLvPoint()
    {
        /*
        if (DataHandler.Goods.point==DataHandler.PlayData.playerLv - 1)
        {
            GameUIMgr.SOpenToast();
            return;
        }

        SoundMgr.PlaySfx(SoundName.BtnPress);

        GameUIMgr.SOpenPopup2Button(LocalizationText.GetText("lvpoint_reset_comform"), curMgr.ResetLvPointComform);
        */

        SvConnectManager.Instance.RequestSvPost(true, 0, IVServerFormat.UrlApi.GetUrl(IVServerFormat.UrlApi.PointReset), typeof(nCharEnhancePointReturn), APointResetSucc, APointResetFail, null, true);

    }

    


    private void APointResetFail(IVServerFormat.SvError error, object request)
    {
        CoverCamera.Release();
        iLoading--;
    }

    // 레벨 리셋 통신 성공.
    private void APointResetSucc(object result, object request)
    {
        nCharEnhancePointReturn data = result as nCharEnhancePointReturn;
        if (data == null)
        {
            APointEnhanceFail(new IVServerFormat.SvError(IVServerFormat.eErrorCode.NULL_OR_EMPTY), request);
            return;
        }

        /*
        nIdLv datalv;
        datalv = data.playCharEnhancePoint;
        SCalcMyInfoStat();
        CheckBedge();
        BattleMgr.StatRecalc();
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();

        BattleMgr.EnhanceHeal((dataEnhance.aftLv - dataEnhance.befLv) * DataHandler.GetCharStats()[2].abilityValueInc);

        dataEnhance = null;

        while (coverCameraCount > 0)
        {
            CoverCamera.Release();
            coverCameraCount--;
        }
        while (iLoading > 0)
        {
            iLoading--;
        }
        */
        nIdLv datalv;
        datalv = data.playCharEnhancePoint;

        DataHandler.AllResetLvPoint();
        //DataHandler.SetLvPoint(data.playCurrency.point);
        DataHandler.SetGoods(data.playCurrency, false);

        SCalcMyInfoStat();
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();

        if (DataHandler.Goods.Dia >= DataHandler.Const.lvPointResetPrice)
        {
            curMgr.btnReset.interactable = true;
        }
        else
        {
            curMgr.btnReset.interactable = false;
        }
        GameUIMgr.SOpenToast(LocalizationText.GetText("reset_level_confirm"));

        CoverCamera.Release();
        iLoading--;
    }

    //사용하지 않는 코드. 서버연결 없을 적의 레벨포인트 리셋 완료 시 계산하는 함수.
    public void ResetLvPointComform()
    {
        DataHandler.AllResetLvPoint();
        DataHandler.SetLvPoint(DataHandler.PlayData.playerLv - 1);
        DataHandler.SubDia(curMgr.resetLvPointCost);
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
    }

    int goldMultiful = 1;
    int lvPointMultiful = 1;

    //골드 쪽 한번에 강화. x10 x100.
    public static void MultifulGoldEnhance(int multi)
    {
        curMgr.goldMultiful = multi;

        ResetMultifulGold();
        switch (multi)
        {
            case 1:
                curMgr.goldMultiButton[0].interactable = false;
                break;
            case 10:
                curMgr.goldMultiButton[1].interactable = false;
                break;
            case 100:
                curMgr.goldMultiButton[2].interactable = false;
                break;
        }

        SoundMgr.PlaySfx(SoundName.BtnPress);

        curMgr.escrCharGoldEnhance.scroller.RefreshActiveCellViews();
    }

    public static void ResetMultifulGold()
    {
        curMgr.goldMultiButton[0].interactable = true;
        curMgr.goldMultiButton[1].interactable = true;
        curMgr.goldMultiButton[2].interactable = true;
    }

    public static int GetMultifulGoldEnhance()
    {
        return curMgr.goldMultiful;
    }
    //레벨포인트 한번에 강화.
    public static void MultifulLvPointEnhance(int multi)
    {
        curMgr.lvPointMultiful = multi;

        ResetMultifulLvPoint();
        switch (multi)
        {
            case 1:
                curMgr.lvPointMultiButton[0].interactable = false;
                break;
            case 10:
                curMgr.lvPointMultiButton[1].interactable = false;
                break;
            case 100:
                curMgr.lvPointMultiButton[2].interactable = false;
                break;
        }

        SoundMgr.PlaySfx(SoundName.BtnPress);

        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
    }

    public static void ResetMultifulLvPoint()
    {
        curMgr.lvPointMultiButton[0].interactable = true;
        curMgr.lvPointMultiButton[1].interactable = true;
        curMgr.lvPointMultiButton[2].interactable = true;
    }

    public static int GetMultifulLvPointEnhance()
    {
        return curMgr.lvPointMultiful;
    }

    #region Enhance
    // 골드 강화.

    //안 쓰이는 코드. 서버연결 없을 적.
    public static void SLevelUpCharStatMulti(int key, int upLevel, int cost, int nextStat)
    {
        int level = DataHandler.GetCharStatLevel(key) + upLevel;

        if (DataHandler.LvUpCharStatMulti(key, level, cost, nextStat))
        {
            curMgr.escrCharGoldEnhance.scroller.RefreshActiveCellViews();
        }
    }
    //안 쓰이는 코드. 서버연결 없을 적.
    public static void SLevelUpCharLvPointMulti(int key,int upLevel,int cost, int nextStat)
    {
        int level = DataHandler.GetCharLvPointLevel(key) + upLevel;

        if (DataHandler.LvUpCharLvPointMulti(key, level, cost, nextStat))
        {
            curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
        }
    }

    //서버연결이 있는 골드강화.
    public static void SLevelUpCharStatServer(int key, int upLevel, BigInteger biprice, int nextStat)
    {
        int level = DataHandler.GetCharStatLevel(key) + upLevel;

        DataHandler.LvUpCharStatServer(key, level, biprice, nextStat);
        //curMgr.escrCharGoldEnhance.scroller.RefreshActiveCellViews();
    }
    //서버연결이 있는 포인트강화.
    public static void SLevelUpCharPointServer(int key, int upLevel, int iprice, int nextStat)
    {
        int level = DataHandler.GetCharLvPointLevel(key) + upLevel;

        DataHandler.LvUpCharPointServer(key, level, iprice, nextStat);
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
    }

    nIdEnhance dataEnhance = null;
    
    public static bool IsILoadingSetOne()
    {
        if (curMgr.iLoading > 0)
        {
            return true;
        }
        curMgr.iLoading++;
        return false;
    }

    public static void MinusILoading()
    {
        curMgr.iLoading--;
    }
    //레벨 포인트를 강화하기전에 서버 저장 상태랄ㅇ 다르면 저장을 한번 한다.
    //그리고 통신을 시도한다.
    public static void TrySVPointEnhance(nIdEnhance data)
    {
        curMgr.dataEnhance = data;

        if (DataHandler.IsNeedDataSave)
        {
            SingleMgr.SaveDataPointEnhanceConsume();
        }
        else
        {
            curMgr.APointEnhance();
        }
    }

    public static void SAPointEnhance()
    {
        curMgr.APointEnhance();
    }

    int coverCameraCount = 0;

    private void APointEnhance()
    {
        CoverCamera.Hold();
        coverCameraCount++;

        SvConnectManager.Instance.RequestSvPost(true, 0, IVServerFormat.UrlApi.GetUrl(IVServerFormat.UrlApi.PointEnhance), typeof(nCharEnhancePointReturn), APointEnhanceSucc, APointEnhanceFail, dataEnhance, true);
    }

    private void APointEnhanceFail(IVServerFormat.SvError error, object request)
    {
        CoverCamera.Release();
        DataHandler.AddLvPoint(dataEnhance.useGoods);
        SLevelUpCharPointServer(dataEnhance.sid, -(dataEnhance.aftLv - dataEnhance.befLv), dataEnhance.useGoods, 0);
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
        dataEnhance = null;
        iLoading--;
    }

    // 레벨 강화 통신 성공.
    private void APointEnhanceSucc(object result, object request)
    {
        nCharEnhancePointReturn data = result as nCharEnhancePointReturn;
        if (data == null)
        {
            APointEnhanceFail(new IVServerFormat.SvError(IVServerFormat.eErrorCode.NULL_OR_EMPTY), request);
            return;
        }
        nIdLv datalv;
        datalv = data.playCharEnhancePoint;
        SCalcMyInfoStat();
        CheckBedge();
        BattleMgr.StatRecalc();
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();

        BattleMgr.EnhanceHeal((dataEnhance.aftLv - dataEnhance.befLv) * DataHandler.GetCharStats()[2].abilityValueInc);

        dataEnhance = null;

        while (coverCameraCount > 0)
        {
            CoverCamera.Release();
            coverCameraCount--;
        }
        while (iLoading > 0)
        {
            iLoading--;
        }

    }

    #endregion Enhance



    #region Awaken

    bool autoReroll = false;
    int selected = 1;
    public static int GetSelected()
    {
        return curMgr.selected;
    }
    public static void SetSelected(int key)
    {
        curMgr.selected = key;
        BattleMgr.SetAwakenRewardNumber(key);
        curMgr.escrAwakenDungeon.scroller.RefreshActiveCellViews();
        curMgr.txtEffect.text = FormatString.StringFormat("{0} {1}" ,LocalizationText.GetText("efc11"), FormatString.TextIntPer0CommaBi(DataHandler.SysAwakenRewards[key].awakenInc));
    }

    int prevPreset = -1;
    //각성 잠재능력 프리셋 선택
    public void btnAwakenPresetSet(int preset)
    {
        if (prevPreset == -1)
        {
            prevPreset = DataHandler.PlayAwaken.usePreset;
        }
        DataHandler.btnAwakenPresetSet(preset,false);
        SetAwakenLockSlot(DataHandler.PlayAwaken.awakenUnlock[DataHandler.PlayAwaken.usePreset]);
        AwakenButtonRefresh();

        for (int i = 0; i < btnAbilityPreset.Length; i++)
            btnAbilityPreset[i].interactable = DataHandler.PlayAwaken.usePreset != i;

        SaveAwakenPresetSet();

    }
    //사용 프리셋 저장.
    public void SaveAwakenPresetSet()
    {
        prevPreset = -1;
        StartSetAwakenPreset();

        GameUIMgr.SOpenToast(LocalizationText.GetText(Global.STR_Saved));
    }
    //프리셋 취소. 저장 버튼이 있었을 적에 사용됨.
    void CancelAwakenPresetSet()
    {
        if (prevPreset != -1)
        {
            btnAwakenPresetSet(prevPreset);
            StartSetAwakenPreset();

            prevPreset = -1;
        }
    }
    //잠재능력 스텟을 토대로 스텟 계산
    public static void StartSetAwakenPreset()
    {
        //DataHandler.enhanceAwakenSlot.extras = DataHandler.enhanceAwakenSlot.extraSet[DataHandler.enhanceAwakenSlot.usePreset];
        BuffMgr.Instance.AwakenReset();
        for (int i = 0; i < 6; i++)
        {
            if (DataHandler.PlayAwaken.extras[DataHandler.PlayAwaken.usePreset][i] >= 0)
            {
                BuffMgr.Instance.ChangeAwakenStat(DataHandler.GetExtraAbility(DataHandler.PlayAwaken.extras[DataHandler.PlayAwaken.usePreset][i]).abilityType, DataHandler.GetExtraAbility(DataHandler.PlayAwaken.extras[DataHandler.PlayAwaken.usePreset][i]).abilityValue, false);
            }
        }

        DataHandler.SaveAwakenPreset();
    }

    //잠재능력 슬롯 새로고침
    public void AwakenButtonRefresh()
    {
        for (int i = 0; i < 6; i++)
        {
            awakenButton[i].RefreshView();
        }
    }
    //잠재능력 슬롯 해금
    public static void UnlockSlot(int key)
    {
        curMgr.awakenButton[key - 1].RefreshUnlock();
        curMgr.awakenButton[key - 1].UnlockSlot();
    }

    public static bool GetAutoReroll()
    {
        return curMgr.autoReroll;
    }

    eRarity autoRareity = eRarity.Hero;
    
    public static void SetAutoRareity(eRarity rareity)
    {
        curMgr.autoRareity = rareity;
    }
    //잠재능력 돌리기 비용 재계산
    public static void RecalculateRerollCost()
    {
        curMgr.rerollCost = 10;
        int slotLock = 0;
        int slotUnlock = 6;
        for(int i = 0; i < curMgr.awakenButton.Length; i++)
        {
            if (curMgr.awakenButton[i].GetIsAbilityLock())
            {
                slotLock++;
                slotUnlock--;
            }
            curMgr.awakenButton[i].RefreshView();
        }
        //curMgr.rerollCost = (slotLock + 1) * (slotLock + 1) * curMgr.rerollCost;
        curMgr.rerollCost = DataHandler.Const.awakenChangeStonePrice * (slotUnlock - (6 - Mathf.Min(DataHandler.GetServerAwakenSlots().awaken, 6)));
        if(slotUnlock - (6 - Mathf.Min(DataHandler.GetServerAwakenSlots().awaken, 6)) == 0)
        {
            curMgr.rerollCost = DataHandler.Const.awakenChangeStonePrice;
        }

        curMgr.txtChangeCost.text = curMgr.rerollCost.ToString();
        curMgr.btnStoneSpend.interactable = (curMgr.rerollCost <= DataHandler.Goods.changeStone && slotUnlock - (6 - Mathf.Min(DataHandler.GetServerAwakenSlots().awaken, 6)) > 0);
        curMgr.btnStoneSpendAuto.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;
        curMgr.btnAutoSpend.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;


    }
    //잠재능력 슬롯 잠금여부 판별
    public static void SetAwakenLockSlot(bool[] lockset)
    {
        for(int i = 0; i < 6; i++)
        {
            curMgr.awakenButton[i].SetIsUnlock(lockset[i]);
        }
    }

    //잠재능력 돌리기 전에 확인하는 용도.
    public void RerollCheckAbility()
    {
        int noReroll = 0;
        int serverSlot = 63;

        if (rerollCost <= DataHandler.Goods.changeStone)
        {
            for (int i = 0; i < awakenButton.Length; i++)
            {
                if (!awakenButton[i].GetIsUnlock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);
                    continue;
                }
                else if (awakenButton[i].GetIsAbilityLock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);

                    continue;
                }

                awakenButton[i].RefreshView();

                dExtraAbility ability = DataHandler.GetExtraAbility(DataHandler.GetServerAwakenSlots().extras[DataHandler.PlayAwaken.usePreset][i]);
                if (ability != null)
                {
                    if (ability.rarity >= (int)eRarity.Legend)
                    {
                        GameUIMgr.SOpenPopup2Button(LocalizationText.GetText("msg_highgrade"), RerollAwakenAbility);
                
                        return;
                    }
                }

            }

            if (noReroll == awakenButton.Length)
            {
                //GameUIMgr.SOpenToast(LocalizationText.GetText("msg_noslotchange"));
                GameUIMgr.SOpenToast(LocalizationText.GetText("msg_noslotchange"));

                //no
                return;
            }

            SoundMgr.PlaySfx(SoundName.BtnPress);
            RerollServerAwakenAbility(DataHandler.PlayAwaken.usePreset + 1, serverSlot);
        }
    }

    nAwakenPresetSlot dataSlot = null;

    public void RerollServerAwakenAbility(int preset, int slot)
    {
        dataSlot = new nAwakenPresetSlot(preset, slot);

        CoverCamera.Hold();
        SvConnectManager.Instance.RequestSvPost(true, 0, IVServerFormat.UrlApi.GetUrl(IVServerFormat.UrlApi.AwakenEnhance), typeof(nCharAwakenReturn), AAwakenEnhanceSucc, AAwakenEnhanceFail, dataSlot, true);
    }

    //각성 강화 통신 실패
    private void AAwakenEnhanceFail(IVServerFormat.SvError error, object request)
    {

        dataSlot = null;


        CoverCamera.Release();
    }

    // 각성 강화 통신 성공.
    private void AAwakenEnhanceSucc(object result, object request)
    {
        nCharAwakenReturn data = result as nCharAwakenReturn;
        if (data == null)
        {
            AAwakenEnhanceFail(new IVServerFormat.SvError(IVServerFormat.eErrorCode.NULL_OR_EMPTY), request);
            return;
        }

        BuffMgr.Instance.AwakenReset();

        DataHandler.SetServerAwakenSlot(data.playAwaken,DataHandler.PlayAwaken.usePreset);
        DataHandler.SubChangeStone(DataHandler.Goods.changeStone - data.playCurrency.changeStone);

        DataHandler.PlayAwaken.OnAfterDeserialize();

        for (int i = 0; i < 6; i++)
        {
            if (data.playAwaken.extras[DataHandler.PlayAwaken.usePreset][i] >= 0)
            {
                BuffMgr.Instance.ChangeAwakenStat(DataHandler.GetExtraAbility(data.playAwaken.extras[DataHandler.PlayAwaken.usePreset][i]).abilityType, DataHandler.GetExtraAbility(data.playAwaken.extras[DataHandler.PlayAwaken.usePreset][i]).abilityValue, false);
                awakenButton[i].RefreshView();
            }
        }

        //DataHandler.enhanceAwakenSlot.extraSet[DataHandler.enhanceAwakenSlot.usePreset] = DataHandler.enhanceAwakenSlot.extras;
        BuffMgr.Instance.CalcAllStat();
        SCalcMyInfoStat();

        dataSlot = null;

        CoverCamera.Release();
    }

    //잠재능력 돌리기
    public void RerollAwakenAbility()
    {
        int noReroll = 0;
        int serverSlot = 63;

        if (rerollCost <= DataHandler.Goods.changeStone)
        {
            for (int i = 0; i < awakenButton.Length; i++)
            {
                if (!awakenButton[i].GetIsUnlock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);
                    continue;
                }
                else if (awakenButton[i].GetIsAbilityLock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);
                    continue;
                }

                //DataHandler.RerollAwakenAbility(i + 1);
                awakenButton[i].UnlockLockButton();
                awakenButton[i].RefreshView();
            }

            BuffMgr.Instance.CalcAllStat();

            if (noReroll == awakenButton.Length)
            {
                GameUIMgr.SOpenToast(LocalizationText.GetText("msg_noslotchange"));

                //no
                return;
            }

            RerollServerAwakenAbility(DataHandler.PlayAwaken.usePreset + 1, serverSlot);

            //DataHandler.SubChangeStone(rerollCost);
            curMgr.btnStoneSpend.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;
            curMgr.btnStoneSpendAuto.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;
        }
    }

    //자동돌리기 시작.
    public void AutoRerollStart()
    {
        if (rerollCost <= DataHandler.Goods.changeStone)
        {
            autoReroll = true;

            SoundMgr.PlaySfx(SoundName.BtnPress);
            StartCoroutine("AutoRerollAbility");
        }


    }

    IEnumerator AutoRerollAbility()
    {
        ExitAutoRerollConfig();
        ChangeButtonSetOnoff(false);

        bool alreadyHave = false;

        for (int i = 0; i < awakenButton.Length; i++)
        {
            if (!awakenButton[i].GetIsUnlock())
            {
                continue;
            }
            else if (awakenButton[i].GetIsAbilityLock())
            {
                continue;
            }

            dExtraAbility ability = DataHandler.GetExtraAbility(DataHandler.GetServerAwakenSlots().extras[DataHandler.PlayAwaken.usePreset][i]);
            if (ability == null)
            {
                ability = new dExtraAbility();
                ability.rarity = 0;
            }
            if (ability.rarity >= (int)autoRareity)
            {
                //트루일때
                for (int j = 0; j < efcOptions.Length; j++)
                {
                    if (bSelectedOptions[j])
                    {
                        if (ability.abilityType == efcOptions[j])
                        {
                            alreadyHave = true;
                            break;
                        }
                    }

                }
            }
        }
        //원하는 조건에 걸릴때 중단.
        if (alreadyHave)
        {
            autoReroll = false;

            GameUIMgr.SOpenToast(LocalizationText.GetText("awaken_waning_already_have"));
            ChangeButtonSetOnoff(true);
        }

        while (autoReroll)
        {
            int noReroll = 0;
            int serverSlot = 63;
            bool conditionOK = false;


            if (curMgr.rerollCost > DataHandler.Goods.changeStone)
            {
                GameUIMgr.SOpenToast(LocalizationText.GetText("msg_nodice"));
                ChangeButtonSetOnoff(true);

                autoReroll = false;
                yield break;
            }

            for (int i = 0; i < awakenButton.Length; i++)
            {
                if (!awakenButton[i].GetIsUnlock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);

                    continue;
                }
                else if (awakenButton[i].GetIsAbilityLock())
                {
                    noReroll++;
                    serverSlot -= (int)Mathf.Pow(2, i);

                    continue;
                }

                //DataHandler.RerollAwakenAbility(i + 1);
                awakenButton[i].UnlockLockButton();
                awakenButton[i].RefreshView();

                dExtraAbility ability = DataHandler.GetExtraAbility(DataHandler.GetServerAwakenSlots().extras[DataHandler.PlayAwaken.usePreset][i]);
                if (ability == null)
                {
                    ability = new dExtraAbility();
                    ability.rarity = 0;
                }
                if (ability.rarity >= (int)autoRareity)
                {
                    for (int j = 0; j < efcOptions.Length; j++)
                    {
                        if (bSelectedOptions[j])
                        {
                            if (ability.abilityType == efcOptions[j])
                            {
                                conditionOK = true;
                                break;
                            }
                        }

                    }
                }
            }

            if (noReroll == awakenButton.Length)
            {
                GameUIMgr.SOpenToast(LocalizationText.GetText("msg_noslotchange"));
                ChangeButtonSetOnoff(true);

                autoReroll = false;
                yield break;
            }

            //BuffMgr.Instance.CalcAllStat();

            //DataHandler.SubChangeStone(rerollCost);

            curMgr.btnStoneSpend.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;
            curMgr.btnStoneSpendAuto.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;

            if (conditionOK)
            {
                //GameUIMgr.SOpenPopup1Button(LocalizationText.GetText("awaken_want_ability"));
                GameUIMgr.SOpenToast(LocalizationText.GetText("awaken_waning_already_have"));
                ChangeButtonSetOnoff(true);

                autoReroll = false;
                yield break;
            }
            else
            {
                RerollServerAwakenAbility(DataHandler.PlayAwaken.usePreset + 1, serverSlot);
            }

            yield return new WaitForSeconds(0.5f);
        }

    }

    //돌리는 도중 강제중단.
    public void ForceAutoStop()
    {
        autoReroll = false;
        ChangeButtonSetOnoff(true);
        SoundMgr.PlaySfx(SoundName.BtnPress);
    }


    // 아이템 효과 종류.
    public static eEffectType SGetEfcAddAutoType(int index)
    {
        if (index < 0)
            return eEffectType.None;
        return curMgr.efcOptions[index];
    }
    
    // 아이템 선택 상태.
    public static bool SGetEfcAddAutoSelect(int index)
    {
        if (index < 0)
            return false;
        return curMgr.bSelectedOptions[index];
    }

    // 추가 효과 잠금상태 변경.
    public static void SToggleSelect(int itemid, bool bselect)
    {
        if (itemid < 0)
        {
            if (bselect)
            {
            }
            return;
        }
        curMgr.bSelectedOptions[itemid] = bselect;
        for(int i = 0; i < curMgr.bSelectedOptions.Length; i++)
        {
            if (curMgr.bSelectedOptions[i])
            {
                curMgr.btnAutoSpend.interactable = true;
                break;
            }
            curMgr.btnAutoSpend.interactable = false;
        }

        curMgr.btnAutoSpend.interactable = curMgr.rerollCost <= DataHandler.Goods.changeStone;
        curMgr.escrAutoRerollConfig.scroller.RefreshActiveCellViews();
    }

    public void OpenInfoHelp()
    {
        SoundMgr.PlaySfx(SoundName.BtnPress);
        GameUIMgr.SOpenPopupRarityRate();
    }
    #endregion

    #region MyInfo

    public static void SCalcMyInfoStat()
    {
        curMgr.CalcMyInfoStat();
    }
    //내 정보 스텟 표기
    private void CalcMyInfoStat()
    {
        if (iSelectedTab < 0)
        {
            return;
        }
        BuffMgr.Instance.CalcBattlePower();

        charInfoNumberT[0].text = DataHandler.PlayData.playerLv.ToString();
        charInfoNumberT[1].text = FormatString.BigIntString1(BuffMgr.Instance.GetBattlePower());
        charInfoNumberB[0].text = FormatString.BigIntString1(BuffMgr.Instance.GetCharAtk());
        charInfoNumberB[1].text = FormatString.BigIntString1(BuffMgr.Instance.GetCharHp());
        charInfoNumberB[3].text = FormatString.TextEffectValue(eEffectType.Spd, BuffMgr.Instance.GetCharSpd());
        charInfoNumberB[4].text = FormatString.TextEffectValue(eEffectType.Mov, BuffMgr.Instance.GetCharMov());
        charInfoNumberB[5].text = FormatString.TextEffectValue(eEffectType.GoldDropRate, BuffMgr.Instance.GetGoldDropRate());
        charInfoNumberB[6].text = FormatString.TextEffectValue(eEffectType.ExpDropRate, BuffMgr.Instance.GetExpDropRate());
        charInfoNumberB[7].text = FormatString.TextEffectValue(eEffectType.ChestDropRate, BuffMgr.Instance.GetChestDropRate());
        charInfoNumberB[8].text = FormatString.TextEffectValue(eEffectType.SkillDamage, BuffMgr.Instance.GetSkillDamage());
        charInfoNumberB[9].text = FormatString.TextEffectValue(eEffectType.SkillCool, BuffMgr.Instance.GetSkillCooldownReduce());
        charInfoNumberB[10].text = FormatString.TextEffectValue(eEffectType.HealPerSec, BuffMgr.Instance.GetHpHealPerSec());
        charInfoNumberB[11].text = FormatString.TextEffectValue(eEffectType.DgGoldBonus, BuffMgr.Instance.GetDgGoldBonus());
        charInfoNumberB[12].text = FormatString.TextEffectValue(eEffectType.DgReinStoneBonus, BuffMgr.Instance.GetDgReinStoneBonus());
        charInfoNumberB[13].text = FormatString.TextEffectValue(eEffectType.DgPetBonus, BuffMgr.Instance.GetDgPetBonus());
        charInfoNumberB[14].text = FormatString.TextEffectValue(eEffectType.DgAwakneStoneBonus, BuffMgr.Instance.GetDgAwakenStoneBonus());


        int icrtrate = BuffMgr.Instance.GetCharCrtRate();
        int icrtmul = icrtrate / dConst.RateMax + 1;
        int irate = icrtrate % dConst.RateMax;
        charInfoNameB[2].text = FormatString.StringFormat(LocalizationText.GetText("stat_kind_bottom3"), icrtmul.ToString());
        charInfoNumberB[2].text = FormatString.TextEffectValue(eEffectType.CrtRate, irate);
    }
    #endregion

    //골드 계산. 뱃지 확인용으로도 사용됨
    public static void CalcGoldEnhance()
    {
        int iMaxLv = 1000;
        BigInteger buyingCnt = 0L;
        int buyingCntInc = 1;
        BigInteger iprice = 0L;

        for (int i = 0; i < DataHandler.GetCharStats().Count; i++)
        {
            if (DataHandler.GetCharStat(i + 1).condType != 0 &&
                DataHandler.GetCharStatLevel(DataHandler.GetCharStat(i + 1).condType) < DataHandler.GetCharStat(i + 1).condValue)
            {
                curMgr.goldEnhanceBedge.SetActive(false);
                continue;
            }

            int ilevel = DataHandler.GetCharStat(i + 1).level;
            iMaxLv = DataHandler.GetCharStat(i + 1).maxLv;
            buyingCnt = DataHandler.GetCharStat(i + 1).buyingCount;
            buyingCntInc = DataHandler.GetCharStat(i + 1).buyingCntInc;


            iprice = SSingleRecalcGoldPrice(i + 1);

            //iprice = buyingCnt + (buyingCntInc * (intervalUpLevel));

            if (iprice <= DataHandler.Goods.gold && DataHandler.GetCharStat(i + 1).level <iMaxLv)
            {
                curMgr.mainEnhanceBedge.SetActive(true);
                curMgr.goldEnhanceBedge.SetActive(true);

                return;
            }

        }
        curMgr.goldEnhanceBedge.SetActive(false);
    }

    //포인트 계산. 뱃지 확인용으로 사용됨.
    public static void CalcPointEnhance()
    {
        int iMaxLv = 1000;
        BigInteger buyingCnt = 0L;
        int iprice = 0;

        for (int i = 0; i < DataHandler.GetCharLvPoints().Count; i++)
        {
            int ilevel = DataHandler.GetCharLvPoint(i + 1).level;
            iMaxLv = DataHandler.GetCharLvPoint(i + 1).maxLv;
            buyingCnt = DataHandler.GetCharLvPoint(i + 1).buyingCount;
            iprice = 1;

            if (iprice <= DataHandler.Goods.point && DataHandler.GetCharLvPoint(i + 1).level < iMaxLv)
            {
                curMgr.mainEnhanceBedge.SetActive(true);
                curMgr.pointEnhanceBedge.SetActive(true);

                return;
            }

        }

        curMgr.pointEnhanceBedge.SetActive(false);
    }
    public void EnhanceBedgeSetActive()
    {
        mainEnhanceBedge.SetActive(goldEnhanceBedge.activeSelf || pointEnhanceBedge.activeSelf);
    }

    public static void levelUpScrolRefresh()
    {
        curMgr.escrCharLvPointEnhance.scroller.RefreshActiveCellViews();
    }

    public static void SResetAwakenPreset()
    {
        if (curMgr.iSelectedTab < 0)
        {
            return;
        }
        curMgr.btnAwakenPresetSet(DataHandler.PlayAwaken.usePreset);

        StartSetAwakenPreset();
    }

    public static void TestSettingAwakenBtnTrue()
    {
        if (DataHandler.PlayAwaken.awaken > 0)
        {
            curMgr.btnStoneSpend.interactable = true;
        }

    }
}