using MeshVR;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using SimpleJSON;
using AssetBundles;


namespace RunRudolf
{  
    public class NippleClippingEliminator : MVRScript
    {
        private string date = "Version 2026-02-24";
        private bool debug1 = false; //LogError with debug steps
        private JSONStorableBool debug2; //LogMessage with info on which section is active, available in UI
        private bool debug3 = false; //LogMessage with step measurement
        private bool debug4 = false; //LogError with debug steps
        private float t0;
        private float t1;
        private int timer4 = 0;

        //Modes
        private JSONStorableBool nippleMode; 
        private JSONStorableBool pubicMode; 
        private JSONStorableBool hairSimProp;

        private bool isSceneLoaded = false;
        private bool isActive = false;
        private string clothingNippleCovering;
        private string clothingPubicCovering;
        private string nameLower = "";
        private bool hasTopTag = false;
        private bool hasExposeOpen = false;

        //Special cases
        private float morphSum = 0f;
        private float morphSumOld = 0f;
        private bool nippleMorphSumChanged = false;
        private bool nippleSliderValueChanged = false;

        private float lengthSum = 0f;
        private float lengthSumOld = 0f;
        private bool hairLengthSumChanged = false;
        private bool hairSliderValueChanged = false;

        class PersonData
        {
            public Atom atom;
            public DAZCharacterSelector geometry;
            public DAZMorph[] nippleMorphs;
            public float[] restoreNippleValues;
            public bool nippleCovered;
            public bool nippleCoveredOld;
            public bool isFemale;
            public Dictionary<string, Vector3> pubicHairRestoreWidth = new Dictionary<string, Vector3>();
            public bool pubicCovered;
            public bool pubicCoveredOld;
            public List<ClothingCacheEntry> clothingCache = new List<ClothingCacheEntry>(32);
            public bool clothingCacheDirty = true;
            public int lastClothingChildCount = -1;
            public int cachedTagsHash;
            public const int AdditionalNippleSlots = 3;
            public string[] additionalNippleMorphUids = new string[AdditionalNippleSlots];
            public int nextAdditionalNippleSlot = 0;
            public int lastClothingInstanceCount;
        }

        List<PersonData> persons = new List<PersonData>();

        class ClothingCacheEntry
        {
            public int cachedTagsHash;
            public DAZClothingItem item;
            public bool isPotentialTop;
            public bool isPotentialBottom;
            public bool isExpose;
            public bool wasActive;
            public JSONStorable simStorable;
            public bool simEnabled;
            public bool allowDetach;
        }

        //Button hook and mouse over detection before preset saving
        private Atom lastSelectedAtom;
        private Button hookedStorePresetButton;
        private bool presetHoverArmed = false;
        private bool presetSaveInProgress = false;
        private Coroutine hoverCleanupRoutine;
        private StorePresetHoverHook hookedHoverHook;

        //UI
        private UIDynamicTextField _textField1; //Dynamic addon morph status field
        private string stateVal = "";
        private UIDynamicTextField _textField2; //Help text field

        private UIDynamicTextField _textField3; //Dynamic active clothing info field
        private string stateVal3 = "";

        private UIDynamicPopup myNippleMorphsPopup1;
        private JSONStorableStringChooser myNippleMorphsList1;
        private List<string> myNippleMorphs1;
        private Dictionary<string, string> myUidLookup1 = new Dictionary<string, string>();
        private string selectedAdditionalNippleMorphUid = ""; 
        private JSONStorableString selectedAdditionalNippleMorphJSON;

        private UIDynamicSlider nippleFlattenedSlider;
        private JSONStorableFloat nippleFlattenedMorphValueJSON;

        private UIDynamicSlider hairInvisibleSlider;
        private JSONStorableFloat hairInvisibleLengthValueJSON;

        private bool refreshNippleMorphsList = false;
        
		private List<string> boolParamNamesList; // B69 Addition - List declaration which will be used to check available bool parameters for each clothing item
								
        public override void Init()
        {
            try
            {
                base.Init();
				
				boolParamNamesList = new List<string>(); // B69 Addition - initialising the list of bool parameters as new empty list
                
                debug2 = new JSONStorableBool("Enable Debug", false); //Debug mode
                debug2.storeType = JSONStorableParam.StoreType.Full;
                RegisterBool(debug2);

				// B69 Start Change Section
				// see orig row below now commented out. 2 different bools were attempting to be registered with the same name "Enable"
                //nippleMode = new JSONStorableBool("Enable", true, tickModeCallback1);
				nippleMode = new JSONStorableBool("Enable Nipple", true, tickModeCallback1);
				// B69 End Change Section
				
                nippleMode.storeType = JSONStorableParam.StoreType.Full;
                RegisterBool(nippleMode);
				
				// B69 Start Change Section
				// i've given each JSON Storable bool a unique name for registering so they should both now be triggerable
				// note these changes don't affect the UI or other functionality in the plugin but do affect any external triggers using these
				// although that being said, pubicMode trigger was failing to register so wasn't available previously for trigger calls 
				//pubicMode = new JSONStorableBool("Enable", true, tickModeCallback2);
                pubicMode = new JSONStorableBool("Enable Pubic", true, tickModeCallback2);
                // B69 End Change Section
				
				pubicMode.storeType = JSONStorableParam.StoreType.Full;
                RegisterBool(pubicMode);

                hairSimProp = new JSONStorableBool("Auto On/Off Pubic Hair Sim", false); //Auto hair sim deactivation
                hairSimProp.storeType = JSONStorableParam.StoreType.Full;
                RegisterBool(hairSimProp);

                //Start an async coroutine to load stuff which requires the scene to be fully loaded, and prevent Update from starting before everything is initialised
                StartCoroutine(WaitForLoadingComplete());

                //Start create UI
                createStaticDescriptionTextMain("Nipple Clipping Eliminiator", "<size=30><b>Nipple Clipping Eliminiator</b></size>", false, 34);
                createStaticDescriptionTextMain("Version", "<size=20>" + "                                                   " + date + "</size>", true, 34);
                UIDynamic spacer = CreateSpacer(false); spacer.height = 100;
                UIDynamic spacer2 = CreateSpacer(true); spacer2.height = 48;

                createStaticDescriptionTextMain("Hide Nipples","<size=30>Hide Nipples</size>",false,34);
                CreateToggle(nippleMode, false);

                nippleFlattenedMorphValueJSON = new JSONStorableFloat("Flattened Nipple %", 0.0001f, 0.0001f, 1.0f, false); //Nipple flattened morph value slider
                nippleFlattenedMorphValueJSON.storeType = JSONStorableParam.StoreType.Full;
                RegisterFloat(nippleFlattenedMorphValueJSON);
                nippleFlattenedMorphValueJSON.setCallbackFunction += (float v) => { floatModeCallback1(); };
                nippleFlattenedSlider = CreateSlider(nippleFlattenedMorphValueJSON, false);
                
                createStaticDescriptionTextMain("Additional Nipple Morphs","<size=30>Additional Nipple Morphs</size>",false,34); //Create nipple morphs chooser popup 1
                myNippleMorphs1 = new List<string>();
                myNippleMorphs1.Add("");
                myUidLookup1 = new Dictionary<string, string>();
                myUidLookup1.Add("", "");
                myNippleMorphsList1 = new JSONStorableStringChooser("myNippleMorphsPopup1", new List<string> { "" }, "", "Select", switchModeCallback1);
                myNippleMorphsPopup1 = CreateFilterablePopup(myNippleMorphsList1, false);
                RegisterStringChooser(myNippleMorphsList1);
                myNippleMorphsList1.valNoCallback = "";
                myNippleMorphsPopup1.popup.onOpenPopupHandlers += () =>
                {                   
                    myNippleMorphsList1.choices = GetAvailableNippleMorphNames();

                    if (!myNippleMorphs1.Contains(myNippleMorphsList1.val))
                        myNippleMorphsList1.val = "";
                };
                selectedAdditionalNippleMorphJSON = new JSONStorableString("selectedAdditionalNippleMorphJSON","", OnAdditionalNippleMorphLoaded);
                selectedAdditionalNippleMorphJSON.storeType = JSONStorableParam.StoreType.Full;
                RegisterString(selectedAdditionalNippleMorphJSON);

                _textField1 = CreateStaticDescriptionText(this, "", "<size=30></size>", false, 34); //Help text field with addon morphs
                SetupTextField(_textField1, 96f, false, false);

                //createStaticDescriptionTextMain("","<size=30></size>",false,35);
               
                createStaticDescriptionTextMain("Hide Pubic","<size=30>Hide Pubic</size>",false,34);
                CreateToggle(pubicMode, false);
                hairInvisibleLengthValueJSON = new JSONStorableFloat("Hidden Hair Length %", 0.0001f, 0.0001f, 1.0f, false); //Invisible pubic hair length value slider
                hairInvisibleLengthValueJSON.storeType = JSONStorableParam.StoreType.Full;
                RegisterFloat(hairInvisibleLengthValueJSON);
                hairInvisibleLengthValueJSON.setCallbackFunction += (float v) => { floatModeCallback2(); };
                hairInvisibleSlider = CreateSlider(hairInvisibleLengthValueJSON, false);
                CreateToggle(hairSimProp, false);

                //createStaticDescriptionTextMain("","<size=30></size>",false,35);

                createStaticDescriptionTextMain("Status & Debug","<size=30>Status & Debug</size>",false,34);
                //Dynamic active hiding clothing info field
                _textField3 = CreateStaticDescriptionText(this, "", "<size=30></size>", false, 34);
                SetupTextField(_textField3, 106f, false, false);
                CreateToggle(debug2, false);

                createStaticDescriptionTextMain("How to Use","<size=30>How to Use</size>",true,34);
                JSONStorableString helpText = new JSONStorableString("Help",
                    "<b>Purpose:</b> Eliminates nipple clipping & hides pubic hair under clothing. Clothing names & tags are analyzed, sim detached state is considered. Person/scene/session plugin.\n\n" +

                    "<b>Tags:</b> The clothing names and clothing tags are checked for certain terms, both in- & excluding certain clothing items from hiding nipples and pubic hair. If case of false negatives or positives, use overriding.\n\n" +
                    "<b>Overriding:</b> Add tags to the clothing's 'User Prefs' to override hiding/unhiding: 'hidenipples' or 'hidepubes' to hide it, 'exposed' to unhide it. Tags are saved with the clothing item.\n\n" +
                    "<b>Values Affected:</b> Nipple morphs: Nipple Diameter (f), Nipples Diameter (m/f), Nipple Length (f), Nipples Large (m/f), Nipple Size (f), Nipples Size (m/f), Nipples (m/f), Nipples Apply (f), Nipples Depth (m/f). Add up to three additional nipple morphs. The plugin controls pubic hair width.\n\n" +
                    "<b>Note:</b> Do <color=red>not</color> change nipple morph values / pubic hair length while hidden (use 'Flattened Nipple %' slider)."
                );
                UIDynamic spacer3 = CreateSpacer(true); spacer.height = 48;
                GridLayoutGroup glg = spacer3.gameObject.AddComponent<GridLayoutGroup>();
                glg.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
                glg.constraintCount = 1;
                glg.cellSize = new Vector2(520, 1030);
                _textField2 = UIWidgets.CreateVAMTextField(this, spacer3.transform);
                _textField2.transform.localPosition = Vector3.zero;
                _textField2.text = helpText.val;
                //End create UI

                //Add listeners
                SuperController.singleton.onBeforeSceneSaveHandlers += BeforeSceneSave;
                SuperController.singleton.onSceneSavedHandlers += AfterSceneSave;
                SuperController.singleton.onSceneLoadedHandlers += OnSceneLoaded;

                //First time build clothing cache
                foreach (var p in persons)
                {
                    p.clothingCacheDirty = true;
                }

                if (debug2.val) { SuperController.LogMessage("Init() completed"); }
            }
            catch (Exception e)
            {
                SuperController.LogError($"{nameof(NippleClippingEliminator)}.{nameof(Init)}: {e}");
            }
        }

