using System;
using UnityEngine;
//using UnityEngine.UI;
//using System.Collections;
using System.Collections.Generic;
//using System.Linq;
//using SimpleJSON;
using MVR.FileManagementSecure;

namespace ky1001
{
    public class HandMorphManager: MVRScript {

        #region PluginInfo    
        public string pluginAuthor = "ky1001";
        public string pluginName = "HandMorphManager";
        public string pluginVersion = "4.0";
        public string pluginDate = "2022-03-01";
        public string pluginDescription = "";
        #endregion

        #region Vars
        protected Atom CurrentAtom;

        //private const string _saveExt = "handmorph";
        private const string _saveExt = "json";
        private const string _handmorphSavePath = "Saves\\PluginData\\handmorph";
        public string SaveData;
        public string LoadData;

        public bool CSH;
        public bool CSF;
        public bool CSS;

        UIDynamic spacer1;
        UIDynamic spacer2;
        UIDynamic spacer3;

        protected JSONStorableBool toggle_x;
        protected JSONStorableBool toggle_l;
        protected JSONStorableBool toggle_r;
        protected JSONStorableString filename;

        protected JSONStorableBool toggle_es;
        protected JSONStorableBool toggle_el;
        protected JSONStorableBool toggle_er;
        
        JSONStorableFloat[] lMorphName;
        JSONStorableFloat[] rMorphName;

        private readonly string[] HandMorphs = new string[] {
            "Hand Fist",
            "Hand Grasp",
            "Hand Spread",
            "Hand Chop",
            "Hand Straighten",
            "Fingers Fist",
            "Fingers Grasp",
            "Fingers In-Out",
            "Fingers Squeeze",
            "Fingers Straighten",
            "Thumb Bend",
            "Index Finger Bend",
            "Mid Finger Bend",
            "Ring Finger Bend",
            "Pinky Finger Bend",
            "Thumb Fist",
            "Thumb Grasp",
            "Thumb In-Out",
            "Thumb Straighten",
        };
        #endregion
        
        #region Controls
        protected UIDynamicButton button;
        protected UIDynamicButton Getbutton;        
        protected UIDynamicButton clbutton;
        protected UIDynamicButton crbutton; 
        protected UIDynamicButton swbutton; 
        protected UIDynamicButton loadbutton;   
        protected UIDynamicButton savebutton;

        protected UIDynamicButton cshbutton;
        protected UIDynamicButton csfbutton;
        protected UIDynamicButton cssbutton;

        protected UIDynamicToggle toggleel;
        protected UIDynamicToggle toggleer;

        public UIDynamicSlider[] lSlider;
        public UIDynamicSlider[] rSlider;        
            
        private JSONStorable geometry;
        private DAZCharacterSelector character;
        private GenerateDAZMorphsControlUI morphControl;
        #endregion

