/* /////////////////////////////////////////////////////////////////////////////////////////////////

PluginReloader by VamEssentials - Atom Plugin Version
Licensed under CC-BY. (see https://creativecommons.org/licenses/by/4.0/)

///////////////////////////////////////////////////////////////////////////////////////////////// */

using UnityEngine;
using UnityEngine.UI;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using SimpleJSON;

namespace VamEssentials
{
    public class PluginReloader : MVRScript
    {
        private string selectedAtom = "";
        private string selectedPlugin = "";
        private string selectedPlugin2 ="";
        private JSONStorableStringChooser atomChooser;
        private JSONStorableStringChooser pluginChooser;
        private JSONStorableAction reloadAction;
        private JSONStorableBool enableLogging;
        private JSONStorableStringChooser reloadHotkey;
        private JSONStorableAction triggerAction;

        // Trigger Delays
        private JSONStorableFloat triggerDelay1;
        private JSONStorableFloat triggerDelay2;
        private JSONStorableFloat triggerDelay3;

        private EventTriggerWithCallback trigger1;
        private EventTriggerWithCallback trigger2;
        private EventTriggerWithCallback trigger3;


        private JSONStorableString triggerActionName = new JSONStorableString("Trigger Action Name", "On Reload Complete");
        private List<JSONStorableAction> triggerList = new List<JSONStorableAction>();


        private readonly List<string> hotkeyOptions = new List<string>
        {
            "None", "Escape", "Space", "Tab",
            "Alpha1", "Alpha2", "Alpha3", "Alpha4", "Alpha5",
            "Alpha6", "Alpha7", "Alpha8", "Alpha9", "Alpha0",
            "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
            "A", "S", "D", "F", "G", "H", "J", "K", "L",
            "Z", "X", "C", "V", "B", "N", "M",
            "Keypad0", "Keypad1", "Keypad2", "Keypad3", "Keypad4",
            "Keypad5", "Keypad6", "Keypad7", "Keypad8", "Keypad9",
            "KeypadPlus", "KeypadMinus", "KeypadMultiply", "KeypadDivide",
            "UpArrow", "DownArrow", "LeftArrow", "RightArrow",
            "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
            "Home", "End", "PageUp", "PageDown", "Insert", "Delete",
            "LeftControl", "RightControl", "LeftAlt", "RightAlt",
            "LeftShift", "RightShift", "Backspace", "Return", "Enter"
        };

        // Start of Init
        public override void Init()
        {
            try
            {
                enableLogging = new JSONStorableBool("Enable Logging", false);
                RegisterBool(enableLogging);
                CreateToggle(enableLogging, false);
                if (containingAtom.type == "SessionPluginManager")
                {
                    SuperController.LogError("PluginReloader is not supported as a Session Plugin. Please use it as a Scene Plugin instead.");
                    return;
                }
                Log("PluginReloader loaded as a Scene Plugin.");


                SimpleTriggerHandler.LoadAssets();

                reloadHotkey = new JSONStorableStringChooser("Reload HotKey", hotkeyOptions, "F5", "Reload HotKey");
                RegisterStringChooser(reloadHotkey);
                CreateFilterablePopup(reloadHotkey, false);

                CreateUI();
                CreateActions();

            }
            catch (Exception e)
            {
                Log($"Error initializing plugin: {e.Message}");
            }
        }
        // End of Init

