Studio/Assets/NewStudioJYM/Scripts/Panel_DataConnectModal.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using XRLib;
using XRLib.UI;

namespace XED
{
    public class Panel_DataConnectModal : PanelBase
    {
        public Data api;
        public Data dataStorage;

        private List<DataClass> apiDatas = new List<DataClass>();
        private List<DataClass> dataStorageDatas = new List<DataClass>();
        private bool isAPI;

        public Toggle Toggle_Api;
        public Toggle Toggle_Storage;
        public TMP_Dropdown Dropdown_DataList;
        public Button Button_Cancel;
        public Button Button_Save;

        private RectTransform RectTransform_APIData;
        private RectTransform AddStorageDataButtonArea;
        private RectTransform APIDataListContent;
        private RectTransform APIContent;
        private Button Button_loadAPIData;
        private Button Button_AddStorageData;
        
        private DataClass loadAPIData;
        private List<UI_LoadDataHierarchyItem> currentAPIDataItems = new List<UI_LoadDataHierarchyItem>();
       
        private RectTransform RectTransform_DataStorage;
        private RectTransform DataStorageContent;
        private RectTransform AddAPIDataButtonArea;
        private Button Button_AddAPIData;
        private Toggle Toggle_limitStorageSetting;

        private UI_LoadDataHierarchyItem prf_loadDataHierarchyItem;
        private UI_DataSettingItem prf_DataSettingItem;
        private UI_DataTypeSelectedItem prf_DataTypeSelectedItem;
        private UI_MatchingTypeDataItem prf_MatchingTypeDataItem;
        private UI_AddOtherDataItem prf_AddOtherDataItem;
        private UI_AddOtherDataTypeItem prf_AddOtherDataTypeItem;

        private RectTransform currentContent;
        private RectTransform currentButtonArea;
        public UI_DataSettingItem currentDataSettingItem;
        public List<UI_AddOtherDataItem> currentAddOtherDataItems = new List<UI_AddOtherDataItem>();

        private string currentDataListOptionName;
        private DataClass currentClass;

        public Action<string, SaveConnectedData> onSaveConnectedData;