        public override void Init()
        {
            try
            {
                #region Button
                geometry = containingAtom.GetStorableByID("geometry");
                character = geometry as DAZCharacterSelector;
                morphControl = character.morphsControlUI;

                var loadPresetUI = CreateButton("Load Preset");
                loadPresetUI.button.onClick.AddListener(() =>
                {
                    filename.val = "";
                    FileManagerSecure.CreateDirectory(_handmorphSavePath);
                    var shortcuts = FileManagerSecure.GetShortCutsForDirectory(_handmorphSavePath);
                    SuperController.singleton.GetMediaPathDialog(HandleLoadPreset, "json|handmorph", _handmorphSavePath, false, true, false, null, false, shortcuts);
                });
                JSONStorableAction LoadDatas = new JSONStorableAction("Load Hand Morphs without dialog", () =>
                {
                    HandleLoadPreset("");
                });
                RegisterAction(LoadDatas);

                var savePresetUI = CreateButton("Save Preset", true);
                savePresetUI.button.onClick.AddListener(() =>
                {
                    FileManagerSecure.CreateDirectory(_handmorphSavePath);
                    var fileBrowserUI = SuperController.singleton.fileBrowserUI;
                    fileBrowserUI.SetTitle("Save Hand Morphs preset");
                    fileBrowserUI.fileRemovePrefix = null;
                    fileBrowserUI.hideExtension = false;
                    fileBrowserUI.keepOpen = false;
                    fileBrowserUI.fileFormat = _saveExt;
                    fileBrowserUI.defaultPath = _handmorphSavePath;
                    fileBrowserUI.showDirs = true;
                    fileBrowserUI.shortCuts = null;
                    fileBrowserUI.browseVarFilesAsDirectories = false;
                    fileBrowserUI.SetTextEntry(true);
                    fileBrowserUI.Show(HandleSavePreset);
                    fileBrowserUI.fileEntryField.text = (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds + "." + _saveExt;
                    fileBrowserUI.ActivateFileNameField();
                });

                button = CreateButton("Hand Morphs to Default");
                if (button != null)
                {
                    button.button.onClick.AddListener(DefaultHandMorphs);
                }
                JSONStorableAction DefaultMorphs = new JSONStorableAction("Hand Morphs Set to Default", () =>
                {
                    DefaultHandMorphs();
                });
                RegisterAction(DefaultMorphs);

                Getbutton = CreateButton("Hand Morphs to Zero", true);
                if (Getbutton != null)
                {
                    Getbutton.button.onClick.AddListener(ZeroHandMorps);
                }
                JSONStorableAction ZeroMorphs = new JSONStorableAction("Hand Morphs Set to Zero", () =>
                {
                    ZeroHandMorps();
                });
                RegisterAction(ZeroMorphs);

                clbutton = CreateButton("Copy Left to Right", false);
                if (clbutton != null)
                {
                    clbutton.button.onClick.AddListener(CopyLtoR);
                }
                JSONStorableAction CopyLR = new JSONStorableAction("Hand Morphs Copy Left to Right", () =>
                {
                    CopyLtoR();
                });
                RegisterAction(CopyLR);

                crbutton = CreateButton("Copy Right to Left", true);
                if (crbutton != null)
                {
                    crbutton.button.onClick.AddListener(CopyRtoL);
                }
                JSONStorableAction CopyRL = new JSONStorableAction("Hand Morphs Copy Right to Left", () =>
                {
                    CopyRtoL();
                });
                RegisterAction(CopyRL);

                swbutton = CreateButton("Swap Left and Right", false);
                if (swbutton != null)
                {
                    swbutton.button.onClick.AddListener(SwapLandR);
                }
                JSONStorableAction SwapLR = new JSONStorableAction("Hand Morphs Swap Left and Right", () =>
                {
                    SwapLandR();
                });
                RegisterAction(SwapLR);

                toggle_x = new JSONStorableBool("Enable swap loading Preset", false);
                CreateToggle(toggle_x, true);
                RegisterBool(toggle_x);

                toggle_l = new JSONStorableBool("Enable loading Preset to Left", true);
                CreateToggle(toggle_l, false);
                RegisterBool(toggle_l);
                toggle_r = new JSONStorableBool("Enable loading Preset to Right", true);
                CreateToggle(toggle_r, true);
                RegisterBool(toggle_r);

                toggle_es = new JSONStorableBool("Enable Saveing L-R Separately", false);
                toggle_el = new JSONStorableBool("Enable Saveing Preset from Left", true);
                toggle_er = new JSONStorableBool("Enable Saveing Preset from Right", true);

                if (toggle_es.val)
                {
                    CreateToggle(toggle_el, false);
                    CreateToggle(toggle_er, true);
                }

                filename = new JSONStorableString("Hand Morph Manager Filename","Saves/PluginData/handmorph/");
                //UIDynamic filenameText = CreateTextField(filename, false);
                RegisterString(filename);
                #endregion

                
                #region Sliders
                lMorphName = new JSONStorableFloat[19];
                rMorphName = new JSONStorableFloat[19];
                lSlider = new UIDynamicSlider[19];
                rSlider = new UIDynamicSlider[19];

                CSH = true;
                CreateButtonCSH();
                CreateSlidersCSH();

                CSF = true;
                CreateButtonCSF();
                CreateSlidersCSF();

                CSS =true;
                CreateButtonCSS();
                CreateSlidersCSS();

                morphValueToSlider();
                #endregion
            }
            catch (Exception e)
            {
                SuperController.LogError("Exception caught: " + e);
            }       
        }

        private void DefaultHandMorphs()
        {
            ZeroHandMorps();
            Invoke("SetDefaultValue", 0.2f);
        }

        private void SetDefaultValue()
        {
            morphControl.GetMorphByDisplayName("Right Fingers Fist").morphValue = 0.15f;
            morphControl.GetMorphByDisplayName("Left Fingers Fist").morphValue = 0.15f;
            morphControl.GetMorphByDisplayName("Right Thumb Fist").morphValue = 0.15f;
            morphControl.GetMorphByDisplayName("Left Thumb Fist").morphValue = 0.15f;
            morphValueToSlider();
        }

        private void ZeroHandMorps()
        {
            List<string> HandMorphList = new List<string>(HandMorphs);
            foreach (string HandMorphs in HandMorphList)
            {
                morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue = 0f; 
                morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue = 0f; 
            }
            morphValueToSlider();
        }

        private void morphValueToSlider() {       
            for (int i = 0; i < 19; i++) {
                lSlider[i].slider.value = morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue;
                rSlider[i].slider.value = morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue;
            }            
        }

        private void sliderValueToMorph() {
            for (int i = 0; i < 19; i++) {
                morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue = lSlider[i].slider.value;
                morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue = rSlider[i].slider.value;
            }            
        }

        private void CopyLtoR()
        {
            List<string> HandMorphList = new List<string>(HandMorphs);
            foreach (string HandMorphs in HandMorphList)
            {
                morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue = morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue; 
            }
            morphValueToSlider();   
        }

        private void CopyRtoL()
        {
            List<string> HandMorphList = new List<string>(HandMorphs);
            foreach (string HandMorphs in HandMorphList)
            {
                morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue = morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue;
            }
            morphValueToSlider();
        }

        private void SwapLandR()
        {
            List<string> HandMorphList = new List<string>(HandMorphs);
            foreach (string HandMorphs in HandMorphList)
            {
                float l_temp = morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue;
                morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue = morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue;
                morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue = l_temp;
            }
            morphValueToSlider();
        }

        private void CreateSlidersCSH()
        {
            for (int i = 0; i < 5; i ++) {
                if (i == 3) {
                    lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                    rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, 0f, 1f, true);
                } else {
                    lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                    rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, -1f, 1f, true);
                }
                lSlider[i] = CreateSlider(lMorphName[i], false);
                rSlider[i] = CreateSlider(rMorphName[i], true);
            }
        }

