using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using SimpleJSON;
using MVR.FileManagementSecure;

namespace ky1001
{
    public class SubSceneLoader : MVRScript
    {
        #region PluginInfo    
        public string pluginAuthor = "ky1001";
        public string pluginName = "SubSceneLoader";
        public string pluginVersion = "6a ランダム確認用";
        public string pluginDate = "2023-02-26";
        public string pluginDescription = "";
        #endregion

        private Atom _thisAtom;
        private Atom _targetAtom;
        private const string _subSceneSystemPath = "Custom/SubScene";
        private const string _addonPackagesPath = "AddonPackages";
        private const string _filePrefs = "AddonPackagesFilePrefs/";
        private const string _pluginDataPath = "Saves/PluginData/ky1001/SubSceneLoader";
        private JSONStorableBool _enableRnd;
        private JSONStorableBool _enableSubfolder;
        private JSONStorableBool _enableAutoLoad;
        private UIDynamicButton _loadSettingButton;
        private UIDynamicButton _saveSettingButton;
        private JSONStorableStringChooser _selectCount;
        private Dictionary<string, UIDynamicPopup> _subScenePopupDic = new Dictionary<string, UIDynamicPopup>();
        private Dictionary<string, UIDynamicButton> _setSubSceneButtonDic = new Dictionary<string, UIDynamicButton>();
        private Dictionary<string, UIDynamicToggle> _onlyFavToggle = new Dictionary<string, UIDynamicToggle>();
        private Dictionary<string, UIDynamicTextField> _currentText = new Dictionary<string, UIDynamicTextField>();
        private Dictionary<string, UIDynamicTextField> _subScenePathText = new Dictionary<string, UIDynamicTextField>();
        private Dictionary<string, JSONStorableStringChooser> _subSceneChooserDic = new Dictionary<string, JSONStorableStringChooser>();
        private Dictionary<string, JSONStorableString> _current = new Dictionary<string, JSONStorableString>();
        private Dictionary<string, JSONStorableBool> _onlyFavDic = new Dictionary<string, JSONStorableBool>();
        private Dictionary<string, string> _subScenePathDic = new Dictionary<string, string>();
        private Dictionary<string, JSONStorableString> _subSceneSelectedPathDic = new Dictionary<string, JSONStorableString>();
        private Dictionary<string, JSONStorableString> _filesInFolder = new Dictionary<string, JSONStorableString>();
        private Dictionary<string, List<string>> _subSceneListDic = new Dictionary<string, List<string>>();
        private Dictionary<string, List<string>> _favListDic = new Dictionary<string, List<string>>();
        private Dictionary<string, List<string>> _listDic = new Dictionary<string, List<string>>();
        private Dictionary<string, List<int>> _randomOrder = new Dictionary<string, List<int>>();
        private Dictionary<string, JSONStorableString> _previousNumber = new Dictionary<string, JSONStorableString>();
        private Dictionary<string, string> _favPathDic = new Dictionary<string, string>();
        private Dictionary<string, string> _subScenePathDicXXX = new Dictionary<string, string>();
        private List<string> _targetChoices = new List<string>();
        private List<string> _subSceneList = new List<string>();
        private List<string> _favList = new List<string>();
        private string _varFileName;
        private string _varFullName;
        private string _varFullPath;
        private string _previousSelectCount;
        private string _currentSubScene;
        private string _nextSubScene = "SubScene1";
        private bool _loopStart = false;
        private float _waitCount;
        private int _startTime;
        private int _currentTime;
        private int _selectTime;
        private int _subSceneWaitStart;
        private const int _jsonstringLimit = 15000;
        private string _sceneVar;
        private JSONStorableBool _enablePathInSceneVar;
        private JSONStorableBool _enableBackwardLoop;
        private bool _backward;
        private bool _started = false;

        private readonly string[] _subScenes = new string[]
        {
            "SubScene1",
            "SubScene2",
            "SubScene3",
            "SubScene4"
        };