        private IEnumerator WaitForLoadingComplete()
        {
            while (SuperController.singleton.isLoading)
            {
                isSceneLoaded = false;
                yield return null;
            }

            while (SuperController.singleton.freezeAnimation)
            {
                isSceneLoaded = false;
                yield return null;
            }

            yield return null;
            isSceneLoaded = true;
            isActive = true;

            //Initially fill the nipple morphs list
            refreshNippleMorphsList = true;

            //First initialisation of person atoms in the scene (empties existing list). Don't do too early, as additional nipple morphs will not be ready.
            InitPersons(clearList: true);

            //getAllStorables(); //For debug only

            //getUIHierarchy(); //For debug only

            if (debug2.val) { SuperController.LogMessage("WaitForLoadingComplete() completed"); }
        }
    
        //System to hook the "Create New Preset" / "Overwrite Preset" (hover & click) button in VaM UI based on currently selected person atom
        private void AddStorePresetHook()
        {
            Atom selectedAtom  = SuperController.singleton.GetSelectedAtom();

            if (selectedAtom == null || selectedAtom.type != "Person")
                return;

            if (selectedAtom == lastSelectedAtom)
                return;
            
            lastSelectedAtom = selectedAtom;

            Button[] allButtons = selectedAtom.gameObject.GetComponentsInChildren<Button>(true);
            int storePresetButtonIndex = 0;

            for (int i = 0; i < allButtons.Length; i++)
            {
                Button b = allButtons[i];

                if (b.name == "StorePresetButton")
                {
                    if (storePresetButtonIndex == 1) //Index 1 is Appearance Presets section
                    {
                        //Button click hook
                        b.onClick.RemoveListener(OnPresetButtonClicked);
                        b.onClick.AddListener(OnPresetButtonClicked);

                        hookedStorePresetButton = b;

                        //Mouse over hook
                        var hover = b.gameObject.GetComponent<StorePresetHoverHook>();
                        if (hover == null)
                            hover = b.gameObject.AddComponent<StorePresetHoverHook>();

                        hover.plugin = this;
                        hookedHoverHook = hover;

                        if (debug2.val) {SuperController.LogMessage($"Hooked StorePresetButton for '{selectedAtom.name}'"); }

                        return;
                    }

                    storePresetButtonIndex++;
                }
            }
        }

        public void OnStorePresetHover()
        {
            if (presetSaveInProgress)
                return;

            presetHoverArmed = true;

            if (debug2.val)
                SuperController.LogMessage("StorePreset hover detected, restoring nipple morphs for appearance preset saving");

            BeforeSceneSave();
        }

        public void OnStorePresetHoverExit()
        {
            presetHoverArmed = false;

            if (hoverCleanupRoutine != null)
                StopCoroutine(hoverCleanupRoutine);

            hoverCleanupRoutine = StartCoroutine(HoverExitCleanup());

            if (debug2.val)
                SuperController.LogMessage("StorePreset hover exit, enabling nipple morphs");
        }

        private IEnumerator HoverExitCleanup()
        {
            yield return new WaitForSeconds(0.1f);

            presetHoverArmed = false;
            presetSaveInProgress = false;

            if (!presetSaveInProgress)
                AfterSceneSave();
        }

        private void OnPresetButtonClicked()
        {          
            presetHoverArmed = false;
            presetSaveInProgress = false;

            if (debug2.val)
                SuperController.LogMessage("Save click, holding morphs");

            StartCoroutine(HoverExitCleanup());
        }

        //Add additional nipple morphs during preset load based on callback from selectedAdditionalNippleMorphJSON
        private void OnAdditionalNippleMorphLoaded(string uid)
        {           
            selectedAdditionalNippleMorphUid = uid;

            if (debug2.val)
                SuperController.LogMessage(
                    $"Preset load: restoring additional nipple morph '{uid}'");

            if (!isSceneLoaded || string.IsNullOrEmpty(uid))
                return;

            foreach (PersonData p in persons)
            {
                AddSelectedNippleMorph(p);
            }
        }

        //Refesh the list of available "nipple" morphs for the popup chooser based on all potentially selectable "nipple" morph in all person atoms in the scene
        private List<string> GetAvailableNippleMorphNames()
        {
            List<string> morphNames = new List<string> { "" };
            myUidLookup1.Clear();
            myUidLookup1[""] = "";

            if (persons == null || persons.Count == 0)
                return morphNames;

            Dictionary<string, List<DAZMorph>> foundMorphs = new Dictionary<string, List<DAZMorph>>();

            //Gather all available "nipple" morphs from all persons in the scene (male, female)
            foreach (var p in persons)
            {
                if (p?.atom == null) continue;

                var geometry = p.atom.GetStorableByID("geometry") as DAZCharacterSelector;
                if (geometry == null) continue;

                var ui = geometry.morphsControlUI;
                if (ui == null) continue;
            
                foreach (string uid in ui.GetMorphUids())
                {
                    //SuperController.LogMessage("Debug: Checking morph uid='" + uid + "' on atom='" + p.atom.name + "'");
                    
                    var morph = ui.GetMorphByUid(uid);
                    if (morph == null) continue;

                    if (morph.displayName.IndexOf("nipple", StringComparison.OrdinalIgnoreCase) < 0)
                        continue;

                    List<DAZMorph> list;
                    if (!foundMorphs.TryGetValue(morph.displayName, out list))
                    {
                        list = new List<DAZMorph>();
                        foundMorphs[morph.displayName] = list;
                    }

                    if (!list.Any(m => m.uid == morph.uid))
                    {
                        list.Add(morph);
                    }
                }
            }
               
            //Order the list of found nipple morphs and expand those where the displayName is used by multiple morphs (different authors)
            foreach (var kvp in foundMorphs.OrderBy(k => k.Key))
            {
                string displayName = kvp.Key;
                var morphs = kvp.Value;

                //Case only one nipple morph with this displayName -> add displayNameto morphNames list
                if (morphs.Count == 1)
                {
                    if (!myUidLookup1.ContainsKey(displayName))
                    {
                        morphNames.Add(displayName);
                        myUidLookup1[displayName] = morphs[0].uid;
                    }
                }

                //Case multiple nipple morphs with this displayName (different authors) -> add uniqueName to morphNames
                else
                {
                    foreach (var morph in morphs.OrderBy(m => m.uid))
                    {
                        int idx = morph.uid.IndexOf('.');
                        string author = idx > 0 ? morph.uid.Substring(0, idx) : morph.uid;
                        string uniqueName = $"{displayName} ({author})";

                        if (!myUidLookup1.ContainsKey(uniqueName))
                        {
                            morphNames.Add(uniqueName);
                            myUidLookup1[uniqueName] = morph.uid;
                        }
                    }
                }
            }

            return morphNames;
        }