        private void TestDataConnected()
        {
            var apiJson = Resources.Load<TextAsset>("Test").text;
            api = JsonConvert.DeserializeObject<Data>(apiJson);

            var dataStorageJson = Resources.Load<TextAsset>("Test1").text;
            dataStorage = JsonConvert.DeserializeObject<Data>(dataStorageJson);
        }
        public override void AfterAwake()
        {
            TestDataConnected();

            prf_loadDataHierarchyItem = Resources.Load<UI_LoadDataHierarchyItem>("Prefabs/UI/PRF_LoadDataHierarchyItem");
            prf_DataSettingItem = Resources.Load<UI_DataSettingItem>("Prefabs/UI/PRF_DataSettingItem");
            prf_DataTypeSelectedItem = Resources.Load<UI_DataTypeSelectedItem>("Prefabs/UI/PRF_DataTypeSelectedItem");
            prf_MatchingTypeDataItem = Resources.Load<UI_MatchingTypeDataItem>("Prefabs/UI/PRF_MatchingTypeDataItem");
            prf_AddOtherDataItem = Resources.Load<UI_AddOtherDataItem>("Prefabs/UI/PRF_AddOtherDataItem");
            prf_AddOtherDataTypeItem = Resources.Load<UI_AddOtherDataTypeItem>("Prefabs/UI/PRF_AddOtherDataTypeItem");

            Toggle_Api.onValueChanged.AddListener(OnAPIToggleValueChanged);
            Toggle_Storage.onValueChanged.AddListener(OnDataStorageToggleValueChanged);
            Toggle_limitStorageSetting.onValueChanged.AddListener(OnLimitStorageSettingToggleValueChanged);

            Button_loadAPIData.onClick.AddListener(LoadAPIData);
            Button_AddStorageData.onClick.AddListener(() => AddOtherDataItem(null));
            Button_AddAPIData.onClick.AddListener(() => AddOtherDataItem(null));
            Button_Cancel.onClick.AddListener(CloseModal);
            Button_Save.onClick.AddListener(Save);

            RectTransform_APIData.gameObject.SetActive(false);
            RectTransform_DataStorage.gameObject.SetActive(false);
        }
        private void OnAPIToggleValueChanged(bool isOn)
        {
            if (isOn)
            {
                RectTransform_APIData.gameObject.SetActive(true);
                ChangePanel(APIContent, AddStorageDataButtonArea);

                isAPI = true;
                PopulateDataListDropdown(api.dataList);
                Toggle_Storage.isOn = false;
                Toggle_limitStorageSetting.isOn = true;
            }
            else
            {
                RectTransform_APIData.gameObject.SetActive(false);
            }
        }
        private void OnDataStorageToggleValueChanged(bool isOn)
        {
            if (isOn)
            {
                RectTransform_DataStorage.gameObject.SetActive(true);
                ChangePanel(DataStorageContent, AddAPIDataButtonArea);

                isAPI = false;
                PopulateDataListDropdown(dataStorage.dataList);
                Toggle_Api.isOn = false;
                Toggle_limitStorageSetting.isOn = false;
            }
            else
            {
                RectTransform_DataStorage.gameObject.SetActive(false);
            }
        }
        private void ChangePanel(RectTransform dataContent, RectTransform buttonArea)
        {
            currentContent = dataContent;
            currentButtonArea = buttonArea;

            currentDataSettingItem = currentContent.GetComponentInChildren<UI_DataSettingItem>();
            currentAddOtherDataItems.Clear();
            var currentAddOtherDataItem = currentContent.GetComponentsInChildren<UI_AddOtherDataItem>().ToList();
            currentAddOtherDataItems.AddRange(currentAddOtherDataItem);
        }
        private void OnLimitStorageSettingToggleValueChanged(bool isOn)
        {
            var isActive = isOn;
            DataStorageContent.gameObject.SetActive(isActive);
        }
        private void PopulateDataListDropdown(List<DataClass> data)
        {
            Dropdown_DataList.ClearOptions();
            List<string> displayNames = new List<string>();

            if (isAPI)
            {
                apiDatas.Clear();

                foreach (var api in data)
                {
                    apiDatas.Add(api);
                    displayNames.Add(api.name);
                }

                Dropdown_DataList.AddOptions(displayNames);
                Dropdown_DataList.onValueChanged.RemoveAllListeners();
                Dropdown_DataList.onValueChanged.AddListener(OnValueChangedAPIDropDown);

                var notCheckIndex = currentDataListOptionName != null ? displayNames.IndexOf(currentDataListOptionName) : 0;
                var index = notCheckIndex >= 0 ? notCheckIndex : 0;

                Dropdown_DataList.SetValueWithoutNotify(index);
                SetLoadApiData(index);
            }
            else
            {
                dataStorageDatas.Clear();

                foreach (var storageData in data)
                {
                    dataStorageDatas.Add(storageData);
                    displayNames.Add(storageData.name);
                }

                Dropdown_DataList.AddOptions(displayNames);
                Dropdown_DataList.onValueChanged.RemoveAllListeners();
                Dropdown_DataList.onValueChanged.AddListener(OnValueChangedDataStorageDropDown);

                var notCheckIndex = currentDataListOptionName != null ? displayNames.IndexOf(currentDataListOptionName) : 0;
                var index = notCheckIndex >= 0 ? notCheckIndex : 0;

                Dropdown_DataList.SetValueWithoutNotify(index);
                OnValueChangedDataStorageDropDown(index);
            }
        }
        
        private void OnValueChangedAPIDropDown(int index)
        {
            SetLoadApiData(index);
        }
        private void SetLoadApiData(int index)
        {
            var apiData = apiDatas[index];
            loadAPIData = apiData;
        }