        public override void Init()
        {
            try
            {
                var sceneDir = SuperController.singleton.currentLoadDir;
                if (sceneDir.Contains(":"))
                {
                    var sceneDirSplit = sceneDir.Split(':');
                    _sceneVar = sceneDirSplit[0];
                }
                else
                {
                    _sceneVar = "";
                }

                _thisAtom = containingAtom;

                var AddSubSceneButton = CreateButton("Add SubScene", true);
                AddSubSceneButton.buttonColor = Color.yellow;
                AddSubSceneButton.button.onClick.AddListener(AddSubScene);
                JSONStorableAction AddSubSceneAct = new JSONStorableAction("Add SubScene", AddSubScene);

                var LoadSubSceneButton = CreateButton("Load SubScene");
                LoadSubSceneButton.button.onClick.AddListener(LoadSubScene);
                JSONStorableAction LoadSubSceneAct = new JSONStorableAction("Load SubScene", LoadSubScene);

                var BackwardButton = CreateButton("Backward");
                BackwardButton.button.onClick.AddListener(BackwardLoad);
                JSONStorableAction BackwardAct = new JSONStorableAction("Backward", BackwardLoad);

                _enableBackwardLoop = new JSONStorableBool("Enable Backward Loop", false);
                CreateToggle(_enableBackwardLoop, true);

                var RefreshListButton = CreateButton("Refresh SubScene and File Lists", true);
                RefreshListButton.button.onClick.AddListener(RefreshAllList);
                JSONStorableAction RefreshListAct = new JSONStorableAction("Refresh SubScene and File Lists", RefreshAllList);

                _enableAutoLoad = new JSONStorableBool("Enable Auto Load", false);
                CreateToggle(_enableAutoLoad, true);

                _enableRnd = new JSONStorableBool("Enable Random Load", false);
                var enableRnd = CreateToggle(_enableRnd);
                enableRnd.toggle.onValueChanged.AddListener(delegate { ResetCount(); });

                _enableSubfolder = new JSONStorableBool("Include Subfolder", true);
                var enableSubfolderToggle = CreateToggle(_enableSubfolder);
                enableSubfolderToggle.toggle.onValueChanged.AddListener(delegate { RefreshList(); });

                _enablePathInSceneVar = new JSONStorableBool("Enable Path in Scene var", true);
                var isUseIncludedDataToggle = CreateToggle(_enablePathInSceneVar);
                isUseIncludedDataToggle.toggle.onValueChanged.AddListener(delegate { RefreshList(); });

                List<string> waitCount = new List<string>();
                waitCount.Add("15");
                waitCount.Add("30");
                waitCount.Add("60");
                waitCount.Add("120");
                waitCount.Add("180");

                _selectCount = new JSONStorableStringChooser("Interval", waitCount, "30", "Interval [sec]");
                var sc = CreatePopup(_selectCount, true);

                var sp = CreateSpacer(false);
                sp.height = 12f;

                MakeList();

                foreach (var item in _subScenes)
                {
                    MakeUi(item);
                }

                _loadSettingButton = CreateButton("Load Setting");
                _loadSettingButton.buttonColor = Color.cyan;
                _saveSettingButton = CreateButton("Save Setting", true);
                _saveSettingButton.buttonColor = Color.cyan;

                _loadSettingButton.button.onClick.AddListener(() =>
                {
                    if (!FileManagerSecure.DirectoryExists(_pluginDataPath))
                    {
                        FileManagerSecure.CreateDirectory(_pluginDataPath);
                    }
                    var shortcuts = FileManagerSecure.GetShortCutsForDirectory(_pluginDataPath, false, false, true, true);
                    SuperController.singleton.GetMediaPathDialog(LoadSetting, "json", _pluginDataPath, true, true, false, null, false, shortcuts);
                });

                _saveSettingButton.button.onClick.AddListener(() =>
                {
                    if (!FileManagerSecure.DirectoryExists(_pluginDataPath))
                    {
                        FileManagerSecure.CreateDirectory(_pluginDataPath);
                    }
                    var fileBrowserUI = SuperController.singleton.fileBrowserUI;
                    fileBrowserUI.SetTitle("Save SubSceneLoader Setting");
                    fileBrowserUI.fileRemovePrefix = null;
                    fileBrowserUI.hideExtension = false;
                    fileBrowserUI.keepOpen = false;
                    fileBrowserUI.fileFormat = "json";
                    fileBrowserUI.defaultPath = _pluginDataPath;
                    fileBrowserUI.showDirs = true;
                    fileBrowserUI.shortCuts = null;
                    fileBrowserUI.browseVarFilesAsDirectories = true;
                    fileBrowserUI.SetTextEntry(true);
                    fileBrowserUI.Show(SaveSetting);
                    fileBrowserUI.fileEntryField.text = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds + ".json";
                    fileBrowserUI.ActivateFileNameField();
                    fileBrowserUI.showInstallFolderInDirectoryList = true;
                });

                Dictionary<string, JSONStorableAction> SetSubScenePathAct = new Dictionary<string, JSONStorableAction>();
                foreach (var item in _subScenes)
                {
                    SetSubScenePathAct[item] = new JSONStorableAction("Set " + item + " Path", () =>
                    {
                        SetSubScenePath(item);
                    });
                }

                var subScene1 = "SubScene1";
                var subScene2 = "SubScene2";
                var subScene3 = "SubScene3";
                var subScene4 = "SubScene4";

                RegisterAction(LoadSubSceneAct);
                RegisterAction(BackwardAct);
                RegisterBool(_enableBackwardLoop);
                RegisterBool(_enableRnd);
                RegisterBool(_enableSubfolder);
                RegisterBool(_enablePathInSceneVar);
                RegisterBool(_enableAutoLoad);
                RegisterAction(AddSubSceneAct);
                RegisterAction(RefreshListAct);
                RegisterStringChooser(_selectCount);
                RegisterStringChooser(_subSceneChooserDic[subScene1]);
                RegisterStringChooser(_subSceneChooserDic[subScene2]);
                RegisterStringChooser(_subSceneChooserDic[subScene3]);
                RegisterStringChooser(_subSceneChooserDic[subScene4]);
                RegisterBool(_onlyFavDic[subScene1]);
                RegisterBool(_onlyFavDic[subScene2]);
                RegisterBool(_onlyFavDic[subScene3]);
                RegisterBool(_onlyFavDic[subScene4]);
                RegisterString(_subSceneSelectedPathDic[subScene1]);
                RegisterString(_subSceneSelectedPathDic[subScene2]);
                RegisterString(_subSceneSelectedPathDic[subScene3]);
                RegisterString(_subSceneSelectedPathDic[subScene4]);
                RegisterAction(SetSubScenePathAct[subScene1]);
                RegisterAction(SetSubScenePathAct[subScene2]);
                RegisterAction(SetSubScenePathAct[subScene3]);
                RegisterAction(SetSubScenePathAct[subScene4]);
                RegisterString(_previousNumber[subScene1]);
                RegisterString(_previousNumber[subScene2]);
                RegisterString(_previousNumber[subScene3]);
                RegisterString(_previousNumber[subScene4]);
            }
            catch (Exception e)
            {
                SuperController.LogError("Exception caught: " + e);
            }
        }