        //(Re-)Build clothing cache
        void RebuildClothingCache(PersonData p)
        {
            p.clothingCache.Clear();

            var items = p.atom.GetComponentsInChildren<DAZClothingItem>(true);

            foreach (var c in items)
            {
                var e = new ClothingCacheEntry();
                e.item = c;
                e.wasActive = c.isActiveAndEnabled;
                e.cachedTagsHash = ComputeTagsHash(c.tagsArray);

                //Sim detached property
                var sim = c.GetComponentInChildren<JSONStorable>(true);
                e.simStorable = sim;

				// B69 Start Change Section
				// detailed explanation of changes can be found in Update code block
				// setting the 2 bools to false initially as this is the fallback anyway if they can't be found
				e.simEnabled  = false;
                e.allowDetach = false;
                if (sim != null)
                {
					// storables can exist but not neccesarily the named ones e.g. default item "Heat Up Skirt Sim" returns storable "hideMaterial" only
					// so get list of all storables and check for the desired ones before attempting value assignment
					boolParamNamesList = sim.GetBoolParamNames();
					if (boolParamNamesList.Contains("simEnabled")) e.simEnabled = sim.GetBoolParamValue("simEnabled");
					if (boolParamNamesList.Contains("allowDetach")) e.allowDetach = sim.GetBoolParamValue("allowDetach");
                }
				// B69 End Change Section

                string name = c.displayName?.ToLowerInvariant() ?? "";

                //Nipple covering flags
                bool hasNoNippleHideTags = //Additional condition: If contains any of these, its not covering nipples
                (
                    name.Contains("lash") ||
                    name.Contains("eye") ||
                    c.tagsArray?.Contains("accessory") == true ||
                    c.tagsArray?.Contains("glasses") == true ||
                    c.tagsArray?.Contains("gloves") == true ||
                    c.tagsArray?.Contains("hat") == true ||
                    c.tagsArray?.Contains("jewelry") == true ||
                    c.tagsArray?.Contains("mask") == true ||
                    c.tagsArray?.Contains("panties") == true ||
                    c.tagsArray?.Contains("pants") == true ||
                    c.tagsArray?.Contains("bottom") == true ||
                    c.tagsArray?.Contains("shoes") == true ||
                    c.tagsArray?.Contains("shorts") == true ||
                    c.tagsArray?.Contains("socks") == true ||
                    c.tagsArray?.Contains("stockings") == true ||
                    c.tagsArray?.Contains("arms") == true ||
                    c.tagsArray?.Contains("feet") == true ||
                    c.tagsArray?.Contains("hands") == true ||
                    c.tagsArray?.Contains("head") == true ||
                    c.tagsArray?.Contains("legs") == true ||
                    c.tagsArray?.Contains("neck") == true
                );

                e.isPotentialTop =
                    !hasNoNippleHideTags &&
                    (
                        name.Contains("top") ||
                        name.Contains("shirt") ||
                        name.Contains("bra") ||
                        name.Contains("sweater") ||
                        name.Contains("blouse") ||
                        name.Contains("dress") ||
                        name.Contains("jacket") ||
                        name.Contains("hoodie") ||
                        c.tagsArray?.Contains("top") == true ||
                        c.tagsArray?.Contains("shirt") == true ||
                        c.tagsArray?.Contains("bra") == true ||
                        c.tagsArray?.Contains("hoodie") == true ||
                        c.tagsArray?.Contains("jacket") == true ||
                        c.tagsArray?.Contains("sweater") == true ||
                        c.tagsArray?.Contains("dress") == true ||
                    c.tagsArray?.Contains("hidenipples") == true
                    );
                
                //Pubic covering flags
                bool hasNoPubicHideTags = //Additional condition: If contains any of these, its not covering pubic area
                (
                    name.Contains("lash") ||
                    name.Contains("eye") ||
                    c.tagsArray?.Contains("accessory") == true ||
                    c.tagsArray?.Contains("glasses") == true ||
                    c.tagsArray?.Contains("gloves") == true ||
                    c.tagsArray?.Contains("hat") == true ||
                    c.tagsArray?.Contains("jewelry") == true ||
                    c.tagsArray?.Contains("mask") == true ||
                    c.tagsArray?.Contains("shoes") == true ||
                    c.tagsArray?.Contains("socks") == true ||
                    c.tagsArray?.Contains("arms") == true ||
                    c.tagsArray?.Contains("feet") == true ||
                    c.tagsArray?.Contains("hands") == true ||
                    c.tagsArray?.Contains("head") == true ||
                    c.tagsArray?.Contains("neck") == true
                );

                e.isPotentialBottom =
                    !hasNoPubicHideTags &&
                    (
                        name.Contains("pant") ||
                        name.Contains("pants") ||
                        name.Contains("shorts") ||
                        name.Contains("bodysuit") ||
                        name.Contains("trunk") ||
                        c.tagsArray?.Contains("panties") == true ||
                        c.tagsArray?.Contains("pants") == true ||
                        c.tagsArray?.Contains("shorts") == true ||
                        c.tagsArray?.Contains("bodysuit") == true ||
                        c.tagsArray?.Contains("hidepubes") == true
                    );

                //Expose flags
                bool hasHideTags =  //Additional condition: Must not contain hiding override tags
                (
                    c.tagsArray?.Contains("hidenipples") == true ||
                    c.tagsArray?.Contains("hidepubes") == true
                );

                e.isExpose =
                    !hasHideTags &&
                    (
                        name.Contains("expose") ||
                        name.Contains("exposed") ||
                        name.Contains("open") ||
                        name.Contains("up") ||
                        name.Contains("down") ||
                        name.Contains("harness") ||
                        name.Contains("lewd") ||
                        name.Contains("raised") ||
                        c.tagsArray?.Contains("expose") == true ||
                        c.tagsArray?.Contains("exposed") == true
                        //c.tagsArray?.Contains("accessory") == true
                    );

                p.clothingCache.Add(e);
            }

            p.clothingCacheDirty = false;
        }

        void AttachSimStorable(PersonData p)
        {
            var storableIDs = p.atom.GetStorableIDs();
            if (storableIDs == null) return;

            var lookup = new Dictionary<string, ClothingCacheEntry>();

            foreach (var e in p.clothingCache)
            {
                string key = NormalizeKey(e.item.displayName);
                lookup[key] = e;
            }

            foreach (var id in storableIDs)
            {
                if (!id.EndsWith("Sim")) continue;

                string cleanId = id.Substring(id.LastIndexOf(':') + 1);
                string baseKey = NormalizeKey(cleanId.Substring(0, cleanId.Length - 3));

                ClothingCacheEntry entry;
                if (!lookup.TryGetValue(baseKey, out entry))
                    continue;

                entry.simStorable = p.atom.GetStorableByID(id);

                //if (debug2.val) SuperController.LogMessage($"AttachSimStorable(): Adding sim detached property to clothing cache for '{baseKey}'"); 
            }
        }

        string NormalizeKey(string s)
        {
            return s?.Replace(" ", "").ToLowerInvariant() ?? "";
        }

        //Calculate hash of cached clothing items' tags array properties to detect changes of tags
        static int ComputeTagsHash(string[] tags)
        {
            if (tags == null || tags.Length == 0) return 0;

            unchecked
            {
                int hash = 17;
                for (int i = 0; i < tags.Length; i++)
                    hash = hash * 31 + (tags[i]?.GetHashCode() ?? 0);
                return hash;
            }
        }

        //Enable/Disable nipple functionality
        private void tickModeCallback1(bool select)
        {
            if (!select)
            {
                Cleanup(true, false);
            }
        }

        //Enable/Disable pubic hair functionality
        private void tickModeCallback2(bool select)
        {
            if (!select)
            {
                Cleanup(false, true);
            }
        }

        //Refresh hidden nipple morphs if slider is changed by user
        private void floatModeCallback1()
        {
            foreach (PersonData p in persons)
            {
                if (p.nippleCovered) 
                {
                    nippleSliderValueChanged = true;
                    SetHiddenNippleValues(p);
                }
            }
        }

        //Refresh hidden pubic hair length value if slider is changed by user
        private void floatModeCallback2()
        {
            foreach (PersonData p in persons)
            {
                if (p.nippleCovered) 
                {
                    hairSliderValueChanged = true;
                    SetHiddenPubicValues(p);
                }
            }
        }

        //Additional nipple morphs selector callback
        private void switchModeCallback1(string selectedMorph) 
        {
            if(!isSceneLoaded) return;

            selectedAdditionalNippleMorphUid = "";

            if (!string.IsNullOrEmpty(selectedMorph))
            {
                string uid;
                if (myUidLookup1.TryGetValue(selectedMorph, out uid))
                {
                    selectedAdditionalNippleMorphUid = uid;
                }
            }
            
            foreach (PersonData p in persons)
            {
                AddSelectedNippleMorph(p);
            }

            //Add selected additional nipple morph to JSONStorableString, which is needed to restore morph values during loading presets 
            var firstPerson = persons.FirstOrDefault();
            if (firstPerson == null) return;

            string jsonValue = string.Join(
                ",",
                firstPerson.additionalNippleMorphUids
                    .Select(uid => uid ?? "")
                    .ToArray()
            );

            selectedAdditionalNippleMorphJSON.val = jsonValue;

            if (debug2.val)
                SuperController.LogMessage(
                    "Saved additional nipple morphs JSON: " + jsonValue
                );
		}

