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

namespace ky1001
{
    public class HandMorphManager : MVRScript
    {
        #region PluginInfo    
        public string pluginAuthor = "ky1001";
        public string pluginName = "HandMorphManager";
        public string pluginVersion = "10.5";
        public string pluginDate = "2026-10-18";
        public string pluginLicense = "CC BY-SA";
        public string pluginDescription = "";
        #endregion

        #region Vars
        private Atom CurrentAtom;

        private const string _saveExt = "vap";
        private const string _handmorphSavePath = "Saves\\PluginData\\handmorph";
        private const string _vapPosePath = "Custom\\Atom\\Person\\Pose";
        private const string _jsonPosePath = "Saves\\Person\\pose";
        private const string _vapMorphsPath = "Custom\\Atom\\Person\\Morphs";
        //private string SaveData;
        private string LoadData;
        private string ext;
        private string jsonPath;

        private bool CSH;
        private bool CSF;
        private bool CSS;

        private bool firstTime = true;

        private int _handMorphsCount;

        private UIDynamic spacer1;
        private UIDynamic spacer2;
        private UIDynamic spacer3;

        private JSONStorableBool toggle_x;
        private JSONStorableBool toggle_l;
        private JSONStorableBool toggle_r;
        private JSONStorableString filename;

        private JSONStorableBool toggle_es;
        private JSONStorableBool toggle_el;
        private JSONStorableBool toggle_er;
        private JSONStorableBool toggle_morphsLock;

        private JSONNode jSONNode;
        private JSONArray atomArray;
        private JSONArray asArray;
        private JSONArray morphsAsArray;
        private JSONClass asAtomObject;
        private JSONClass asObject;
        private JSONClass morphs;
        private string id;

        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",
        };
        private List<string> HandMorphList;
        #endregion

        #region Controls
        private UIDynamicButton button;
        private UIDynamicButton Getbutton;
        private UIDynamicButton clbutton;
        private UIDynamicButton crbutton;
        private UIDynamicButton swbutton;
        private UIDynamicButton loadbutton;
        private UIDynamicButton savebutton;
        private UIDynamicButton loadVapButton;
        private UIDynamicButton loadJsonButton;
        private UIDynamicButton cshbutton;
        private UIDynamicButton csfbutton;
        private UIDynamicButton cssbutton;

        private UIDynamicToggle toggleel;
        private UIDynamicToggle toggleer;

        private JSONStorableFloat[] lMorphName;
        private JSONStorableFloat[] rMorphName;
        private JSONStorableFloat[] lMorphNameCTL;
        private JSONStorableFloat[] rMorphNameCTL;
        private UIDynamicSlider[] lSlider;
        private UIDynamicSlider[] rSlider;
        private float[] lSliderValue;
        private float[] rSliderValue;
        private float[] lSliderValuePast;
        private float[] rSliderValuePast;

        private float[] lMorphNamePastCTL;
        private float[] rMorphNamePastCTL;


        private JSONStorable geometry;
        private DAZCharacterSelector character;
        private GenerateDAZMorphsControlUI morphControl;
        #endregion