        public void MakeUi(string number)
        {
            _subSceneChooserDic[number] = new JSONStorableStringChooser(number, null, "None", number, MakeListByPopup);
            _subSceneChooserDic[number].choices = _targetChoices;
            _subScenePopupDic[number] = CreateScrollablePopup(_subSceneChooserDic[number]);
            _setSubSceneButtonDic[number] = CreateButton("Set Path for " + number);
            _setSubSceneButtonDic[number].button.onClick.AddListener(() =>
            {
                _currentSubScene = number;
                SetSubScene();
            });
            _current[number] = new JSONStorableString("", "");
            _currentText[number] = CreateTextField(_current[number], true);
            _currentText[number].height = 10f;
            _onlyFavDic[number] = new JSONStorableBool("Favorite Only " + number, false);
            _onlyFavToggle[number] = CreateToggle(_onlyFavDic[number]);
            _onlyFavToggle[number].toggle.onValueChanged.AddListener(delegate { SetSubScenePath(number); });
            _filesInFolder[number] = new JSONStorableString("", "");
            _subScenePathText[number] = CreateTextField(_filesInFolder[number], true);
            _subScenePathText[number].height = 115f;
            _subSceneSelectedPathDic[number] = new JSONStorableString(number + " Path", "");
            _subScenePathDic[number] = _subSceneSelectedPathDic[number].val;
            _previousNumber[number] = new JSONStorableString("SubScene Number in " + number, "1");
        }

        public void MakeListByPopup(string dummy)
        {
            MakeList();
            foreach (var item in _subScenes)
            {
                _subSceneChooserDic[item].choices = _targetChoices;
                if (!_targetChoices.Contains(_subSceneChooserDic[item].val))
                {
                    _subSceneChooserDic[item].val = "None";
                }
            }
        }

        public void MakeList()
        {
            _targetChoices = new List<string>();
            _targetChoices.Add("None");
            foreach (string atomUID in SuperController.singleton.GetAtomUIDs())
            {
                var targetAtom = SuperController.singleton.GetAtomByUid(atomUID);
                if (targetAtom.type == "SubScene")
                {
                    _targetChoices.Add(atomUID);
                }
            }
        }

        public void SetSubScene()
        {
            var shortcuts = FileManagerSecure.GetShortCutsForDirectory(_subSceneSystemPath);
            SuperController.singleton.GetDirectoryPathDialog(LoadSubSceneList, _subSceneSystemPath, shortcuts, false);
        }

        public void SetSubScenePath(string subSceneName)
        {
            _currentSubScene = subSceneName;
            LoadSubSceneList(_subSceneSelectedPathDic[subSceneName].val);
            if (_subScenePathDic[subSceneName] == "")
            {
                _favPathDic[subSceneName] = "";
                _favListDic[subSceneName] = new List<string>();
                _subScenePathDicXXX[subSceneName] = "";
                _subSceneListDic[subSceneName] = new List<string>();
            }
            ChangePath(subSceneName);
        }

        public void AddSubScene()
        {
            SuperController.singleton.AddAtomByType("SubScene", false, true, false);
            Invoke("CheckAddedAtom", 1f);
        }

        public void CheckAddedAtom()
        {
            MakeList();
            foreach (var item in _subScenes)
            {
                _subSceneChooserDic[item].choices = _targetChoices;
            }

            SuperController.singleton.SelectController(_thisAtom.mainController);
        }