        private void BeforeSceneSave()
        {
            if (debug2.val) { SuperController.LogMessage("BeforeSceneSave: Restore nipple morph and pubic hair values before saving"); }
            
            //Stop Update before saving to json (prevent saving zero nipple morphs and lose original values)
            isActive = false;

            //Restore original values
            foreach (var p in persons)
            {
                //Restore nipple morph values
                if (p.nippleMorphs == null) 
                    continue;
                
                LoadRestoreNippleValues(p);
                p.nippleCovered = false;

                //Restore pubic hair length values
                LoadRestorePubicValues(p);
                p.pubicCovered = false;
            }
        }

        private void AfterSceneSave()
        {
            if (debug2.val) { SuperController.LogMessage("AfterSceneSave: Set nipple morphs and pubic hair values again"); }

            //Reactivate Update after saving is completed, hidden nipple states will be reapplied
            isActive = true;

            //Force reload of pubic hair status
            if (pubicMode.val)
            {
                foreach (var p in persons)
                {
                    hairLengthSumChanged = true;

                }
            }
            
            //Force reload of nipple status
            if (nippleMode.val)
            {
                foreach (var p in persons)
                {
                    nippleMorphSumChanged = true;
                }
            }
        }

        void OnSceneLoaded()
        {
            if (debug2.val) { SuperController.LogMessage("OnSceneLoaded: Initialise person list"); }

            //Check for new person atoms and update the list
            InitPersons(clearList: false);

            //Fill the nipple morphs list for the popup chooser
            refreshNippleMorphsList = true;

            //Build clothing cache
            foreach (var p in persons)
            {
                p.clothingCacheDirty = true;
            }
        }

        public void OnDestroy()
        {
            isActive = false;

            //Restore original morph values and remove everything
            Cleanup(true, true);
        }

        public void Cleanup(bool nipples, bool pubic)
        {
            if (debug2.val) { SuperController.LogMessage("Cleanup"); }

            //Restore original nipple morph values
            if (nipples)
            {
                foreach (var p in persons)
                {
                    if (p.nippleMorphs == null) 
                        continue;

                    LoadRestoreNippleValues(p);
                }
            }

            //Restore pubic hair values
            if (pubic)
            {
                foreach (var p in persons)
                {
                    LoadRestorePubicValues(p);
                    p.pubicHairRestoreWidth.Clear();
                }
            }

            //Clear persons list
            persons.Clear();

            //Unregister listeners
            SuperController.singleton.onBeforeSceneSaveHandlers -= BeforeSceneSave;
            SuperController.singleton.onSceneSavedHandlers -= AfterSceneSave;
            SuperController.singleton.onSceneLoadedHandlers -= OnSceneLoaded;

            //Remove preset store hook
            StopAllCoroutines();
            hoverCleanupRoutine = null;
            presetHoverArmed = false;
            presetSaveInProgress = false;

            if (hookedStorePresetButton != null && hookedStorePresetButton.gameObject != null)
            {
                hookedStorePresetButton.onClick.RemoveListener(OnPresetButtonClicked);
                hookedStorePresetButton = null;
            }

            if (hookedHoverHook != null)
            {
                Destroy(hookedHoverHook);
                hookedHoverHook = null;
            }

            lastSelectedAtom = null;
        }

        //Save restore nipple morph values (if not set to flattened already)
        private void SaveRestoreNippleValues(PersonData p)
        {   
            for (int i = 0; i < p.nippleMorphs.Length; i++)
            {
                if (p.nippleMorphs[i] == null) continue;

                if (p.nippleMorphs[i].morphValue != p.restoreNippleValues[i] * nippleFlattenedMorphValueJSON.val) 
                {
                    p.restoreNippleValues[i] = p.nippleMorphs[i].morphValue;

                    if (debug2.val) { SuperController.LogMessage($"SaveRestoreNippleValues: Save Restore Value for '{p.nippleMorphs[i].displayName}': p.restoreNippleValues[i]='{p.restoreNippleValues[i]}'"); }
                }

                if (p.nippleMorphs[i].morphValue == 0f)
                {
                    p.restoreNippleValues[i] = 0f;

                    if (debug2.val) { SuperController.LogMessage($"SaveRestoreNippleValues: Save Restore Value for '{p.nippleMorphs[i].displayName}': p.restoreNippleValues[i]='{p.restoreNippleValues[i]}'"); }
                }
            }
        }

        //Save restore pubic hair length values (if not set to hidden already)
        private void SaveRestorePubicValues(PersonData p)
        {  
            var geometry = p.atom.GetStorableByID("geometry") as DAZCharacterSelector;

            if (geometry == null || geometry.hairItems == null || !geometry.hairItems.Any())
                return;

            foreach (var hairItem in geometry.hairItems.Where(h => h.isActiveAndEnabled && IsPubes(h)))
            {
                //Check if hairSim is ready yet
                var hairSim = hairItem.GetComponentInChildren<HairSimControl>();

                if (hairSim == null)
                {
                    if (debug2.val) { SuperController.LogMessage("ApplyHairProperty: HairSim not ready yet, retry next frame for '" + hairItem.displayName + "'"); }
                    continue;
                }

                //Read current pubic hair lengths
                float length1 = hairSim.GetFloatParamValue("length1");
                float length2 = hairSim.GetFloatParamValue("length2");
                float length3 = hairSim.GetFloatParamValue("length3");

                //Get restore values vector
                string key = hairItem.uid;
                Vector3 restore;
                if (!p.pubicHairRestoreWidth.TryGetValue(key, out restore))
                    continue;
                
                //Write new restore values (if not yet hidden)
                if (length1 != restore.x * hairInvisibleLengthValueJSON.val || length2 != restore.y * hairInvisibleLengthValueJSON.val || length3 != restore.z * hairInvisibleLengthValueJSON.val)
                {
                    p.pubicHairRestoreWidth[key] = new Vector3(length1, length2, length3);

                    if (debug2.val) SuperController.LogMessage($"SaveRestorePubicValues: Save Restore Values for '{hairItem.uid}': '{length1}'/'{length2}'/'{length3}'");
                }
            }
        }

        //Set nipple morph to flattened value
        private void SetHiddenNippleValues(PersonData p)
        {
            for (int i = 0; i < p.nippleMorphs.Length; i++)
            {
                if (p.nippleMorphs[i] != null)
                    p.nippleMorphs[i].morphValue = p.restoreNippleValues[i] * nippleFlattenedMorphValueJSON.val;

                if (debug2.val) { SuperController.LogMessage($"SetHiddenNippleValues: Set flattened Value for '{p.nippleMorphs[i].displayName}' to '{p.nippleMorphs[i].morphValue}'"); }
            }
        }

        //Set pubic hair to hidden value
        private void SetHiddenPubicValues(PersonData p)
        {
            var geometry = p.atom.GetStorableByID("geometry") as DAZCharacterSelector;
            
            if (geometry == null || geometry.hairItems == null || !geometry.hairItems.Any())
                return;

            foreach (var hairItem in geometry.hairItems.Where(h => h.isActiveAndEnabled && IsPubes(h)))
            {
                var hairSim = hairItem.GetComponentInChildren<HairSimControl>();

                string key = hairItem.uid;
                Vector3 restore;
                if (!p.pubicHairRestoreWidth.TryGetValue(key, out restore))
                    continue;

                if (hairSim != null)
                {
                    //Write new invisible hair values
                    hairSim.SetFloatParamValue("length1", restore.x * hairInvisibleLengthValueJSON.val);
                    hairSim.SetFloatParamValue("length2", restore.y *hairInvisibleLengthValueJSON.val);
                    hairSim.SetFloatParamValue("length3", restore.z * hairInvisibleLengthValueJSON.val);
                }

                if (hairSimProp.val)
                {
                    setDisableHairSimProperty(p.pubicCovered, hairItem, p);
                }

                if (debug2.val) { SuperController.LogMessage($"SetHiddenPubicValues: Set hidden value for '{hairItem.displayName}' to '{restore.x * hairInvisibleLengthValueJSON.val}'/'{restore.y * hairInvisibleLengthValueJSON.val}'/'{restore.z * hairInvisibleLengthValueJSON.val}'"); }
            }
        }

        //Restore nipple morph values
        private void LoadRestoreNippleValues(PersonData p)
        {       
            for (int i = 0; i < p.nippleMorphs.Length; i++)
            {
                if (p.nippleMorphs[i] != null)
                    p.nippleMorphs[i].morphValue = p.restoreNippleValues[i];

                if (debug2.val) { SuperController.LogMessage($"RestoreNippleMorphs: Restored Nipple Morph for '{p.nippleMorphs[i].displayName}' to '{p.restoreNippleValues[i]}'"); }
            }
        }