        private void CreateSlidersCSF()
        {
            for (int i = 5; i < 10; i ++) {
                if (i == 8) {
                    lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                    rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, 0f, 1f, true);
                } else {
                    lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                    rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, -1f, 1f, true);
                }
                lSlider[i] = CreateSlider(lMorphName[i], false);
                rSlider[i] = CreateSlider(rMorphName[i], true);
            }
        }

        private void CreateSlidersCSS()
        {
            for (int i = 10; i < 19; i ++) {
                lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, -1f, 1f, true);
                lSlider[i] = CreateSlider(lMorphName[i], false);
                rSlider[i] = CreateSlider(rMorphName[i], true);
            }
        }

        private void RemoveButtonES()
        {
            RemoveToggle(toggle_el);
            RemoveToggle(toggle_er);
        }

        private void CreateButtonES()
        {
            if (toggle_es.val == true)
            {
                toggleel = CreateToggle(toggle_el, false);
                toggle_el.toggle.onValueChanged.AddListener(delegate { toggle_el_ChangeColor(); });
                if (toggle_el.val == true)
                {
                    toggle_el_e();
                }
                else
                {
                    toggle_el_d();
                }
                toggleer = CreateToggle(toggle_er, true);
                toggle_er.toggle.onValueChanged.AddListener(delegate { toggle_er_ChangeColor(); });
                if (toggle_er.val == true)
                {
                    toggle_er_e();
                }
                else
                {
                    toggle_er_d();
                }
            }
        }

        private void toggle_el_e()
        {
            toggleel.backgroundColor = Color.white;            
            toggleel.label = "Enable Saveing Preset from Left";
            toggleel.textColor = Color.black;
        }

        private void toggle_el_d()
        {
            toggleel.backgroundColor = Color.red;
            toggleel.label = "Disable Saveing Preset from Left";
            toggleel.textColor = Color.white;
        }

        private void toggle_er_e()
        {
            toggleer.backgroundColor = Color.white;
            toggleer.label = "Enable Saveing Preset from Right";
            toggleer.textColor = Color.black;
        }

        private void toggle_er_d()
        {
            toggleer.backgroundColor = Color.red;
            toggleer.label = "Disable Saveing Preset from Right";
            toggleer.textColor = Color.white;
        }

        private void toggle_el_ChangeColor()
        {
            if (toggle_el.val == true)
            {
                toggle_el_e();
            }
            else
            {
                toggle_el_d();
            }
        }
        private void toggle_er_ChangeColor()
        {
            if (toggle_er.val == true)
            {
                toggle_er_e();
            }
            else
            {
                toggle_er_d();
            }
        }

        private void OpenES()
        {
            RemoveButtonES();
            CreateButtonES();
            RemoveButtonCSH();
            RemoveButtonCSF();
            RemoveButtonCSS();
            RemoveSlidersCSH();
            RemoveSlidersCSF();
            RemoveSlidersCSS();

            CreateButtonCSH();
            CreateButtonCSF();
            CreateButtonCSS();

            CSH = !CSH;
            OpenCSH();
            CSF = !CSF;
            OpenCSF();
            CSS = !CSS;
            OpenCSS();
        }

        private void OpenCSH()
        {
            if (CSH == true)
            {
                CSH = false;
                cshbutton.label = "Open Hand Morph Sliders";
                cshbutton.buttonColor = Color.green;
                RemoveSlidersCSH();
            }
            else
            {
                RemoveSlidersCSH();
                RemoveSlidersCSF();
                RemoveSlidersCSS();
                CSH = true;
                CreateButtonCSH();
                CreateSlidersCSH();
                CreateButtonCSF();
                if (CSF == true)
                {
                    CreateSlidersCSF();
                }
                CreateButtonCSS();
                if (CSS == true)
                {
                    CreateSlidersCSS();
                }
            }
            //SuperController.LogMessage("CSH" + CSH.ToString());
        }

        private void OpenCSF()
        {
            if (CSF == true)
            {
                CSF = false;
                csfbutton.label = "Open Fingers Morph Sliders";
                csfbutton.buttonColor = Color.green;
                RemoveSlidersCSF();
            }
            else
            {
                RemoveSlidersCSH();
                RemoveSlidersCSF();
                RemoveSlidersCSS();
                CSF = true;
                CreateButtonCSH();
                if (CSH == true)
                {
                    CreateSlidersCSH();
                }
                CreateButtonCSF();
                CreateSlidersCSF();
                CreateButtonCSS();
                if (CSS == true)
                {
                    CreateSlidersCSS();
                }
            }
            //SuperController.LogMessage("CSF" + CSF.ToString());
        }

        private void OpenCSS()
        {
            if (CSS == true)
            {
                CSS = false;
                cssbutton.label = "Open Individual Finger Morph Sliders";
                cssbutton.buttonColor = Color.green;
                RemoveSlidersCSS();
            }
            else
            {
                RemoveSlidersCSH();
                RemoveSlidersCSF();
                RemoveSlidersCSS();
                CSS = true;
                CreateButtonCSH();
                if (CSH == true)
                {
                    CreateSlidersCSH();
                }
                CreateButtonCSF();
                if (CSF == true)
                {
                    CreateSlidersCSF();
                }
                CreateButtonCSS();
                CreateSlidersCSS();
            }
            //SuperController.LogMessage("CSS" + CSS.ToString());
        }

        private void CreateButtonCSH()
        {
            RemoveButton(cshbutton);
            RemoveToggle(toggle_es);
            
            cshbutton = CreateButton("Open Hand Morph Sliders", false);
            cshbutton.buttonColor = Color.green;
            if (CSH == true)
            {
                cshbutton.label = "Close Hand Morph Sliders";
                cshbutton.buttonColor = Color.yellow;
            }
            if (cshbutton != null)
            {
                cshbutton.button.onClick.AddListener(OpenCSH);
            }
            CreateToggle(toggle_es, true);
            toggle_es.toggle.onValueChanged.AddListener(delegate { OpenES(); });
        }

        private void CreateButtonCSF()
        {
            RemoveButton(csfbutton);
            RemoveSpacer(spacer2);

            csfbutton = CreateButton("Open Fingers Morph Sliders", false);
            csfbutton.buttonColor = Color.green;
            if (CSF == true)
            {
                csfbutton.label = "Close Fingers Morph Sliders";
                csfbutton.buttonColor = Color.yellow;
            }
            if (csfbutton != null)
            {
                csfbutton.button.onClick.AddListener(OpenCSF);
            }
            spacer2 = CreateSpacer(true);
            spacer2.height = 50f;            
        }

        private void CreateButtonCSS()
        {
            RemoveButton(cssbutton);
            RemoveSpacer(spacer3);

            cssbutton = CreateButton("Open Individual Finger Morph Sliders", false);
            cssbutton.buttonColor = Color.green;
            if (CSS == true)
            {
                cssbutton.label = "Close Individual Finger Morph Sliders";
                cssbutton.buttonColor = Color.yellow;
            }
            if (cssbutton != null)
            {
                cssbutton.button.onClick.AddListener(OpenCSS);
            }
            spacer3 = CreateSpacer(true);
            spacer3.height = 50f;
        }

        private void RemoveButtonCSH()
        {
            RemoveButton(cshbutton);
            RemoveSpacer(spacer1);
        }
        
        private void RemoveButtonCSF()
        {
            RemoveButton(csfbutton);
            RemoveSpacer(spacer2);
        }

        private void RemoveButtonCSS()
        {
            RemoveButton(cssbutton);
            RemoveSpacer(spacer3);
        }

        private void RemoveSlidersCSH()
        {
            for (int i = 0; i < 5; i++) {
                RemoveSlider(lMorphName[i]);
                RemoveSlider(rMorphName[i]);
            }
        }

        private void RemoveSlidersCSF()
        {
            for (int i = 5; i < 10; i++) {
                RemoveSlider(lMorphName[i]);
                RemoveSlider(rMorphName[i]);
            }
        }

        private void RemoveSlidersCSS()
        {
            for (int i = 10; i < 19; i++) {
                RemoveSlider(lMorphName[i]);
                RemoveSlider(rMorphName[i]);
            }
        }

        #region Preset Load and Save
        private void HandleLoadPreset(string path)
        {
            if (filename.val != "")
            {
                string ext = "";
                if (filename.val.Length > 10 )
                {
                   if (filename.val.Substring(filename.val.Length - 10, 10) == ".handmorph")
                   {
                       ext = ".handmorph";
                   }
                }

                if (filename.val.Length > 5)
                {
                    if (filename.val.Substring(filename.val.Length - 5, 5) == ".json")
                    {
                        ext = ".json";
                    }
                }

                if (ext == "")
                {
                    filename.val =filename.val + ".json";
                }

                if (filename.val.IndexOf(":") == -1)
                {
                    if (filename.val.Substring(0,6) != "Saves/")
                    {
                        //SuperController.LogMessage(filename.val.Substring(0,6));
                        path = "Saves/PluginData/handmorph/" + filename.val;
                    }
                    else
                    {
                        path = filename.val;
                    }   
                }
                else
                {
                    path = filename.val;
                }
            }
            //SuperController.LogMessage(path);

            LoadData = SuperController.singleton.ReadFileIntoString(path);
            LoadData = LoadData.Replace("{\n","");
            LoadData = LoadData.Replace("\" : \"", ",");
            LoadData = LoadData.Replace("\t\"", "");
            LoadData = LoadData.Replace("\",", "");
            LoadData = LoadData.Replace("\"\n}\n", "");

            //SuperController.LogMessage(LoadData);

            string[] LoadDataList = LoadData.Split('\n');
            int i=0;
            foreach (string HandMorphName in LoadDataList)
            {
                string[] NameAndValue = LoadDataList[i].Split(',');
                i = i + 1;
                //SuperController.LogMessage(mv[0]);
                //SuperController.LogMessage(mv[1]);
                int len = NameAndValue[0].Length;

                if (toggle_x.val)
                {
                    if (NameAndValue[0].Substring(0, 5) == "Right")
                    {
                        NameAndValue[0] = "Left " + NameAndValue[0].Substring(6, len - 6);
                        //SuperController.LogMessage("Left " + NameAndValue[0].Substring(6, len - 6));
                    }
                    else
                    {
                        NameAndValue[0] = "Right " + NameAndValue[0].Substring(5, len  - 5);
                        //SuperController.LogMessage("Right " + NameAndValue[0].Substring(5, len - 5));
                    }
                }

                if (toggle_l.val && NameAndValue[0].Substring(0, 1) == "L")
                {
                    morphControl.GetMorphByDisplayName(NameAndValue[0]).morphValue = float.Parse(NameAndValue[1]);
                }
                
                if (toggle_r.val && NameAndValue[0].Substring(0, 1) == "R")
                {
                    morphControl.GetMorphByDisplayName(NameAndValue[0]).morphValue = float.Parse(NameAndValue[1]);
                }
            }
            morphValueToSlider();
        }

        private void HandleSavePreset(string path)
        {
            List<string> HandMorphList = new List<string>(HandMorphs);
            int i = 1;
            SaveData = "{\n";
            foreach (string HandMorphs in HandMorphList)
            {
                if (!toggle_es.val)
                {                    
                    SaveData = SaveData + "\t\"" + "Right " + HandMorphs + "\" : \"" + morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue.ToString() + "\"" + ",\n";
                    SaveData = SaveData + "\t\"" + "Left " + HandMorphs + "\" : \"" + morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue.ToString();
                    if (i != 19)
                    {
                        SaveData = SaveData + "\",\n";
                    }
                    else
                    {
                        SaveData = SaveData + "\"\n";
                    }
                }
                else
                {
                    if (toggle_er.val)
                    {
                        SaveData = SaveData + "\t\"" + "Right " + HandMorphs + "\" : \"" + morphControl.GetMorphByDisplayName("Right "+HandMorphs).morphValue.ToString() + "\"";
                        if (i != 19)
                        {
                            SaveData = SaveData + ",\n";
                        }
                        else
                        {
                            if (!toggle_el.val)
                            {
                                SaveData = SaveData + "\n";
                            }
                            else
                            {
                                SaveData = SaveData + ",\n";
                            }
                        }
                    }
                    if (toggle_el.val)
                    {
                        SaveData = SaveData + "\t\"" + "Left " + HandMorphs + "\" : \"" + morphControl.GetMorphByDisplayName("Left "+HandMorphs).morphValue.ToString() + "\"";
                        if (i != 19)
                        {
                            SaveData = SaveData + ",\n";
                        }
                        else
                        {
                            SaveData = SaveData + "\n";
                        }
                    }
                } 
                i = i + 1;
            }
            SaveData = SaveData + "}\n";
            //  SuperController.LogMessage(s);
            if (path.Substring(path.Length - 5, 5) != ".json")
            {
                path = path + ".json";
            }
            //SuperController.LogMessage(path.Substring(path.Length-10,10));
            SuperController.singleton.SaveStringIntoFile(path, SaveData);
            SuperController.singleton.DoSaveScreenshot(path);
        }
        #endregion

        public void Start()
        {
//            morphValueToSlider();
        }

       public void Update()
        {
            //morphValueToSlider();
        }
        
       public void FixedUpdate()
        {
            sliderValueToMorph();
            //morphValueToSlider();
        }
    }
}