        public void BackwardLoad()
        {
            foreach (var subSceneName in _subScenes)
            {
                int temp;
                int previousNumber;
                if (int.TryParse(_previousNumber[subSceneName].val, out temp))
                {
                    if (temp <= 2)
                    {
                        if (_enableBackwardLoop.val || _enableRnd.val)
                        {
                            if (temp == 2)
                            {
                                previousNumber = _listDic[subSceneName].Count - 1;
                            }
                            else
                            {
                                previousNumber = _listDic[subSceneName].Count - 2;
                            }
                        }
                        else
                        {
                            if (temp == 2)
                            {
                                previousNumber = _listDic[subSceneName].Count - 1;
                                previousNumber = 0;

                            }
                            else
                            {
                                previousNumber = _listDic[subSceneName].Count - 2;
                            }
                        }
                    }
                    else
                    {
                        previousNumber = temp - 3;
                    }
                }
                else
                {
                    previousNumber = 0;
                }

                _previousNumber[subSceneName].val = (previousNumber + 1).ToString();
            }

            LoadSubScene();
        }

        public void LoadSubScene()
        {
            if (_enableAutoLoad.val)
            {
                if (_loopStart)
                {
                    _waitCount = _selectTime;
                }
                else
                {
                    _loopStart = true;
                    return;
                }
            }
            else
            {
                _loopStart = false;
                _waitCount = 0;
            }

            /*
            if (_enableAutoLoad.val)
            {
                if (_loopStart)
                {
                    _waitCount = _selectTime;
                }
                else
                {
                    _loopStart = true;
                    return;
                }
            }
            else
            {
                _loopStart = false;
                _waitCount = 0;
            }
            */

            LoadSubSceneJson();
        }

        public void LoadSubSceneJson()
        {
            foreach (var subSceneName in _subScenes)
            {
                int number;
                if (_subSceneChooserDic[subSceneName].val != "None")
                {
                    _targetAtom = SuperController.singleton.GetAtomByUid(_subSceneChooserDic[subSceneName].val);
                    if (_listDic[subSceneName].Count != 0)
                    {
                        int temp;
                        int previousNumber;
                        if (int.TryParse(_previousNumber[subSceneName].val, out temp))
                        {
                            if (temp <= 1)
                            {
                                previousNumber = 0;
                            }
                            else
                            {
                                previousNumber = temp - 1;
                            }

                            if (previousNumber > _listDic[subSceneName].Count)
                            {
                                previousNumber = _listDic[subSceneName].Count - 1;
                            }
                        }
                        else
                        {
                            previousNumber = 0;
                        }

                        if (_listDic[subSceneName].Count == 1)
                        {
                            number = 0;
                        }
                        else
                        {
                            if (previousNumber >= _listDic[subSceneName].Count)
                            {
                                _previousNumber[subSceneName].val = "1";
                                previousNumber = 0;
                            }

                            if (_enableRnd.val)
                            {
                                number = _randomOrder[subSceneName][previousNumber];
                                previousNumber++;
                                if (previousNumber >= _listDic[subSceneName].Count)
                                {
                                    _randomOrder[subSceneName] = MakeRandomOrder(_listDic[subSceneName].Count, number);
                                    _previousNumber[subSceneName].val = "1";
                                }
                                else
                                {
                                    _previousNumber[subSceneName].val = (previousNumber + 1).ToString();
                                }
                            }
                            else
                            {
                                number = previousNumber;
                                previousNumber++;
                                if (previousNumber >= _listDic[subSceneName].Count)
                                {
                                    _previousNumber[subSceneName].val = "1";
                                }
                                else
                                {
                                    _previousNumber[subSceneName].val = (previousNumber + 1).ToString();
                                }
                            }
                        }

                        _current[subSceneName].val = _listDic[subSceneName][number];

                        _targetAtom.GetStorableByID("SubScene").GetUrlJSONParam("browsePath").val = _current[subSceneName].val;

                        SuperController.LogMessage(_current[subSceneName].val);

                        var setStartTime = DateTime.Now.Second * 1000 + DateTime.Now.Millisecond;
                        var currentTime = setStartTime;
                        do
                        {
                            currentTime = DateTime.Now.Second * 1000 + DateTime.Now.Millisecond;
                            if (setStartTime > currentTime)
                            {
                                currentTime += 60000;
                            }
                        }
                        while (currentTime - setStartTime < 200);
                        _targetAtom.GetStorableByID("SubScene").GetAction("LoadSubScene");
                        MakeList();
                        _subSceneChooserDic[subSceneName].val = _targetAtom.name;

                        _subSceneWaitStart = DateTime.Now.Second * 1000 + DateTime.Now.Millisecond;
                        /*
                        var currentTime2 = DateTime.Now.Second * 1000 + DateTime.Now.Millisecond;
                        do
                        {
                            currentTime2 = DateTime.Now.Second * 1000 + DateTime.Now.Millisecond;
                            if (currentTime2 < _subSceneWaitStart)
                            {
                                currentTime2 += 60000;
                            }
                        }
                        while (currentTime2 - _subSceneWaitStart < 1000);
                        */
                    }
                    else
                    {
                        _current[subSceneName].val = "";
                    }
                }
                else
                {
                    _current[subSceneName].val = "";
                }
            }
            _nextSubScene = "SubScene1";
        }