        void LoadAPIData()
        {
            foreach (var dataItem in currentAPIDataItems)
                Destroy(dataItem.gameObject);

            currentAPIDataItems.Clear();

            var item = Instantiate(prf_loadDataHierarchyItem, APIDataListContent);
            item.SetData(loadAPIData);
            item.onClickItem += OnClickAPIDataItem;
            currentAPIDataItems.Add(item);
        }
        private void OnClickAPIDataItem(DataClass data)
        {
            AddDataSettingItem(data);
        }
        private void OnValueChangedDataStorageDropDown(int index)
        {
            AddDataSettingItem(dataStorageDatas[index]);
        }
        private void UpdateLayout()
        {
            LayoutRebuilder.ForceRebuildLayoutImmediate(currentContent);
        }
        private void AddDataSettingItem(DataClass data)
        {
            if (currentDataSettingItem != null)
            {
                Destroy(currentDataSettingItem.gameObject);
                currentDataSettingItem = null;
            }

            var item = Instantiate(prf_DataSettingItem, currentContent);
            var index = currentButtonArea.transform.GetSiblingIndex();
            item.transform.SetSiblingIndex(index);
            item.SetData(data, prf_DataTypeSelectedItem, prf_MatchingTypeDataItem);
            item.onUpdateLayout += UpdateLayout;
            currentDataSettingItem = item;
        }
        private void AddOtherDataItem(DataClass data)
        {
            var item = Instantiate(prf_AddOtherDataItem, currentContent);
            item.onUpdateLayout += UpdateLayout;
            item.onDestory += RemoveOtherDataItem;
            item.SetItem(dataStorage.dataList, data, prf_AddOtherDataTypeItem);
            item.transform.SetAsLastSibling();
            currentAddOtherDataItems.Add(item);
        }
        private void RemoveOtherDataItem(UI_AddOtherDataItem item)
        {
            currentAddOtherDataItems.Remove(item);
            Destroy(item.gameObject);
        }
        public SaveConnectedData saveData;
        void Save()
        {
            saveData = GetData();
            onSaveConnectedData?.Invoke(saveData.dataSource, saveData);
            Initialize();
            gameObject.SetActive(false);
        }

        public void OpenModal()
        {
            gameObject.SetActive(true);
        }
        void CloseModal()
        {
            gameObject.SetActive(false);
        }
        private void Initialize()
        {
            Toggle_Api.SetIsOnWithoutNotify(false);
            Toggle_Storage.SetIsOnWithoutNotify(false);

            Toggle_limitStorageSetting.SetIsOnWithoutNotify(false);

            currentContent = null;
            currentButtonArea = null;

            loadAPIData = null;

            foreach (var item in currentAPIDataItems)
            {
                Destroy(item.gameObject);
            }
            currentAPIDataItems.Clear();

            if (currentDataSettingItem != null)
            {
                Destroy(currentDataSettingItem.gameObject);
                currentDataSettingItem = null;
            }

            foreach (var item in currentAddOtherDataItems)
            {
                Destroy(item.gameObject);
            }
            currentAddOtherDataItems.Clear();

            RectTransform_APIData.gameObject.SetActive(false);
            RectTransform_DataStorage.gameObject.SetActive(false);
        }
        private SaveConnectedData GetData()
        {
            SaveConnectedData saveData = new SaveConnectedData();
            saveData.connectDataClass.Clear();
            saveData.otherDataClasses.Clear();

            saveData.isAPI = isAPI;
            saveData.dataListOptionName = Dropdown_DataList.options[Dropdown_DataList.value].text;

            saveData.isLimitStorageSetting = Toggle_limitStorageSetting.isOn;

            var dataclass = currentDataSettingItem.GetData();
            saveData.dataSource = dataclass.name;
            saveData.connectDataClass.Add(dataclass);

            foreach (var item in currentAddOtherDataItems)
            {
                var otehrDataClass = item.GetData();
                saveData.otherDataClasses.Add(otehrDataClass);
            }

            return saveData;
        }
        public void SetLoadSaveData(SaveConnectedData saveData)
        {
            OpenModal();

            currentClass = saveData.connectDataClass[0];
            currentDataListOptionName = saveData.dataListOptionName;

            if (saveData.isAPI)
            {
                Toggle_Api.isOn = true;
                LoadAPIData();
            }
            else
            {
                Toggle_Storage.isOn = true;
                Toggle_limitStorageSetting.isOn = !saveData.isLimitStorageSetting;
                Toggle_limitStorageSetting.isOn = saveData.isLimitStorageSetting;
            }
            AddDataSettingItem(currentClass);

            foreach (var item in currentAddOtherDataItems)
            {
                Destroy(item.gameObject);
            }
            currentAddOtherDataItems.Clear();

            foreach (var otherClass in saveData.otherDataClasses)
            {
                AddOtherDataItem(otherClass);
            }
        }
    }
}