        private void CreateUI()
        {
            // Left Side of UI
            atomChooser = new JSONStorableStringChooser("SelectedAtom", GetAtomUIDs(), "", "Select Atom", (atom) =>
            {
                selectedAtom = atom;
                UpdatePluginsDropdown();
            });
            RegisterStringChooser(atomChooser);
            CreateFilterablePopup(atomChooser, false);

            pluginChooser = new JSONStorableStringChooser("SelectedPlugin", new List<string>(), "", "Select Plugin", (plugin) =>
            {
                selectedPlugin = plugin;
            });
            RegisterStringChooser(pluginChooser);
            CreateFilterablePopup(pluginChooser, false);

            var reloadButton = CreateButton("Reload Plugin");
            reloadButton.button.onClick.AddListener(() => ReloadPlugin());

            // Right Side of UI
            triggerDelay1 = new JSONStorableFloat("Trigger Delay 1 (seconds)", 2.0f, 0.0f, 60.0f, true);
            triggerDelay2 = new JSONStorableFloat("Trigger Delay 2 (seconds)", 3.0f, 0.0f, 60.0f, true);
            triggerDelay3 = new JSONStorableFloat("Trigger Delay 3 (seconds)", 4.0f, 0.0f, 60.0f, true);

            RegisterFloat(triggerDelay1);
            RegisterFloat(triggerDelay2);
            RegisterFloat(triggerDelay3);

            trigger1 = new EventTriggerWithCallback(this, "Trigger After Delay 1");
            trigger2 = new EventTriggerWithCallback(this, "Trigger After Delay 2");
            trigger3 = new EventTriggerWithCallback(this, "Trigger After Delay 3");

            trigger1.Callback = () => Log("Delay 1 Triggered");
            trigger2.Callback = () => Log("Delay 2 Triggered");
            trigger3.Callback = () => Log("Delay 3 Triggered");

            CreateSlider(triggerDelay1, true);
            CreateButton("Edit Delay 1 Trigger", true).button.onClick.AddListener(() => trigger1.OpenPanel());

            CreateSlider(triggerDelay2, true);
            CreateButton("Edit Delay 2 Trigger", true).button.onClick.AddListener(() => trigger2.OpenPanel());

            CreateSlider(triggerDelay3, true);
            CreateButton("Edit Delay 3 Trigger", true).button.onClick.AddListener(() => trigger3.OpenPanel());
        }

        private void CreateActions()
        {
            reloadAction = new JSONStorableAction("Reload Plugin", ReloadPlugin);
            RegisterAction(reloadAction);
        }

        private List<string> GetAtomUIDs()
        {
            List<string> atomUIDs = new List<string>();
            foreach (var atom in SuperController.singleton.GetAtoms())
            {
                atomUIDs.Add(atom.uid);
            }
            return atomUIDs;
        }

        private void Update()
        {
            if (!string.IsNullOrEmpty(reloadHotkey?.val) && Input.GetKeyDown((KeyCode)Enum.Parse(typeof(KeyCode), reloadHotkey.val)))
            {
                ReloadPlugin();
                StartCoroutine(ExecuteTriggersWithDelay());

            }
        }

        private void UpdatePluginsDropdown()
        {
            Atom atom = SuperController.singleton.GetAtomByUid(selectedAtom);
            if (atom == null) return;

            var pluginNames = new List<string>();
            var pluginManager = atom.GetStorableByID("PluginManager") as MVRPluginManager;
            if (pluginManager != null)
            {
                foreach (var plugin in pluginManager.GetComponentsInChildren<MVRScript>())
                {
                    pluginNames.Add(plugin.storeId);
                }
            }
            pluginChooser.choices = pluginNames;
            pluginChooser.SetVal(pluginNames.Count > 0 ? pluginNames[0] : "");
        }