        public void ResetCount()
        {
            if (_enableRnd.val && _started)
            {
                foreach (var subSceneName in _subScenes)
                {
                    _previousNumber[subSceneName].val = "1";
                    _randomOrder[subSceneName] = MakeRandomOrder(_listDic[subSceneName].Count, 0);
                }
            }
            else
            {
                foreach (var subSceneName in _subScenes)
                {
                    _previousNumber[subSceneName].val = "1";
                }
            }
        }

        public void RefreshAllList()
        {
            var dummy = "";
            RefreshList();
            MakeListByPopup(dummy);
        }

        public void RefreshList()
        {
            foreach (var item in _subScenes)
            {
                if (_subSceneSelectedPathDic[item] != null && _subSceneSelectedPathDic[item].val != "")
                {
                    _listDic[item] = new List<string>();
                    _currentSubScene = item;
                    LoadSubSceneList(_subSceneSelectedPathDic[item].val);
                    if (_subScenePathDic[item] == "")
                    {
                        _favPathDic[item] = "";
                        _favListDic[item] = new List<string>();
                        _subScenePathDicXXX[item] = "";
                        _subSceneListDic[item] = new List<string>();
                    }
                    ChangePath(item);
                }
            }
        }

        public string MakeFilename(string path)
        {
            if (path != null && path != "")
            {
                path = path.Replace("\\", "/");
                if (!path.Contains(":"))
                {
                    if (path.Substring(0, 1) == "/")
                    {
                        path = path.Remove(0, 1);
                    }

                    if (!path.Contains(_subSceneSystemPath))
                    {
                        path = _subSceneSystemPath + "/" + path;
                    }
                }
                else
                {
                    if (path.Contains(".var:"))
                    {
                        path = path.Replace(".var:", ":");
                    }

                    if (!path.Contains(":/"))
                    {
                        path = path.Replace(":", ":/");
                    }

                    string[] div = { ":/" };
                    var pathSplit = path.Split(div, StringSplitOptions.None);
                    if (!pathSplit[1].Contains(_subSceneSystemPath))
                    {
                        pathSplit[1] = (_subSceneSystemPath + "/" + pathSplit[1]);
                    }

                    var varPathSplit = pathSplit[0].Split('/');
                    var varNameFull = varPathSplit[varPathSplit.Length - 1];
                    var varNameSplit = varNameFull.Split('.');
                    var varName = varNameSplit[0] + "." + varNameSplit[1];

                    var varExist = FileManagerSecure.FileExists(pathSplit[0] + ".var");
                    if (varExist)
                    {
                        path = varNameFull + ":/" + pathSplit[1];
                    }
                    else
                    {
                        varExist = FileManagerSecure.FileExists(_addonPackagesPath + "/" + varNameFull + ".var");
                        if (varExist)
                        {
                            path = varNameFull + ":/" + pathSplit[1];
                        }
                        else
                        {
                            int i = 100;
                            bool varExistFull;
                            bool varExistKy;
                            do
                            {
                                i--;
                                varExistFull = FileManagerSecure.FileExists(pathSplit[0].Remove(pathSplit[0].LastIndexOf(".")) + "." + i.ToString() + ".var");
                                varExist = FileManagerSecure.FileExists(_addonPackagesPath + "/" + varName + "." + i.ToString() + ".var");
                                varExistKy = FileManagerSecure.FileExists(_addonPackagesPath + "/" + _addonPackagesPath + "/" + varName + "." + i.ToString() + ".var");
                            }
                            while (!varExistFull && !varExist && !varExistKy && i > 0);

                            if (i != 0)
                            {
                                path = varName + "." + i.ToString() + ":/" + pathSplit[1];
                            }
                            else
                            {
                                ArrayList allFiles = new ArrayList();
                                SearchFile(_addonPackagesPath, varName + ".*.var", ref allFiles);
                                var searchedFiles = (string[])allFiles.ToArray(typeof(string));
                                List<string> varFiles = new List<string>();

                                if (searchedFiles != null)
                                {
                                    foreach (var item in searchedFiles)
                                    {
                                        var searchedFilesSplit = item.Replace("\\", "/").Split('/');
                                        var searchedVarName = searchedFilesSplit[searchedFilesSplit.Length - 1];
                                        searchedVarName = searchedVarName.Remove(searchedVarName.LastIndexOf(".var"));
                                        varFiles.Add(searchedVarName);
                                    }

                                    if (varFiles.Contains(varNameFull))
                                    {
                                        varName = varNameFull;
                                    }
                                    else
                                    {
                                        int latest = 1;
                                        foreach (var item in varFiles)
                                        {
                                            var itemSplit = item.Split('.');
                                            if (latest <= int.Parse(itemSplit[2]))
                                            {
                                                latest = int.Parse(itemSplit[2]);
                                            }
                                        }
                                        varName = varNameFull.Remove(varNameFull.LastIndexOf(".")) + "." + latest.ToString();
                                    }
                                    path = varName + ":/" + pathSplit[1];
                                }
                                else
                                {
                                    path = "";
                                }
                            }
                        }
                    }
                }
                return path;
            }
            return "";
        }