        private void LoadRestorePubicValues(PersonData p)
        {
            var geometry = p.atom.GetStorableByID("geometry") as DAZCharacterSelector;

            if (geometry == null || geometry.hairItems == null || !geometry.hairItems.Any())
                return;

            foreach (var hairItem in geometry.hairItems.Where(h => IsPubes(h)))
            {           
                string key = hairItem.uid;
                Vector3 restore;
                if (!p.pubicHairRestoreWidth.TryGetValue(key, out restore))
                    continue;

                var hairSim = hairItem.GetComponentInChildren<HairSimControl>();
                if (hairSim == null)
                    continue;

                float restoreLength1 = restore.x;
                float restoreLength2 = restore.y;
                float restoreLength3 = restore.z;

                hairSim.SetFloatParamValue("length1", restoreLength1);
                hairSim.SetFloatParamValue("length2", restoreLength2);
                hairSim.SetFloatParamValue("length3", restoreLength3);

                if (hairSimProp.val)
                {
                    setDisableHairSimProperty(p.pubicCovered, hairItem, p);
                }

                if (debug2.val) { SuperController.LogMessage($"LoadRestorePubicValues: Restored Pubic Haird Length for '{hairItem.displayName}' to '{restoreLength1}'/'{restoreLength2}'/'{restoreLength3}'"); }
            }
        }

        //Detect appearance changes based on nipple morph value changes (periodic)
        private void DetectMorphSumChange(PersonData p)
        {
            //Calculate current morph sum
            CalculateMorphSum(p);

            //Detect significant change of nipple morphs since last frame
            if (Mathf.Abs(morphSum - morphSumOld) > 0.0001f)
            {
                if (debug2.val) { SuperController.LogMessage($"DetectMorphSumChange: New nipple morph sum on '{p.atom.name}', morphSum={morphSum:F3}, morphSumOld={morphSumOld:F3}'"); }

                nippleMorphSumChanged = true;
            }

            morphSumOld = morphSum;
        }

        //Calculate current nipple morph sum
        private void CalculateMorphSum(PersonData p)
        {
            morphSum = 0f;

            if (p?.nippleMorphs == null)
                return;
            
            for (int i = 0; i < p.nippleMorphs.Length; i++)
            {
                var morph = p.nippleMorphs[i];
                if (morph == null)
                    continue; 
                
                morphSum += morph.morphValue * (i + 1);
            }
        }

        //Detect pubic hair changes based on pubic hair items activated
        private void DetectHairChange(PersonData p, DAZCharacterSelector geometry)
        {
            if (geometry == null || geometry.hairItems == null)
                return;

            //Calculate current hair length sum
            CalculateHairLengthSum(p, geometry);

            //Detect significant change of hair length since last frame (appearance change or manual hair length change, but not due to new clothing item covering)
            if (Mathf.Abs(lengthSum - lengthSumOld) > 0.0001f)
            {
                if (debug2.val) { SuperController.LogMessage($"DetectHairChange: New pubic hair length sum on '{p.atom.name}', lengthSum={lengthSum:F3}, lengthSumOld={lengthSumOld:F3}'"); } 

                SyncPubicHairRestoreDictionary(p, geometry);
                hairLengthSumChanged = true;
            }

            lengthSumOld = lengthSum;
        }

        //Calculating hair length sum
        private void CalculateHairLengthSum(PersonData p, DAZCharacterSelector geometry)
        {
            if (geometry == null || geometry.hairItems == null)
                return;
            
            lengthSum = 0f;

            int i = 0;

            foreach (var hairItem in geometry.hairItems)
            {
                if (hairItem == null || !hairItem.isActiveAndEnabled || !IsPubes(hairItem))
                {
                    i++;
                    continue;
                }

                var hairSim = hairItem.GetComponentInChildren<HairSimControl>();
                if (hairSim == null)
                {
                    i++;
                    continue; 
                }

                float l1 = hairSim.GetFloatParamValue("length1");
                float l2 = hairSim.GetFloatParamValue("length2");
                float l3 = hairSim.GetFloatParamValue("length3");

                float weightBase = (i + 1) * 0.137f;

                lengthSum += l1 * weightBase;
                lengthSum += l2 * (weightBase * 1.7f);
                lengthSum += l3 * (weightBase * 2.3f);

                i++;
            }
        }

        //Rebuild persons list, consider changed gender (nipple morph selection) and add new person atoms
        void InitPersons(bool clearList = true)
        {
            //Only completely rebuild the persons list if clearList = true, otherwise just add new person atoms            
            if (clearList) persons.Clear();

            foreach (Atom atom in GetAllPersonAtoms())
            {
                //SuperController.LogMessage("Debug: GetAllPersonAtoms='" + atom.name + "'");

                //Detect if person atom is already existing 
                var existingPerson = persons.FirstOrDefault(pd => ReferenceEquals(pd.atom, atom));

                var geometry = atom.GetStorableByID("geometry") as DAZCharacterSelector;
                if (geometry == null) continue;
                
                //Get person atom gender
                bool female = geometry.gender == DAZCharacterSelector.Gender.Female;

                //Person is already existing
                if (existingPerson != null)
                {
                    //Case 1: Person is existing and gender unchanged -> next person
                    if (existingPerson.isFemale == female)
                    {
                        continue;
                    }
                    
                    //Case 2: Person is existing, but gender changed -> remove person and rebuild personData in case 3
                    else
                    {
                        persons.Remove(existingPerson);

                        if (debug2.val){ SuperController.LogMessage($"InitPersons: Gender change detected on '{atom.name}', reinitializing PersonData");}
                    }
                }

                //Case 3: Person not existing or removed due to gender change
                //Add new person gender dependent morphs
                var uiNew = geometry.morphsControlUI;
                if (uiNew == null) continue;

                List<DAZMorph> nippleMorphList = new List<DAZMorph>();
                Action<string, bool> TryAdd = (uid, femaleOnly) =>
                {
                    if (femaleOnly && !female) return;

                    var morph = uiNew.GetMorphByUid(uid);
                    if (morph != null) nippleMorphList.Add(morph);
                    else if (debug2.val)
                        SuperController.LogMessage($"InitPersons: Morph '{uid}' not available on '{atom.uid}'");
                };

                //Add base nipple morphs
                TryAdd("Nipple Diameter", true);
                TryAdd("Nipples Diameter", false);
                TryAdd("Nipple Length", true);
                TryAdd("Nipples Large", false);
                TryAdd("Nipple Size", true);
                TryAdd("Nipples Size", false);
                TryAdd("Nipples", false);
                TryAdd("Nipples Apply", true);
                TryAdd("Nipples Depth", false);

                //Add selected additional nipple morphs to new persons
                string json = selectedAdditionalNippleMorphJSON?.val;

                if (!string.IsNullOrEmpty(json))
                {
                    string[] uids = json.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                    foreach (string uid in uids)
                    {
                        var extraMorph = uiNew.GetMorphByUid(uid);
                        if (extraMorph != null && !nippleMorphList.Any(m => m.uid == extraMorph.uid))
                            nippleMorphList.Add(extraMorph);
                    }
                }

                //Build new personData (not all fields of the class must be initialised here)
                var nippleMorphs = nippleMorphList.ToArray();
                PersonData person = new PersonData
                {
                    atom = atom,
                    geometry = geometry,
                    nippleMorphs = nippleMorphs,
                    restoreNippleValues = new float[nippleMorphs.Length],
                    nippleCovered = false,
                    nippleCoveredOld = false, //Important, must be set false when person atom is added to lead to appearanceChangeCheck
                    isFemale = female,
                    pubicCovered = false,
                    pubicCoveredOld = false,
                };

                //Add new or changed person atom to list
                persons.Add(person);

                //Save current nipple morph values of new person atom as restoreNippleValues
                SaveRestoreNippleValues(person);

                //Save current pubic hair width values of new person atom as pubicHairRestoreWidth
                person.pubicHairRestoreWidth.Clear();

                SaveRestorePubicValues(person);

                //Rebuild clothing cache for new person
                person.clothingCacheDirty = true;
                person.lastClothingChildCount = -1;
            }
        }

        List<Atom> GetAllPersonAtoms()
        {
            //if (debug2.val) { SuperController.LogMessage("GetAllPersonAtoms"); }

            //Scene or session plugin mode
            if (containingAtom.type != "CoreControl" && containingAtom.type != "SessionPluginManager")
            {
                return new List<Atom> { containingAtom };
            }
            else
            {
                return GetSceneAtoms()
                    .Where(a => a != null && a.type == "Person")
                    .ToList();
            }
        }

        //Add chosen additional nipple morph based on chooser callback or preset load
        private void AddSelectedNippleMorph(PersonData person)
        {
            var geometry = person.atom.GetStorableByID("geometry") as DAZCharacterSelector;
            if (geometry == null || string.IsNullOrEmpty(selectedAdditionalNippleMorphUid))
                return;

            var ui = geometry.morphsControlUI;
            if (ui == null) return;

            var morph = ui.GetMorphByUid(selectedAdditionalNippleMorphUid);
            if (morph == null) return;

            if (person.nippleMorphs.Any(m => m != null && m.uid == morph.uid))
                return;

            //Get next available additional nipple morph slot
            int slot = person.nextAdditionalNippleSlot;
            person.nextAdditionalNippleSlot =
                (person.nextAdditionalNippleSlot + 1) % PersonData.AdditionalNippleSlots;

            //Clear morph if slot is occupied
            RemoveAdditionalNippleMorph(person, slot);

            //Add morph to person nippleMorphs slot and save restore values
            var list = person.nippleMorphs.ToList();
            list.Add(morph);
            person.nippleMorphs = list.ToArray();

            Array.Resize(ref person.restoreNippleValues, person.nippleMorphs.Length);

            int idx = person.nippleMorphs.Length - 1;
            person.restoreNippleValues[idx] = morph.morphValue;

            person.additionalNippleMorphUids[slot] = morph.uid;

            if (debug2.val)
                SuperController.LogMessage(
                    $"Added '{morph.uid}' to slot {slot} on '{person.atom.name}'"
                );
        }