        private void ReloadPlugin()
        {
            removePlugin(selectedPlugin, "Reload");
        }

        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 + "  ");
            }
        }

        protected void removePlugin(string selectedPlugin, string function)
        {
            //This conversion is necessary, because you deliver the plugin name including the prefix ("plugin#1"), but only creator and name is needed.
            string fullString = selectedPlugin;
            Match m = Regex.Match(fullString, @"^plugin#\d+_(.+)$");
            if (m.Success)
            {
                selectedPlugin2 = m.Groups[1].Value; // Gives: "Creator.PluginName"
            }
            
            Atom atom = SuperController.singleton.GetAtomByUid(selectedAtom);
            if (atom == null) return;
            var pluginManager = atom.GetStorableByID("PluginManager") as MVRPluginManager;
            if (pluginManager == null) return;
            
            //This function serves to either remove or reload a certain plugin. The string selectedPlugin should contain the plugin creator and plugin name (e.g. RunRudolf.ControlCenter), the string function can be either "Reload" or "Remove".
            SuperController.LogError("Start: '" + function + "' '" + selectedPlugin2 + "'");

            Transform panelRoot = pluginManager.UITransform;
            if (panelRoot == null) return;

            //This part serves to create a dump of the UI hierarchy, just comment out to deactivate it. The hierarchy can be found in the error log file.
            //DumpUIHierarchy(pluginManager.UITransform);

            foreach (Transform pluginPanel in panelRoot)
            {
                Text[] allTexts = pluginPanel.GetComponentsInChildren<Text>(true);
                Button[] buttons = pluginPanel.GetComponentsInChildren<Button>(true);

                //1. Count the number of plugin#? text entries (e.g. "plugin#1")
                List<Text> pluginTexts = new List<Text>();
                Regex pattern1 = new Regex(@"^plugin#\d+$");
                foreach (var txt in allTexts)
                {
                    if (!string.IsNullOrEmpty(txt.text) && pattern1.IsMatch(txt.text) && txt.gameObject.name == "UID")
                    {
                        pluginTexts.Add(txt);
                    }
                }
                SuperController.LogError(function + ": Found " + pluginTexts.Count + " plugin#?:");
                //DEBUG
                StringBuilder sb = new StringBuilder();
                foreach (Text tx in pluginTexts)
                {
                    sb.AppendLine(tx.text);
                }
                string result1 = sb.ToString();
                SuperController.LogError(result1);

                //2. Count the number of plugin#?_? text entries (e.g. "plugin#1_RunRudolf.ControlCenter")
                List<Text> pluginTexts2 = new List<Text>();
                Regex pattern2 = new Regex(@"^plugin#\d+_.+$");
                foreach (var txt in allTexts)
                {
                    if (!string.IsNullOrEmpty(txt.text) && pattern2.IsMatch(txt.text) && txt.gameObject.name == "UID")
                    {
                        pluginTexts2.Add(txt);
                    }
                }
                SuperController.LogError(function + ": Found " + pluginTexts2.Count + " plugin#?_?:");
                //DEBUG
                StringBuilder sb2 = new StringBuilder();
                foreach (Text tx in pluginTexts2)
                {
                    sb2.AppendLine(tx.text);
                }
                string result2 = sb2.ToString();
                SuperController.LogError(result2);

                //3. Determine position of selectedPlugin
                string escapedPlugin = Regex.Escape(selectedPlugin2);
                Regex pattern3 = new Regex($@"^plugin#\d+_{escapedPlugin}$");
                for (int i = 0; i < pluginTexts2.Count; i++)
                {
                    if (pattern3.IsMatch(pluginTexts2[i].text))
                    {
                        int position1 = i + 1;
                        SuperController.LogError(function + ": Found " + "'" + selectedPlugin2 + "'at Position " + position1 + " out of " + pluginTexts2.Count);

                        //4. Determine plugin#? at position i+1 (index i)
                        string text = pluginTexts2[i].text;
                        SuperController.LogError(function + ": " + text);

                        if (text.Contains("_"))
                        {
                            string[] parts = text.Split('_');
                            if (parts.Length > 1)
                            {
                                string pluginId = parts[0];
                                SuperController.LogError(function + ": " + "pluginID of " + selectedPlugin2 + ": " + pluginId);

                                //5. Compare selectedPlugin to plugin#? from list in 1
                                int index = pluginTexts.FindIndex(t => t.text == pluginId);
                                if (index >= 0)
                                {
                                    int position2 = index + 1;
                                    SuperController.LogError(function + ": Found " + pluginId + " at position " + position2);

                                    //6. Count number of Reload/Remove buttons
                                    List<Button> reloadButtons = new List<Button>();
                                    foreach (var btn in buttons)
                                    {
                                        string btnText = btn.GetComponentInChildren<Text>()?.text;
                                        if (btnText == function)
                                        {
                                            reloadButtons.Add(btn);
                                        }
                                    }
                                    SuperController.LogError(function + ": Found " + reloadButtons.Count + " " + function + " Buttons.");

                                    //7. Execute Button at correct position
                                    //Reload buttons for plugins are positioned in the UI starting from index 0, Remove buttons for plugins start at index 1 (first is atom remove)
                                    if (function == "Reload")
                                    {
                                        position2 = position2 - 1;
                                    }
                                    reloadButtons[position2].onClick.Invoke();
                                    SuperController.LogError(function + ": " + function + " Button for " + selectedPlugin2 + " clicked at index: " + position2);
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }





        private IEnumerator WaitThenClickReload(Transform pluginPanel)
        {
            yield return null; // wait one frame

            Button[] buttons = pluginPanel.GetComponentsInChildren<Button>(true);
            foreach (var btn in buttons)
            {
                var txt = btn.GetComponentInChildren<Text>()?.text;
                if (txt == "Reload")
                {
                    btn.onClick.Invoke();
                    Log($"UI Reload triggered for plugin: {selectedPlugin}");
                    StartCoroutine(ExecuteTriggersWithDelay());
                    yield break;
                }
            }

            Log("Reload button still not found after expanding UI.");
        }


        private IEnumerator ExecuteTriggersWithDelay()
        {
            if (triggerDelay1.val > 0)
                yield return new WaitForSeconds(triggerDelay1.val);
            trigger1?.Trigger();
            Log("Executed Delay 1 Trigger");

            if (triggerDelay2.val > 0)
                yield return new WaitForSeconds(triggerDelay2.val);
            trigger2?.Trigger();
            Log("Executed Delay 2 Trigger");

            if (triggerDelay3.val > 0)
                yield return new WaitForSeconds(triggerDelay3.val);
            trigger3?.Trigger();
            Log("Executed Delay 3 Trigger");
        }

        public override JSONClass GetJSON(bool includePhysical = true, bool includeAppearance = true, bool forceStore = false)
        {
            JSONClass jc = base.GetJSON(includePhysical, includeAppearance, forceStore);
            if (includePhysical || forceStore)
            {
                needsStore = true;
                jc[trigger1.Name] = trigger1.GetJSON(base.subScenePrefix);
                jc[trigger2.Name] = trigger2.GetJSON(base.subScenePrefix);
                jc[trigger3.Name] = trigger3.GetJSON(base.subScenePrefix);
            }
            return jc;
        }

        public override void LateRestoreFromJSON(JSONClass jc, bool restorePhysical = true, bool restoreAppearance = true, bool setMissingToDefault = true)
        {
            base.LateRestoreFromJSON(jc, restorePhysical, restoreAppearance, setMissingToDefault);
            if (!base.physicalLocked && restorePhysical && !IsCustomPhysicalParamLocked("trigger"))
            {
                trigger1.RestoreFromJSON(jc, base.subScenePrefix, base.mergeRestore, setMissingToDefault);
                trigger2.RestoreFromJSON(jc, base.subScenePrefix, base.mergeRestore, setMissingToDefault);
                trigger3.RestoreFromJSON(jc, base.subScenePrefix, base.mergeRestore, setMissingToDefault);
            }
        }

        private void Log(string message)
        {
            if (enableLogging != null && enableLogging.val)
            {
                SuperController.LogMessage(message);
            }
        }

        public void OnDisable()
        {
            Log("Plugin Reloader: OnDisable called");
        }

        public void OnDestroy()
        {
            Log("Plugin Reloader: OnDestroy called");

            RemoveToggle(enableLogging);
            RemovePopup(atomChooser);
            RemovePopup(pluginChooser);
            RemovePopup(reloadHotkey);
            RemoveSlider(triggerDelay1);
            RemoveSlider(triggerDelay2);
            RemoveSlider(triggerDelay3);

            OnDisable();
        }
    }

    public class EventTriggerWithCallback : EventTrigger
    {
        public Action Callback;

        public EventTriggerWithCallback(MVRScript owner, string name, string secondary = null)
            : base(owner, name, secondary) { }

        public new void Trigger()
        {
            base.Trigger();
            Callback?.Invoke();
        }
    }


}