        public void SaveSetting(string path)
        {
            if (path != null && path != "")
            {
                JSONClass saveData = new JSONClass();
                saveData["Enable Random Load"] = _enableRnd.val.ToString();
                saveData["Include Subfolder"] = _enableSubfolder.val.ToString();
                saveData["Enable Path in Scene var"] = _enablePathInSceneVar.val.ToString();
                saveData["Enable Auto Load"] = _enableAutoLoad.val.ToString();
                saveData["Interval"] = _selectCount.val;

                foreach (var item in _subScenes)
                {
                    saveData[item]["Selected SubScene"] = _subSceneChooserDic[item].val;
                    saveData[item]["Favorite Only"] = _onlyFavDic[item].val.ToString();
                    saveData[item]["SubScene Path"] = _subSceneSelectedPathDic[item].val.ToString();
                }

                if (path.Length < 5 || path.Substring(path.Length - 5) != ".json")
                {
                    path = path + ".json";
                }
                SaveJSON(saveData, path);
            }
        }

        public void LoadSetting(string path)
        {
            if (path != null && path != "")
            {
                var loadData = SuperController.singleton.ReadFileIntoString(path);
                JSONNode jSONNode = JSON.Parse(loadData);
                _enableRnd.val = bool.Parse(jSONNode["Enable Random Load"]);
                _enableSubfolder.val = bool.Parse(jSONNode["Include Subfolder"]);
                _enableAutoLoad.val = bool.Parse(jSONNode["Enable Auto Load"]);
                _selectCount.val = jSONNode["Interval"];
                if (jSONNode["Enable Path in Scene var"] != null)
                {
                    _enablePathInSceneVar.val = bool.Parse(jSONNode["Enable Path in Scene var"]);
                }

                foreach (var item in _subScenes)
                {
                    _subSceneChooserDic[item].val = jSONNode[item][0];
                    _subSceneSelectedPathDic[item].val = jSONNode[item][2];
                    _currentSubScene = item;
                    LoadSubSceneList(_subSceneSelectedPathDic[item].val);
                    if (_subScenePathDic[item] == "")
                    {
                        _favPathDic[item] = "";
                        _favListDic[item] = new List<string>();
                        _subScenePathDicXXX[item] = "";
                        _subSceneListDic[item] = new List<string>();
                    }
                    ChangePath(item);
                    _onlyFavDic[item].val = bool.Parse(jSONNode[item][1]);
                }
            }
        }

        public void ChangePath(string subSceneName)
        {
            if (_onlyFavDic[subSceneName].val)
            {
                _filesInFolder[subSceneName].val = _favPathDic[subSceneName];
                _listDic[subSceneName] = new List<string>(_favListDic[subSceneName]);
            }
            else
            {
                _filesInFolder[subSceneName].val = _subScenePathDicXXX[subSceneName];
                _listDic[subSceneName] = new List<string>(_subSceneListDic[subSceneName]);
            }
            _previousNumber[subSceneName].val = "1";
            _randomOrder[subSceneName] = MakeRandomOrder(_listDic[subSceneName].Count, 0);
        }