        private void RemoveAdditionalNippleMorph(PersonData person, int slot)
        {
            string uid = person.additionalNippleMorphUids[slot];
            if (string.IsNullOrEmpty(uid)) return;

            int index = Array.FindIndex(
                person.nippleMorphs,
                m => m != null && m.uid == uid
            );

            if (index < 0) return;

            var morphs = person.nippleMorphs.ToList();
            morphs.RemoveAt(index);
            person.nippleMorphs = morphs.ToArray();

            var restore = person.restoreNippleValues.ToList();
            restore.RemoveAt(index);
            person.restoreNippleValues = restore.ToArray();

            person.additionalNippleMorphUids[slot] = null;

            if (debug2.val)
                SuperController.LogMessage(
                    $"Removed additional nipple morph slot {slot} from '{person.atom.name}'"
                );
        }

        private void SyncPubicHairRestoreDictionary(PersonData p, DAZCharacterSelector geometry)
        {
            if (geometry == null || geometry.hairItems == null)
                return;

            //Collect current active pubic hair UIDs
            HashSet<string> currentUids = new HashSet<string>();

            foreach (var hairItem in geometry.hairItems
                .Where(h => h.isActiveAndEnabled && IsPubes(h)))
            {
                string uid = hairItem.uid;
                currentUids.Add(uid);

                //Add new hair item to dictionary
                if (!p.pubicHairRestoreWidth.ContainsKey(uid))
                {
                    var hairSim = hairItem.GetComponentInChildren<HairSimControl>();
                    if (hairSim == null)
                        continue;

                    float length1 = hairSim.GetFloatParamValue("length1");
                    float length2 = hairSim.GetFloatParamValue("length2");
                    float length3 = hairSim.GetFloatParamValue("length3");

                    p.pubicHairRestoreWidth[uid] = new Vector3(length1, length2, length3);

                    if (debug2.val)
                    {
                        SuperController.LogMessage(
                            "SyncPubicHairRestoreDictionary: Added new hair '" +
                            uid + "' with lengths " + length1 + ", " + length2 + ", " + length3);
                    }
                }
            }

            //Remove deleted hair items
            var keys = p.pubicHairRestoreWidth.Keys.ToList();
            foreach (string key in keys)
            {
                if (!currentUids.Contains(key))
                {
                    p.pubicHairRestoreWidth.Remove(key);

                    if (debug2.val)
                    {
                        SuperController.LogMessage("SyncPubicHairRestoreDictionary: Removed hair '" + key + "'");
                    }
                }
            }
        }

        //Set hair sim property
        private void setDisableHairSimProperty(bool select, DAZHairGroup hairItem, PersonData p)
        {
            if (hairItem == null || !hairItem.active)
                return;
            
            string uid = hairItem.uid;
            string author = uid.Split('.')[0];
            string lastPart = uid.Substring(uid.LastIndexOf('/') + 1);
            string name = lastPart.Replace(".vam", "");
            string storableId = $"{author}:{name}Sim";

            //SuperController.LogMessage($"setDisableHairSimProperty: Set sim to '{select}' for storableId='{storableId}' for hairItem='{hairItem.displayName}' and person='{p.atom.name}'");

            JSONStorable pubicSim = p.atom.GetStorableIDs()
                .Select(id => p.atom.GetStorableByID(id))
                .FirstOrDefault(s => 
                    s != null && 
                    string.Equals(s.storeId, storableId, StringComparison.OrdinalIgnoreCase));

            if (pubicSim == null)
            {
                if (debug2.val) { SuperController.LogError($"setDisableHairSimProperty: Sim storable not found for '{storableId}'"); }
                return;
            }

            //Set new hair sim enabled/disabled value
            pubicSim.SetBoolParamValue("simulationEnabled", !select);

            if (debug2.val) { SuperController.LogMessage($"setDisableHairSimProperty: Disabling hair sim for '{hairItem.displayName}' ('{storableId}')"); }
        }

        //Get all storables for all person atoms, debug function not regularly in use
        void getAllStorables()
        {
            foreach (PersonData p in persons)
            {
                foreach (string id in p.atom.GetStorableIDs())
                {
                    JSONStorable s = p.atom.GetStorableByID(id);

                    SuperController.LogMessage($"[STORABLE] person='{p}' id='{id}' name='{s.name}'");
                }
            }
        }