        public override void Init()
        {
            try
            {
                #region Button
                var loadPresetUI = CreateButton("Load Preset");
                loadPresetUI.button.onClick.AddListener(() =>
                {
                    filename.val = "";
                    FileManagerSecure.CreateDirectory(_handmorphSavePath);
                    var shortcuts = FileManagerSecure.GetShortCutsForDirectory(_handmorphSavePath, true, false, true, true);
                    SuperController.singleton.GetMediaPathDialog(HandleLoadPreset, "vap|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;

                    List<ShortCut> shortcuts = new List<ShortCut>();
                    var filePath = _handmorphSavePath;
                    var newShortCut = FileManagerSecure.GetShortCutsForDirectory(filePath, true);
                    shortcuts.Add(newShortCut[0]);
                    filePath = _vapPosePath;
                    newShortCut = FileManagerSecure.GetShortCutsForDirectory(filePath, true);
                    shortcuts.Add(newShortCut[0]);
                    filePath = _vapMorphsPath;
                    newShortCut = FileManagerSecure.GetShortCutsForDirectory(filePath, true);
                    shortcuts.Add(newShortCut[0]);
                    //filePath = _jsonPosePath;
                    //newShortCut = FileManagerSecure.GetShortCutsForDirectory(filePath, true);
                    //shortcuts.Add(newShortCut[0]);

                    fileBrowserUI.SetTitle("Save Hand Morphs preset");
                    fileBrowserUI.fileRemovePrefix = null;
                    fileBrowserUI.hideExtension = false;
                    fileBrowserUI.keepOpen = false;
                    fileBrowserUI.fileFormat = "vap|json";
                    fileBrowserUI.defaultPath = _handmorphSavePath;
                    fileBrowserUI.showDirs = true;
                    fileBrowserUI.shortCuts = shortcuts;
                    fileBrowserUI.browseVarFilesAsDirectories = true;
                    fileBrowserUI.SetTextEntry(true);
                    fileBrowserUI.Show(HandleSavePreset);
                    fileBrowserUI.fileEntryField.text = "Preset_" + (int)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds + "." + _saveExt;
                    fileBrowserUI.ActivateFileNameField();
                    fileBrowserUI.showInstallFolderInDirectoryList = true;
                });

                _handMorphsCount = HandMorphs.Count();

                var loadVapPose = CreateButton("Load Vap Pose Preset");
                loadVapPose.button.onClick.AddListener(() =>
                {
                    filename.val = "";
                    var vapPoseShortcuts = FileManagerSecure.GetShortCutsForDirectory(_vapPosePath, true, false, true, true);
                    SuperController.singleton.GetMediaPathDialog(HandleLoadPreset, "vap", _vapPosePath, false, true, false, null, false, vapPoseShortcuts);
                });

                var loadJsonPose = CreateButton("Load Json Pose Preset", true);
                loadJsonPose.button.onClick.AddListener(() =>
                {
                    filename.val = "";
                    var jsonPoseShortcuts = FileManagerSecure.GetShortCutsForDirectory(_jsonPosePath, true, false, true, true);
                    SuperController.singleton.GetMediaPathDialog(HandleLoadPreset, "json", _jsonPosePath, false, true, false, null, false, jsonPoseShortcuts);
                });

                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_morphsLock = new JSONStorableBool("Enable Locking Hand Morphs", false);
                CreateToggle(toggle_morphsLock, false);
                RegisterBool(toggle_morphsLock);
                toggle_morphsLock.toggle.onValueChanged.AddListener(delegate { LockMorphs(); });

                toggle_es = new JSONStorableBool("Enable Saveing L-R Separately", false);
                CreateToggle(toggle_es, true);
                RegisterBool(toggle_es);
                toggle_es.toggle.onValueChanged.AddListener(delegate { OpenES(); });

                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\\");
                RegisterString(filename);
                #endregion

                geometry = containingAtom.GetStorableByID("geometry");
                character = geometry as DAZCharacterSelector;
                morphControl = character.morphsControlUI;
                HandMorphList = new List<string>(HandMorphs);

                lMorphName = new JSONStorableFloat[_handMorphsCount];
                rMorphName = new JSONStorableFloat[_handMorphsCount];
                lSlider = new UIDynamicSlider[_handMorphsCount];
                rSlider = new UIDynamicSlider[_handMorphsCount];

                lSliderValue = new float[_handMorphsCount];
                rSliderValue = new float[_handMorphsCount];
                lSliderValuePast = new float[_handMorphsCount];
                rSliderValuePast = new float[_handMorphsCount];

                lMorphNameCTL = new JSONStorableFloat[_handMorphsCount];
                rMorphNameCTL = new JSONStorableFloat[_handMorphsCount];
                lMorphNamePastCTL = new float[_handMorphsCount];
                rMorphNamePastCTL = new float[_handMorphsCount];

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

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

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

                firstTime = false;

                for (int i = 0; i < _handMorphsCount; i++)
                {
                    RegisterFloat(lMorphNameCTL[i]);
                    RegisterFloat(rMorphNameCTL[i]);
                }

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

        private void DefaultHandMorphs()
        {
            morphControl.GetMorphByDisplayName("Right Hand Fist").morphValue = 0f;
            morphControl.GetMorphByDisplayName("Left Hand Fist").morphValue = 0f;
            Invoke("DefaultHandMorphsMain", 0.2f);
        }

        private void DefaultHandMorphsMain()
        {
            foreach (string HandMorphs in HandMorphList)
            {
                if (HandMorphs != "Hand Fist")
                {
                    morphControl.GetMorphByDisplayName("Right " + HandMorphs).SetDefaultValue();
                    morphControl.GetMorphByDisplayName("Left " + HandMorphs).SetDefaultValue();
                }
            }

            for (int i = 0; i < _handMorphsCount; i++)
            {
                lSliderValue[i] = 0f;
                rSliderValue[i] = 0f;
            }

            lSliderValue[5] = 0.15f;
            lSliderValue[15] = 0.15f;
            rSliderValue[5] = 0.15f;
            rSliderValue[15] = 0.15f;

            for (int i = 0; i < _handMorphsCount; i++)
            {
                lSliderValuePast[i] = lSliderValue[i];
                rSliderValuePast[i] = rSliderValue[i];
            }
            morphValueToSlider();
        }

        private void ZeroHandMorps()
        {
            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 < _handMorphsCount; i++)
            {
                lSliderValue[i] = morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue;
                rSliderValue[i] = morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue;

                lSliderValuePast[i] = lSliderValue[i];
                rSliderValuePast[i] = rSliderValue[i];

                lMorphNameCTL[i].val = lSliderValuePast[i];
                rMorphNameCTL[i].val = rSliderValuePast[i];
                lMorphNamePastCTL[i] = lSliderValuePast[i];
                rMorphNamePastCTL[i] = rSliderValuePast[i];

                lSlider[i].slider.value = lSliderValue[i];
                rSlider[i].slider.value = rSliderValue[i];
            }
        }

        private void sliderValueToMorph()
        {
            {
                for (int i = 0; i < _handMorphsCount; i++)
                {
                    if (lMorphNamePastCTL[i] != lMorphNameCTL[i].val)
                    {
                        lSlider[i].slider.value = lMorphNameCTL[i].val;
                        lMorphNamePastCTL[i] = lMorphNameCTL[i].val;
                    }

                    if (rMorphNamePastCTL[i] != rMorphNameCTL[i].val)
                    {
                        rSlider[i].slider.value = rMorphNameCTL[i].val;
                        rMorphNamePastCTL[i] = rMorphNameCTL[i].val;
                    }

                    lSliderValue[i] = lSlider[i].slider.value;
                    rSliderValue[i] = rSlider[i].slider.value;
                }
            }

            for (int i = 0; i < _handMorphsCount; i++)
            {
                if (lSliderValuePast[i] != lSliderValue[i])
                {
                    morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue = lSliderValue[i];
                    lSliderValuePast[i] = lSliderValue[i];
                }
                else
                {
                    lSliderValue[i] = morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue;
                    lSlider[i].slider.value = lSliderValue[i];
                    lSliderValuePast[i] = lSliderValue[i];
                }

                if (rSliderValuePast[i] != rSliderValue[i])
                {
                    morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue = rSliderValue[i];
                    rSliderValuePast[i] = rSliderValue[i];
                }
                else
                {
                    rSliderValue[i] = morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue;
                    rSlider[i].slider.value = rSliderValue[i];
                    rSliderValuePast[i] = rSliderValue[i];
                }
            }
        }

        private void LockMorphs()
        {
            if (toggle_morphsLock.val)
            {
                for (int i = 0; i < _handMorphsCount; i++)
                {
                    lSliderValue[i] = morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue;
                    rSliderValue[i] = morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue;
                }

                if (lSliderValue[0] != 0f)
                {
                    lSliderValue[5] = lSliderValue[0];
                    lSliderValue[15] = lSliderValue[0];
                }

                if (rSliderValue[0] != 0f)
                {
                    rSliderValue[5] = rSliderValue[0];
                    rSliderValue[15] = rSliderValue[0];
                }

                if (lSliderValue[1] != 0f)
                {
                    lSliderValue[6] = lSliderValue[1];
                }

                if (rSliderValue[1] != 0f)
                {
                    rSliderValue[6] = rSliderValue[1];
                }

                if (lSliderValue[2] != 0f)
                {
                    lSliderValue[7] = lSliderValue[2];
                    lSliderValue[17] = lSliderValue[2];
                }

                if (rSliderValue[2] != 0f)
                {
                    rSliderValue[7] = rSliderValue[2];
                    rSliderValue[17] = rSliderValue[2];
                }

                if (lSliderValue[3] != 0f)
                {
                    lSliderValue[8] = lSliderValue[3];
                }

                if (rSliderValue[3] != 0f)
                {
                    rSliderValue[8] = rSliderValue[3];
                }

                for (int i = 0; i < _handMorphsCount; i++)
                {
                    lSlider[i].slider.value = lSliderValue[i];
                    rSlider[i].slider.value = rSliderValue[i];
                    lSliderValuePast[i] = lSliderValue[i];
                    rSliderValuePast[i] = rSliderValue[i];
                }
            }
        }

        private void morphLock()
        {
            for (int i = 0; i < _handMorphsCount; i++)
            {
                lSliderValue[i] = lSlider[i].slider.value;
                rSliderValue[i] = rSlider[i].slider.value;
            }

            if (lSliderValue[0] != 0f)
            {
                lSliderValue[5] = lSliderValue[0];
                lSliderValue[15] = lSliderValue[0];
            }
            else if (lSliderValuePast[0] != 0f)
            {
                lSliderValue[5] = 0f;
                lSliderValue[15] = 0f;
            }

            if (rSliderValue[0] != 0f)
            {
                rSliderValue[5] = rSliderValue[0];
                rSliderValue[15] = rSliderValue[0];
            }
            else if (rSliderValuePast[0] != 0f)
            {
                rSliderValue[5] = 0f;
                rSliderValue[15] = 0f;
            }

            if (lSliderValue[1] != 0f)
            {
                lSliderValue[6] = lSliderValue[1];
            }
            else if (lSliderValuePast[1] != 0f)
            {
                lSliderValue[6] = 0f;
            }

            if (rSliderValue[1] != 0f)
            {
                rSliderValue[6] = rSliderValue[1];
            }
            else if (rSliderValuePast[1] != 0f)
            {
                rSliderValue[6] = 0f;
            }

            if (lSliderValue[2] != 0f)
            {
                lSliderValue[7] = lSliderValue[2];
                lSliderValue[17] = lSliderValue[2];
            }
            else if (lSliderValuePast[2] != 0f)
            {
                lSliderValue[7] = 0f;
                lSliderValue[17] = 0f;
            }

            if (rSliderValue[2] != 0f)
            {
                rSliderValue[7] = rSliderValue[2];
                rSliderValue[17] = rSliderValue[2];
            }
            else if (rSliderValuePast[2] != 0f)
            {
                rSliderValue[7] = 0f;
                rSliderValue[17] = 0f;
            }

            if (lSliderValue[3] != 0f)
            {
                lSliderValue[8] = lSliderValue[3];
            }
            else if (lSliderValuePast[3] != 0f)
            {
                lSliderValue[8] = 0f;
            }

            if (rSliderValue[3] != 0f)
            {
                rSliderValue[8] = rSliderValue[3];
            }
            else if (rSliderValuePast[3] != 0f)
            {
                rSliderValue[8] = 0f;
            }

            for (int i = 0; i < _handMorphsCount; i++)
            {
                lSlider[i].slider.value = lSliderValue[i];
                rSlider[i].slider.value = rSliderValue[i];
                lSliderValuePast[i] = lSliderValue[i];
                rSliderValuePast[i] = rSliderValue[i];
            }
        }

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

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

        private void SwapLandR()
        {
            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 (firstTime)
                {
                    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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                        rMorphNameCTL[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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                        rMorphNameCTL[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 (firstTime)
                {
                    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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                        rMorphNameCTL[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, 0f, 1f, true);
                    }
                    else if (i == 5)
                    {
                        lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        rMorphNameCTL[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0.15f, -1f, 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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                        rMorphNameCTL[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 < _handMorphsCount; i++)
            {
                if (firstTime)
                {
                    if (i == 17)
                    {
                        lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                        rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, 0f, 1f, true);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, 0f, 1f, true);
                        rMorphNameCTL[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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                        rMorphNameCTL[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0, -1f, 1f, true);
                    }

                    if (i == 15)
                    {
                        lMorphName[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        rMorphName[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0.15f, -1f, 1f, true);
                        rMorphNameCTL[i] = new JSONStorableFloat("Right " + HandMorphs[i], 0.15f, -1f, 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);
                        lMorphNameCTL[i] = new JSONStorableFloat("Left " + HandMorphs[i], 0, -1f, 1f, true);
                        rMorphNameCTL[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();
                }
            }
            morphValueToSlider();
        }

        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();
                }
            }
            morphValueToSlider();
        }

        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();
            }
            morphValueToSlider();
        }

        private void CreateButtonCSH()
        {
            RemoveButton(cshbutton);
            //RemoveToggle(toggle_es);
            RemoveSpacer(spacer1);

            cshbutton = CreateButton("Open Hand Morph Sliders", false);
            cshbutton.buttonColor = Color.green;
            spacer1 = CreateSpacer(true);
            spacer1.height = 50f;

            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 < _handMorphsCount; i++)
            {
                RemoveSlider(lMorphName[i]);
                RemoveSlider(rMorphName[i]);
            }
        }

        #region Preset Load and Save
        private void HandleLoadPreset(string path)
        {
            if (filename.val != "")
            {
                filename.val = filename.val.Replace("\\", "/");
                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 (filename.val.Length > 4)
                {
                    if (filename.val.Substring(filename.val.Length - 4, 4) == ".vap")
                    {
                        ext = ".vap";
                    }
                }

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

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

            LoadData = SuperController.singleton.ReadFileIntoString(path);
            if (!LoadData.Contains("morphs"))
            {
                if (ext == ".handmorph" | path.Substring(path.Length - 10, 10) == ".handmorph" | (!LoadData.Contains("{")))
                {
                    LoadData = LoadData.Replace(",", "\":\"").Replace("\n", "\",\n\"");
                    LoadData = "{\n\"" + LoadData + "end\n}";
                    LoadData = LoadData.Replace(",\n\"end", "");
                    //SuperController.LogMessage(LoadData);
                }

                jSONNode = JSON.Parse(LoadData);
                foreach (var Item in HandMorphs)
                {
                    if (toggle_x.val)
                    {
                        if (toggle_l.val && jSONNode["Right " + Item] != null)
                        {
                            morphControl.GetMorphByDisplayName("Left " + Item).morphValue = float.Parse(jSONNode["Right " + Item]);
                        }

                        if (toggle_r.val && jSONNode["Left " + Item] != null)
                        {
                            morphControl.GetMorphByDisplayName("Right " + Item).morphValue = float.Parse(jSONNode["Left " + Item]);
                        }
                    }
                    else
                    {
                        if (toggle_l.val && jSONNode["Left " + Item] != null)
                        {

                            morphControl.GetMorphByDisplayName("Left " + Item).morphValue = float.Parse(jSONNode["Left " + Item]);
                        }

                        if (toggle_r.val && jSONNode["Right " + Item] != null)
                        {
                            morphControl.GetMorphByDisplayName("Right " + Item).morphValue = float.Parse(jSONNode["Right " + Item]);
                        }
                    }
                }
            }
            else
            {
                jSONNode = JSON.Parse(LoadData);
                bool jsonExt = (path.Substring(path.Length - 4, 4) != ".vap");
                if (jsonExt)
                {
                    atomArray = jSONNode["atoms"].AsArray;
                    for (int k = 0; k < atomArray.Count; k++)
                    {
                        asAtomObject = atomArray[k].AsObject;
                        id = asAtomObject["id"];
                        string type = asAtomObject["type"];
                        if (type == "Person")
                        {
                            asArray = asAtomObject["storables"].AsArray;
                        }
                    }
                }
                else
                {
                    asArray = jSONNode["storables"].AsArray;
                }

                bool def = Convert.ToBoolean(jSONNode["setUnlistedParamsToDefault"]);
                foreach (var item in HandMorphs)
                {
                    if (toggle_l.val && (def | jsonExt))
                    {
                        morphControl.GetMorphByDisplayName("Left " + item).SetDefaultValue();
                    }

                    if (toggle_r.val && (def | jsonExt))
                    {
                        morphControl.GetMorphByDisplayName("Right " + item).SetDefaultValue();
                    }
                }
                //asArray = jSONNode["storables"].AsArray;
                for (int i = 0; i < asArray.Count; i++)
                {
                    asObject = asArray[i].AsObject;
                    id = asObject["id"];
                    if (id == "geometry")
                    {
                        morphsAsArray = asObject["morphs"].AsArray;
                        for (int j = 0; j < morphsAsArray.Count; j++)
                        {
                            morphs = morphsAsArray[j].AsObject;
                            string morphsName = morphs["name"];
                            string morphsValue = morphs["value"];
                            if (HandMorphs.Contains(morphsName.Replace("Right ", "")) | HandMorphs.Contains(morphsName.Replace("Left ", "")))
                            {
                                if (toggle_x.val)
                                {
                                    if (morphsName.Contains("Right"))
                                    {
                                        if (toggle_l.val)
                                        {
                                            morphControl.GetMorphByDisplayName(morphsName.Replace("Right", "Left")).morphValue = float.Parse(morphsValue);
                                        }
                                    }
                                    else
                                    {
                                        if (toggle_r.val)
                                        {
                                            morphControl.GetMorphByDisplayName(morphsName.Replace("Left", "Right")).morphValue = float.Parse(morphsValue);
                                        }
                                    }
                                }
                                else
                                {
                                    if (toggle_l.val && morphsName.Contains("Left"))
                                    {
                                        morphControl.GetMorphByDisplayName(morphsName).morphValue = float.Parse(morphsValue);
                                    }
                                    if (toggle_r.val && morphsName.Contains("Right"))
                                    {
                                        morphControl.GetMorphByDisplayName(morphsName).morphValue = float.Parse(morphsValue);
                                    }
                                }
                            }
                        }
                    }
                }

            }
            morphValueToSlider();
        }

        private void HandleSavePreset(string path)
        {
            JSONClass morphFile = new JSONClass();

            if (path.Substring(path.Length - 5, 5) == ".json")
            {
                foreach (string HandMorphs in HandMorphList)
                {
                    if (!toggle_es.val)
                    {
                        morphFile["Left " + HandMorphs] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).morphValue.ToString();
                        morphFile["Right " + HandMorphs] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).morphValue.ToString();
                    }
                    else
                    {
                        if (toggle_er.val)
                        {
                            morphFile["Right " + HandMorphs] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).morphValue.ToString();
                        }
                        if (toggle_el.val)
                        {
                            morphFile["Left " + HandMorphs] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).morphValue.ToString();
                        }
                    }
                }
                SuperController.singleton.DoSaveScreenshot(path);
                SaveJSON(morphFile, path);
            }
            else
            {
                morphFile["setUnlistedParamsToDefault"] = "true";
                morphFile["V2"] = "true";
                morphFile["storables"][0]["id"] = "geometry";

                int i = 0;
                foreach (string HandMorphs in HandMorphList)
                {
                    if (!toggle_es.val)
                    {
                        morphFile["storables"][0]["morphs"][i * 2]["uid"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).uid;
                        morphFile["storables"][0]["morphs"][i * 2]["name"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).displayName;
                        morphFile["storables"][0]["morphs"][i * 2]["value"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).morphValue.ToString();
                        morphFile["storables"][0]["morphs"][i * 2 + 1]["uid"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).uid;
                        morphFile["storables"][0]["morphs"][i * 2 + 1]["name"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).displayName;
                        morphFile["storables"][0]["morphs"][i * 2 + 1]["value"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).morphValue.ToString();
                    }
                    else
                    {
                        if (toggle_er.val)
                        {
                            morphFile["storables"][0]["morphs"][i]["uid"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).uid;
                            morphFile["storables"][0]["morphs"][i]["name"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).displayName;
                            morphFile["storables"][0]["morphs"][i]["value"] = morphControl.GetMorphByDisplayName("Right " + HandMorphs).morphValue.ToString();
                        }
                        if (toggle_el.val)
                        {
                            morphFile["storables"][0]["morphs"][i]["uid"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).uid;
                            morphFile["storables"][0]["morphs"][i]["name"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).displayName;
                            morphFile["storables"][0]["morphs"][i]["value"] = morphControl.GetMorphByDisplayName("Left " + HandMorphs).morphValue.ToString();
                        }
                    }
                    i++;
                }

                if (path.Substring(path.Length - 4, 4) != ".vap")
                {
                    jsonPath = path + ".json";
                    path = path + ".vap";
                }
                else
                {
                    jsonPath = path.Substring(0, (path.Length - 4)) + ".json";
                }
                SuperController.singleton.DoSaveScreenshot(jsonPath);
                SaveJSON(morphFile, path);
            }
        }
        #endregion

        public void Update()
        {
            if (!toggle_morphsLock.val)
            {
                sliderValueToMorph();
            }
            else
            {
                morphLock();
                for (int i = 0; i < _handMorphsCount; i++)
                {
                    morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue = lSliderValue[i];
                    morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue = rSliderValue[i];
                }
            }
        }

        public void FixedUpdate()
        {
            if (!toggle_morphsLock.val)
            {
                sliderValueToMorph();
            }
            else
            {
                morphLock();
                for (int i = 0; i < _handMorphsCount; i++)
                {
                    morphControl.GetMorphByDisplayName("Left " + HandMorphs[i]).morphValue = lSliderValue[i];
                    morphControl.GetMorphByDisplayName("Right " + HandMorphs[i]).morphValue = rSliderValue[i];
                }
            }
        }
    }
}