        public void LoadSubSceneList(string path)
        {
            if (path != null && path != "")
            {
                _subSceneSelectedPathDic[_currentSubScene].val = path;
                path = MakeFilename(path);

                if (!path.Contains(":") && _sceneVar != "")
                {
                    var tempPath = _sceneVar + ":/" + path;
                    if (FileManagerSecure.DirectoryExists(tempPath) && _enablePathInSceneVar.val)
                    {
                        path = tempPath;
                    }
                    else if (!FileManagerSecure.DirectoryExists(path))
                    {
                        path = tempPath;
                    }
                }

                _varFileName = "";
                string favPath;
                if (path.Contains(":"))
                {
                    var pathSplit = path.Split(':');
                    _varFileName = pathSplit[0];
                    favPath = _filePrefs + _varFileName + pathSplit[1];
                }
                else
                {
                    favPath = path;
                }

                string[] subSceneFiles;
                string[] favFiles;
                string subSceneFilelist = "";
                string favFilelist = "";

                if (_enableSubfolder.val)
                {
                    ArrayList allFiles = new ArrayList();
                    GetAllFiles(path, "*.json", ref allFiles);
                    subSceneFiles = (string[])allFiles.ToArray(typeof(string));
                    Array.Sort(subSceneFiles);
                    _subSceneList = new List<string>();
                    foreach (var item in subSceneFiles)
                    {
                        string tempFileName = item.Replace("\\", "/");
                        if (tempFileName.Contains(":"))
                        {
                            var itemSplit = tempFileName.Split(':');
                            tempFileName = _varFileName + ":" + itemSplit[1];
                            _subSceneList.Add(tempFileName);
                            tempFileName = _varFileName + ":" + itemSplit[1].Remove(0, _subSceneSystemPath.Length + 2);
                        }
                        else
                        {
                            _subSceneList.Add(tempFileName);
                            tempFileName = tempFileName.Remove(0, _subSceneSystemPath.Length + 1);
                        }
                        tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".json"));

                        if (subSceneFilelist.Length < _jsonstringLimit)
                        {
                            subSceneFilelist = subSceneFilelist + tempFileName + "\n";
                        }
                    }

                    allFiles = new ArrayList();
                    if (FileManagerSecure.DirectoryExists(favPath))
                    {
                        GetAllFiles(favPath, "*.json.fav", ref allFiles);
                        favFiles = (string[])allFiles.ToArray(typeof(string));
                        Array.Sort(favFiles);
                        _favList = new List<string>();
                        foreach (var item in favFiles)
                        {
                            string tempFileName = item.Replace("\\", "/");
                            if (tempFileName.Contains(_filePrefs))
                            {
                                var tempSplit = tempFileName.Split('/');
                                tempFileName = _varFileName + ":";
                                for (int i = 2; i < tempSplit.Length; i++)
                                {
                                    tempFileName = tempFileName + "/" + tempSplit[i];
                                }
                            }
                            tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".fav"));
                            _favList.Add(tempFileName);

                            if (favFilelist.Length < _jsonstringLimit)
                            {
                                tempFileName = tempFileName.Replace(_subSceneSystemPath + "/", "").Replace(":/", ":");
                                tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".json"));
                                favFilelist = favFilelist + tempFileName + "\n";
                            }
                        }
                    }
                    else
                    {
                        _favList = new List<string>();
                        favFilelist = "";
                    }
                }
                else
                {
                    subSceneFiles = FileManagerSecure.GetFiles(path, "*.json");
                    Array.Sort(subSceneFiles);
                    _subSceneList = new List<string>();
                    foreach (var item in subSceneFiles)
                    {
                        string tempFileName = item.Replace("\\", "/");
                        if (tempFileName.Contains(":"))
                        {
                            var itemSplit = tempFileName.Split(':');
                            tempFileName = _varFileName + ":" + itemSplit[1];
                            _subSceneList.Add(tempFileName);
                            tempFileName = _varFileName + ":" + itemSplit[1].Remove(0, _subSceneSystemPath.Length + 2);
                        }
                        else
                        {
                            _subSceneList.Add(tempFileName);
                            tempFileName = tempFileName.Remove(0, _subSceneSystemPath.Length + 1);
                        }
                        tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".json"));

                        if (subSceneFilelist.Length < _jsonstringLimit)
                        {
                            subSceneFilelist = subSceneFilelist + tempFileName + "\n";
                        }
                    }

                    if (FileManagerSecure.DirectoryExists(favPath))
                    {
                        favFiles = FileManagerSecure.GetFiles(favPath, "*.json.fav");
                        Array.Sort(favFiles);
                        _favList = new List<string>();
                        foreach (var item in favFiles)
                        {
                            string tempFileName = item.Replace("\\", "/");
                            if (tempFileName.Contains(_filePrefs))
                            {
                                var tempSplit = tempFileName.Split('/');
                                tempFileName = _varFileName + ".var:";
                                for (int i = 2; i < tempSplit.Length; i++)
                                {
                                    tempFileName = tempFileName + "/" + tempSplit[i];
                                }
                            }
                            tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".fav"));
                            _favList.Add(tempFileName);

                            if (favFilelist.Length < _jsonstringLimit)
                            {
                                tempFileName = tempFileName.Replace(_subSceneSystemPath + "/", "").Replace(":/", ":");
                                tempFileName = tempFileName.Remove(tempFileName.LastIndexOf(".json"));
                                favFilelist = favFilelist + tempFileName + "\n";
                            }
                        }
                    }
                    else
                    {
                        _favList = new List<string>();
                        favFilelist = "";
                    }
                }

                _subSceneListDic[_currentSubScene] = new List<string>(_subSceneList);
                _subScenePathDicXXX[_currentSubScene] = subSceneFilelist;
                _favListDic[_currentSubScene] = new List<string>(_favList);
                _favPathDic[_currentSubScene] = favFilelist;

                if (_onlyFavDic[_currentSubScene].val)
                {
                    _filesInFolder[_currentSubScene].val = _favPathDic[_currentSubScene];
                    _listDic[_currentSubScene] = new List<string>(_favListDic[_currentSubScene]);
                }
                else
                {
                    _filesInFolder[_currentSubScene].val = _subScenePathDicXXX[_currentSubScene];
                    _listDic[_currentSubScene] = new List<string>(_subSceneListDic[_currentSubScene]);
                }

                _subScenePathDic[_currentSubScene] = path;
                _randomOrder[_currentSubScene] = MakeRandomOrder(_listDic[_currentSubScene].Count, 0);
            }
        }

        public static void GetAllFiles(string folder, string filter, ref ArrayList allFiles)
        {
            string[] filses = FileManagerSecure.GetFiles(folder, filter);
            allFiles.AddRange(filses);

            string[] subFolders = FileManagerSecure.GetDirectories(folder);
            foreach (string subF in subFolders)
            {
                GetAllFiles(subF, filter, ref allFiles);
            }
        }

        public List<int> MakeRandomOrder(int number, int lastOne)
        {
            if (number != 0)
            {
                List<int> randomOrder = new List<int>();
                List<int> tempList = new List<int>();
                if (number == 1)
                {
                    randomOrder.Add(0);
                }
                else if (number == 2)
                {
                    if (lastOne == 0)
                    {
                        randomOrder.Add(1);
                        randomOrder.Add(0);
                    }
                    else
                    {
                        randomOrder.Add(0);
                        randomOrder.Add(1);
                    }
                }
                else
                {
                    for (int i = 0; i < number; i++)
                    {
                        tempList.Add(i);
                    }

                    int randomNumber;
                    do
                    {
                        randomNumber = UnityEngine.Random.Range(0, number);
                    }
                    while (randomNumber == lastOne);
                    randomOrder.Add(tempList[randomNumber]);
                    tempList.Remove(randomNumber);
                    number--;
                    do
                    {
                        randomNumber = UnityEngine.Random.Range(0, number);
                        randomOrder.Add(tempList[randomNumber]);
                        tempList.RemoveAt(randomNumber);
                        number--;
                    }
                    while (number > 0);
                }
                return randomOrder;
            }
            else
            {
                return null;
            }
        }

        public static void SearchFile(string folder, string filter, ref ArrayList allFiles)
        {
            string[] filses = FileManagerSecure.GetFiles(folder, filter);
            allFiles.AddRange(filses);

            string[] subFolders = FileManagerSecure.GetDirectories(folder);
            foreach (string subF in subFolders)
            {
                SearchFile(subF, filter, ref allFiles);
            }
        }

        // Start is called once before Update or FixedUpdate is called and after Init()
        void Start()
        {
            try
            {
                foreach (var item in _subScenes)
                {
                    _currentSubScene = item;
                    LoadSubSceneList(_subSceneSelectedPathDic[item].val);
                    if (_subScenePathDic[item] == "")
                    {
                        _favPathDic[item] = "";
                        _favListDic[item] = new List<string>();
                        _subScenePathDicXXX[item] = "";
                        _subSceneListDic[item] = new List<string>();
                    }
                    ChangePath(item);
                }
            }
            catch (Exception e)
            {
                SuperController.LogError("Exception caught: " + e);
            }
            _started = true;
        }

        // Update is called with each rendered frame by Unity
        void Update()
        {
            try
            {
                // put code in here
            }
            catch (Exception e)
            {
                SuperController.LogError("Exception caught: " + e);
            }
        }

        // FixedUpdate is called with each physics simulation frame by Unity
        void FixedUpdate()
        {
            try
            {
                if (_previousSelectCount != _selectCount.val)
                {
                    _waitCount = 0;
                }

                /*
                foreach (var subSceneName in _subScenes)
                {
                    if (_subSceneChooserDic[subSceneName].val == "None")
                    {
                        _previousNumber[subSceneName].val = "1";
                    }
                }
                */

                _selectTime = int.Parse(_selectCount.val);
                if (_enableAutoLoad.val && _loopStart)
                {
                    if (_waitCount <= 0 && _nextSubScene == "SubScene1")
                    {
                        _waitCount = _selectTime;
                        _startTime = DateTime.Now.Minute * 60 + DateTime.Now.Second;
                        LoadSubScene();
                    }

                    _currentTime = DateTime.Now.Minute * 60 + DateTime.Now.Second;
                    if (_currentTime < _startTime)
                    {
                        _currentTime += 3600;
                    }
                    _waitCount = _selectTime - (_currentTime - _startTime);
                }
                else
                {
                    _loopStart = false;
                    _waitCount = _selectTime;
                }

                _previousSelectCount = _selectCount.val;
            }
            catch (Exception e)
            {
                SuperController.LogError("Exception caught: " + e);
            }
        }

        // OnDestroy is where you should put any cleanup
        // if you registered objects to supercontroller or atom, you should unregister them here
        void OnDestroy()
        {
        }

    }
}