        //From HidePubes, Credit PrettyFrank
        private bool IsPubes(DAZHairGroup hairItem)
        {
            //if (debug2.val) { SuperController.LogMessage("IsPubes: testing hairItem=" + hairItem.displayName); }

            if (hairItem == null)
            {
                return false;
            }

            if (hairItem.tagsArray != null && hairItem.tagsArray.Contains("genital"))
            {
                //if (debug2.val) {SuperController.LogMessage("IsPubes: true for 'genital' in hairItem=" + hairItem.displayName); } 

                return true;
            }

            if (!string.IsNullOrEmpty(hairItem.displayName))
            {
                if (hairItem.displayName.IndexOf("pube", StringComparison.OrdinalIgnoreCase) >= 0 ||
                    hairItem.displayName.IndexOf("pubic", StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    //if (debug2.val) {SuperController.LogMessage("IsPubes: true for 'pube' or 'pubic' in hairItem=" + hairItem.displayName); } 

                    return true;
                }
            }
            
            return false;
        }

        void Update()
        {
            if (SuperController.singleton.isLoading || SuperController.singleton.freezeAnimation) 
            {return;}

            if(isSceneLoaded && isActive) 
            {
                try
                {   
                    if (debug1 || debug4) { SuperController.LogError("Update() Start"); }
                    if (debug3) { t0 = Time.realtimeSinceStartup; }
                    if (debug3) { t1 = Time.realtimeSinceStartup; }

                    //Load distribution
                    int phase1 = timer4 % 15; //Every 15 frames
                    bool refresh15_2 = (phase1 == 2);
                    bool refresh15_3 = (phase1 == 3);
                    bool refresh15_4 = (phase1 == 4);
                    bool refresh15_5 = (phase1 == 5);
                    bool refresh15_6 = (phase1 == 6);
                    bool refresh15_8 = (phase1 == 8);
                    bool refresh15_11 = (phase1 == 11);
                    bool refresh15_12 = (phase1 == 12);
                    int phase2 = timer4 % 60; //Every 60 frames
                    bool refresh60_7 = (phase2 == 7);
                    bool refresh60_13 = (phase2 == 13);

                    //Initial gathering of all nipple morphs for the popup chooser (only once if triggered with refreshNippleMorphsList = true, very performance relevant with many morphs)
                    if (nippleMode.val && refreshNippleMorphsList)
                    {
                        if (debug4) SuperController.LogMessage("Update(): Initial Nipple Morph List Generation (once only)"); 

                        myNippleMorphsList1.choices = GetAvailableNippleMorphNames();
                        refreshNippleMorphsList = false;
                    }

                    //Periodically check for changed person atoms
                    if (refresh60_7 && (nippleMode.val || pubicMode.val))
                    {
                        if (debug4) SuperController.LogMessage("Update(): Refresh Persons (periodically)");  

                        InitPersons(clearList: false);
                    }

                    //Check for selected person atom and hook appearance saving button
                    if (refresh15_2 && (nippleMode.val || pubicMode.val))
                    {
                        if (debug4) SuperController.LogMessage("Update(): Add Store Button Hook (periodically)");

                        AddStorePresetHook(); //Hooking is only done once if person atom is switched
                    }

                    if (debug1) { SuperController.LogError("Update() 1.0"); }
                    if (debug3) { SuperController.LogMessage("Schritt 1.0: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                    if (debug3) { t0 = Time.realtimeSinceStartup; }

                    foreach (PersonData p in persons)
                    {
                        //Detect changed active clothing items
                        if (refresh15_11 && !p.clothingCacheDirty)
                        {
                            if (debug4) SuperController.LogMessage("Update(): Detect changes of active clothing (periodically)"); 

                            var items = p.atom.GetComponentsInChildren<DAZClothingItem>(false);
                            int currentCount = items.Length;

                            if (currentCount != p.lastClothingInstanceCount)
                            {
                                p.lastClothingInstanceCount = currentCount;
                                p.clothingCacheDirty = true;
                                continue;
                            }
                        }

                        //Detect changed clothing tags
                        if (refresh15_12 && !p.clothingCacheDirty)
                        {
                            foreach (var e in p.clothingCache)
                            {
                                if (!e.item.active) continue;

                                if (debug4) SuperController.LogMessage("Update(): Detect clothing tag changes for " + e.item.displayName + " (periodically)"); 

                                //Detect changed clothing tags
                                var c = e.item;
                                int currentHash = ComputeTagsHash(c.tagsArray);

                                if (currentHash != e.cachedTagsHash)
                                {
                                    e.cachedTagsHash = currentHash;
                                    p.clothingCacheDirty = true;
    
                                    break; 
                                }
                            }
                        }

                        if (debug1) { SuperController.LogError("Update() 1.1"); }
                        if (debug3) { SuperController.LogMessage("Schritt 1.1: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                        if (debug3) { t0 = Time.realtimeSinceStartup; }
                        
                        //Rebuild clothing cache, only if marked dirty                   
                        if (p.clothingCacheDirty)
                        {
                            if (debug4) { SuperController.LogMessage("Update(): Rebuilding clothing cache for '" + p.atom.name + "' (clothingCacheDirty=true)"); }

                            RebuildClothingCache(p);
                            AttachSimStorable(p);
                            continue;
                        }

                        //Detect nipple morph and pubic hair length changes (newly loaded appearance presets or user defined morph changes)
                        if (nippleMode.val) DetectMorphSumChange(p);
                        var geometry = p.atom.GetStorableByID("geometry") as DAZCharacterSelector;
                        if (pubicMode.val) DetectHairChange(p, geometry);

                        //Refresh sim detach states in clothing cache periodically
                        if (refresh15_5 && (nippleMode.val || pubicMode.val))
                        {                          
                            foreach (var e in p.clothingCache)
                            {
                                if (!e.item.active) continue;

                                if (debug4) SuperController.LogMessage("Update(): Refresh cached sim state for active clothing '" + e.item.displayName + " (periodically)"); 

                                if (e.simStorable == null) continue;
								
								// B69 Start Change Section
								// In Assembly-CSharp JSONStorable.cs GetBoolParamValue throws a Debug.LogError before returning 'false', if the param name provided doesn't exist
								// because it returns a bool value under any circumstances it masks the underlying bug so its not caught in the plugin exception handling
								// I've just added a simple check - gather all param names available in the JSONStorable, and check if the desired ones are in the list
								// only calls GetBoolParamValue if we know the parameter exists in simStorable
								boolParamNamesList = e.simStorable.GetBoolParamNames();
								if (boolParamNamesList.Contains("simEnabled")) e.simEnabled = e.simStorable.GetBoolParamValue("simEnabled");
								if (boolParamNamesList.Contains("allowDetach")) e.allowDetach = e.simStorable.GetBoolParamValue("allowDetach");
								// B69 End Change Section
                            }
                        }

                        //Detect current clothing sim detached properties for active items only
                        if (refresh15_8 && (nippleMode.val || pubicMode.val))
                        {
                            foreach (var e in p.clothingCache)
                            {
                                if (!e.item.active) continue;

                                if (debug4)SuperController.LogMessage("Update(): Detect current sim state for active clothing " + e.item.displayName + " (periodically)");

                                if (e.simStorable == null) continue;

								// B69 Start Change Section
								// just initialise these bool variables to false as that is what woudlve been returned if the paramaters didn't exist
								// if the params do exist they will be set appropriately
								bool simEnabledNow = false;
								bool allowDetachNow = false;
								boolParamNamesList = e.simStorable.GetBoolParamNames();
								if (boolParamNamesList.Contains("simEnabled")) simEnabledNow = e.simStorable.GetBoolParamValue("simEnabled");
								if (boolParamNamesList.Contains("allowDetach")) allowDetachNow = e.simStorable.GetBoolParamValue("allowDetach");
								// B69 End Change Section

                                //Sim detached state change detected
                                if (simEnabledNow != e.simEnabled || allowDetachNow != e.allowDetach)
                                {
                                    e.simEnabled = simEnabledNow;
                                    e.allowDetach = allowDetachNow;

                                    AttachSimStorable(p);
                                    break;
                                }
                            }
                        }

                        if (debug1) { SuperController.LogError("Update() 1.2"); }
                        if (debug3) { SuperController.LogMessage("Schritt 1.2: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                        if (debug3) { t0 = Time.realtimeSinceStartup; }

                        //Reset entry conditions (nipples have the same state as they had one frame before, nippleCovered will be set later)
                        p.nippleCovered = false;
                        p.pubicCovered = false;
                        clothingNippleCovering = "-";
                        clothingPubicCovering = "-";

                        //Do the checks for nipple and pubic hair coverage for all active clothing items in the current person atom's clothing cache
                        var cache = p.clothingCache;
                        
                        bool checkNipples = nippleMode.val && !p.nippleCovered;
                        bool checkPubic = pubicMode.val && !p.pubicCovered;

                        for (int i = 0; i < cache.Count; i++)
                        {
                            var e = cache[i];
                            var c = e.item;

                            bool active = c.isActiveAndEnabled;

                            //Clothing has been activated or deactivated
                            if (active != e.wasActive)
                            {
                                e.wasActive = active;
                            }

                            //Only consider active clothing items
                            if (!active)
                                continue;

                            if (debug4) SuperController.LogMessage("Update(): Check nipple/pubic coverage for " + e.item.displayName); 

                            // ---------- NIPPLE COVERAGE ----------
                            if (checkNipples && e.isPotentialTop && !e.isExpose)
                            {
                                //SuperController.LogMessage("clothing: " + c + " - sim enabled: " + e.simEnabled + ", sim detached:" + e.allowDetach);

                                if (!(e.simEnabled && e.allowDetach))
                                {
                                    p.nippleCovered = true;
                                    clothingNippleCovering = c.displayName;
                                    checkNipples = false;

                                    if (debug4) SuperController.LogMessage("Update(): Nipples covered"); 
                                }
                            }

                            // ---------- PUBIC COVERAGE ----------
                            if (checkPubic && e.isPotentialBottom && !e.isExpose)
                            {
                                if (!(e.simEnabled && e.allowDetach))
                                {
                                    p.pubicCovered = true;
                                    clothingPubicCovering = c.displayName;
                                    checkPubic = false;

                                    if (debug4) SuperController.LogMessage("Update(): Pubic hair covered"); 
                                }
                            }

                            //Break early if both covered
                            if (p.nippleCovered && p.pubicCovered)
                                break;
                        }

                        if (debug1) { SuperController.LogError("Update() 1.4"); }
                        if (debug3) { SuperController.LogMessage("Schritt 1.4: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                        if (debug3) { t0 = Time.realtimeSinceStartup; }

                        //if (debug2.val) { SuperController.LogMessage($"Frame Flags Status: nippleMorphSumChanged='{nippleMorphSumChanged}', nippleSliderValueChanged='{nippleSliderValueChanged}', p.nippleCovered='{p.nippleCovered}', p.nippleCoveredOld='{p.nippleCoveredOld}'"); }

                        //Special handling after appearance/morph changes etc. (not hidden value slider change)
                        if (nippleMorphSumChanged && !nippleSliderValueChanged)
                        {
                            if (p.nippleCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: MORPH CHANGE DETECTED (COVERED)"); }

                                //Don't do this after manual morph input in hidden nipple state...
                                SaveRestoreNippleValues(p);
                                p.nippleCoveredOld = false;
                            }

                            if (!p.nippleCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: MORPH CHANGE DETECTED (UNCOVERED)"); }

                                SaveRestoreNippleValues(p); 
                            }
                        }

                        //Special handling after hidden value slider change
                        if (nippleSliderValueChanged)
                        {
                            if (debug2.val) { SuperController.LogMessage($"Mode: NIPPLESLIDER CHANGED"); }

                            //Recalculate new morph sum to prevent detection of morph sum change
                            CalculateMorphSum(p);
                            morphSumOld = morphSum;
                        }

                        //APPLY NIPPLE MORPH CHANGES
                        if (nippleMode.val && p.nippleCovered != p.nippleCoveredOld)
                        {
                            if (p.nippleCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: APPLY NIPPLE MORPH CHANGES (COVERED)"); }

                                //Save restore values
                                SaveRestoreNippleValues(p);

                                //Hide nipples
                                SetHiddenNippleValues(p);
                            }

                            if (!p.nippleCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: APPLY NIPPLE MORPH CHANGES (UNCOVERED)"); }

                                LoadRestoreNippleValues(p);
                            }

                            //Recalculate new morph sum to prevent detection of morph sum change
                            CalculateMorphSum(p);
                            morphSumOld = morphSum;
                        }

                        if (debug1) { SuperController.LogError("Update() 1.5"); }
                        if (debug3) { SuperController.LogMessage("Schritt 1.5: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                        if (debug3) { t0 = Time.realtimeSinceStartup; }

                        //Special handling after hair length changes etc. (not hidden value slider change)
                        if (hairLengthSumChanged && !hairSliderValueChanged)
                        {
                            if (p.pubicCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: PUBIC HAIR CHANGE DETECTED (COVERED)"); }

                                //Don't do this after manual length input in hidden state...
                                SaveRestorePubicValues(p);
                                p.pubicCoveredOld = false;
                            }

                            if (!p.pubicCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: PUBIC HAIR CHANGE DETECTED (UNCOVERED)"); }

                                SaveRestorePubicValues(p); 
                            }
                        }

                        //Special handling after hidden value slider change
                        if (hairSliderValueChanged)
                        {
                            if (debug2.val) { SuperController.LogMessage($"Mode: HAIRSLIDER CHANGED"); }

                            //Recalculate new hair length sum to prevent detection of length sum change
                            CalculateHairLengthSum(p, geometry);
                            lengthSumOld = lengthSum;
                        }

                        //APPLY PUBIC HAIR CHANGES
                        if (pubicMode.val && p.pubicCovered != p.pubicCoveredOld)
                        {
                            if (p.pubicCovered)  
                            {
                                if (debug2.val || debug4) { SuperController.LogMessage($"Mode: APPLY PUBIC HAIR CHANGES (COVERED)"); }

                                //Save restore values
                                SaveRestorePubicValues(p);

                                //Hide nipples
                                SetHiddenPubicValues(p);
                            }

                            if (!p.pubicCovered)
                            {
                                if (debug2.val) { SuperController.LogMessage($"Mode: APPLY PUBIC HAIR CHANGES (UNCOVERED)"); }

                                LoadRestorePubicValues(p);
                            }

                            //Recalculate new morph sum to prevent detection of morph sum change
                            CalculateHairLengthSum(p, geometry);
                            lengthSumOld = lengthSum;
                        }

                        //Set current values for next frame and reset flags
                        nippleMorphSumChanged = false;
                        p.nippleCoveredOld = p.nippleCovered;
                        nippleSliderValueChanged = false;

                        hairLengthSumChanged = false;
                        p.pubicCoveredOld = p.pubicCovered;
                        hairSliderValueChanged = false;

                        if (debug1) { SuperController.LogError("Update() 1.6"); }
                        if (debug3) { SuperController.LogMessage("Schritt 1.6: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                        if (debug3) { t0 = Time.realtimeSinceStartup; }
                    }

                    //Dynamic text field update for added nipple morph
                    if (refresh60_13 && nippleMode.val)
                    { 
                        string[] addonMorphUids = selectedAdditionalNippleMorphJSON.val
                                .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                        List<string> addonMorphNames = new List<string>();

                        foreach (string uid in addonMorphUids)
                        {
                            foreach (var kv in myUidLookup1)
                            {                               
                                if (kv.Value == uid)
                                {
                                    //SuperController.LogError("Test2b: Found matching uid='" + uid + "' for morph name='" + kv.Key + "'"); 

                                    addonMorphNames.Add(kv.Key);
                                    break;
                                }
                            }
                        }

                        string addonMorphText =
                            addonMorphNames.Count > 0
                                ? string.Join(", ", addonMorphNames.ToArray())
                                : "None";

                        stateVal = "Added nipple morphs: " + addonMorphText;
                        _textField1.text = stateVal;
                    }

                    //Dynamic text field update for active clothing hiding nipples and/or pubic hair
                    if (refresh15_6 && (nippleMode.val || pubicMode.val))
                    { 
                        var parts = new List<string>();
                        
                        if (clothingNippleCovering != null)
                        {
                            var s = clothingNippleCovering.Trim();
                            if (s.Length > 0)
                                parts.Add("Nipples covered by '" + s + "'");
                        }

                        if (clothingPubicCovering != null)
                        {
                            var s = clothingPubicCovering.Trim();
                            if (s.Length > 0)
                                parts.Add("Pubic covered by '" + s + "'");
                        }

                        string result = string.Join("\n", parts.ToArray());

                        //SuperController.LogMessage("Hidden by: " + string.Join(", ", activeClothingItems));

                        stateVal3 = result;
                        _textField3.text = stateVal3;
                    }

                    timer4++;
                    if (timer4 >= 60) timer4 = 0;

                    if (debug1) { SuperController.LogError("Update() End"); }
                    if (debug3) { SuperController.LogMessage("Schritt End: " + (Time.realtimeSinceStartup - t0) * 1000f + " ms"); }
                    if (debug3) { t0 = Time.realtimeSinceStartup; }
                    if (debug3) { SuperController.LogMessage("Schritt End: " + (Time.realtimeSinceStartup - t1) * 1000f + " ms"); }
                    if (debug3) { t1 = Time.realtimeSinceStartup; }
                    if (debug4) { SuperController.LogMessage("Update(): End"); }
                }
                catch (Exception e)
                {
                    SuperController.LogError($"{nameof(NippleClippingEliminator)}.{nameof(Init)}: {e}");
                }
            }
        }

        //Dynamic help text fields with debug inputs (Hazmhox VAMMoan 2)
        public static void SetupTextField(UIDynamicTextField target, float fieldHeight, bool disableBackground = false, bool disableScroll = true)
        {
            if (disableBackground) target.backgroundColor = new Color(1f, 1f, 1f, 0f);
            LayoutElement tfLayout = target.GetComponent<LayoutElement>();
            tfLayout.preferredHeight = tfLayout.minHeight = fieldHeight;
            target.height = fieldHeight;
            if (disableScroll) DisableScrollOnText(target);
        }

        public static UIDynamicTextField CreateStaticDescriptionText(MVRScript script, string DescTitle, string DescText, bool rightSide, int fieldHeight, TextAnchor textAlignment = TextAnchor.UpperLeft, bool disableBackground = false, bool disableScroll = true)
        {
            JSONStorableString staticDescString = new JSONStorableString(DescTitle, DescText) { isStorable = false, isRestorable = false };
            staticDescString.hidden = true;
            UIDynamicTextField staticDescStringField = script.CreateTextField(staticDescString, rightSide);
            if (disableBackground) staticDescStringField.backgroundColor = new Color(1f, 1f, 1f, 0f);
            staticDescStringField.UItext.alignment = textAlignment;
            LayoutElement sdsfLayout = staticDescStringField.GetComponent<LayoutElement>();
            sdsfLayout.preferredHeight = sdsfLayout.minHeight = fieldHeight;
            staticDescStringField.height = fieldHeight;
            if (disableScroll) DisableScrollOnText(staticDescStringField);
            return staticDescStringField;
        }

        public static void DisableScrollOnText(UIDynamicTextField target)
        {
            // THIS is important, it's a "useless" temporary canvas group that will prevent the event from the mousewheel
            CanvasGroup tmpCG = target.UItext.transform.parent.transform.parent.transform.parent.gameObject.AddComponent<CanvasGroup>();
            tmpCG.blocksRaycasts = false;

            ScrollRect targetSR = target.UItext.transform.parent.transform.parent.transform.parent.GetComponent<ScrollRect>();
            if (targetSR != null)
            {
                targetSR.horizontal = false;
                targetSR.vertical = false;
            }
        }

        //UI text field (entire UI size)
		private JSONStorableString createStaticDescriptionTextMain( string DescTitle, string DescText, bool rightSide, int fieldHeight ) 
        {
			JSONStorableString staticDescString = new JSONStorableString(DescTitle,DescText);
			UIDynamicTextField staticDescStringField = CreateTextField(staticDescString, rightSide);
			staticDescStringField.backgroundColor = new Color(1f, 1f, 1f, 0f);
            staticDescStringField.textColor = new Color(1f, 1f, 1f, 1f);
			LayoutElement sdsfLayout = staticDescStringField.GetComponent<LayoutElement>();
			sdsfLayout.preferredHeight = sdsfLayout.minHeight = fieldHeight;
			staticDescStringField.height = fieldHeight;
			DisableScrollOnText(staticDescStringField);
			return staticDescString;
		}

        //UI main menu buttons and full size help text boxes
        public static class UIWidgets 
        {
            public static UIDynamicTextField CreateVAMTextField(NippleClippingEliminator DM, Transform parent)
            {
                Transform textFieldPrefab = GameObject.Instantiate(DM.manager.configurableTextFieldPrefab.transform);
                UIDynamicTextField uIDynamicTextField = textFieldPrefab.GetComponent<UIDynamicTextField>();
                uIDynamicTextField.transform.SetParent(parent, false);
                return uIDynamicTextField;
            }
        }

        //Debug helper function, not regularly in use
        private void DebugActivePersons(string header = "Active persons")
        {
            string line = $"{header}: {persons.Count} person atom(s) found:\n";

            line += string.Join("",
                persons.Select((p, i) =>
                    $"[{i}] Atom='{p.atom.name}', " +
                    $"Nipples covered={p.nippleCovered}, " +
                    $"Female={p.isFemale}, " +
                    $"Morphs={p.nippleMorphs.Length}\n"
                ).ToArray()
            );

            if (debug2.val) { SuperController.LogMessage(line); }
        }

        //Debug helper function to get the person atom UI hierarchy, not regularly in use
        void getUIHierarchy()
        {
            Atom personAtom = SuperController.singleton.GetAtoms()
                .FirstOrDefault(a => a.name == "Person");
            if(personAtom == null)
            {
                SuperController.LogMessage("Found no person atom named 'Person'");
                return;
            }
            var pluginManager = personAtom.GetStorableByID("PluginManager") as MVRPluginManager;
            if(pluginManager == null)
            {
                SuperController.LogMessage("PluginManager does not exist.");
                return;
            }
            DumpUIHierarchy(pluginManager.UITransform);
        }

        void DumpUIHierarchy(Transform root, string indent = "")
        {
            if (root == null)
            {
                SuperController.LogError("DumpUIHierarchy: root is null!");
                return;
            }

            string line = indent + "↳ " + root.name;

            // Optional: Text-Komponente anzeigen
            Text txt = root.GetComponent<Text>();
            if (txt != null && !string.IsNullOrEmpty(txt.text))
            {
                line += $" [Text]: \"{txt.text}\"";
            }

            // Optional: Button-Komponente markieren
            Button btn = root.GetComponent<Button>();
            if (btn != null)
            {
                line += " [Button]";
            }

            SuperController.LogMessage(line);

            foreach (Transform child in root)
            {
                DumpUIHierarchy(child, indent + "  ");
            }
        }
    }

    //Function to allow detection of hover over a UI button
    public class StorePresetHoverHook : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
    {
        public NippleClippingEliminator plugin;

        public void OnPointerEnter(PointerEventData eventData)
        {
            plugin.OnStorePresetHover();
        }

        public void OnPointerExit(PointerEventData eventData)
        {
            plugin.OnStorePresetHoverExit();
        }
    }
}