using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using MCPForUnity.Editor.Helpers;
using MCPForUnity.Runtime.Helpers;
using Newtonsoft.Json.Linq;
using UnityEditor;
using UnityEngine;
using UnityEngine.UIElements;

namespace MCPForUnity.Editor.Tools
{
    [McpForUnityTool("manage_ui", AutoRegister = false, Group = "ui")]
    public static class ManageUI
    {
        private static readonly HashSet<string> ValidExtensions = new(StringComparer.OrdinalIgnoreCase)
        {
            ".uxml", ".uss"
        };

        // UTF-8 without BOM — UI Builder in Unity 6 can fail to open UXML files with a BOM.
        private static readonly Encoding Utf8NoBom = new UTF8Encoding(false);

        static ManageUI()
        {
            EditorApplication.quitting += CleanupRenderTextures;
            AssemblyReloadEvents.beforeAssemblyReload += CleanupRenderTextures;
        }

        private static void CleanupRenderTextures()
        {
            foreach (var kvp in s_panelRTs)
            {
                if (kvp.Value == null) continue;
                string assetPath = AssetDatabase.GetAssetPath(kvp.Value);
                kvp.Value.Release();
                if (!string.IsNullOrEmpty(assetPath))
                    AssetDatabase.DeleteAsset(assetPath);
                else
                    UnityEngine.Object.DestroyImmediate(kvp.Value);
            }
            s_panelRTs.Clear();
        }

        public static object HandleCommand(JObject @params)
        {
            string action = @params["action"]?.ToString()?.ToLowerInvariant();
            if (string.IsNullOrEmpty(action))
            {
                return new ErrorResponse("Action is required");
            }

            try
            {
                switch (action)
                {
                    case "ping":
                        return new SuccessResponse("pong", new { tool = "manage_ui" });

                    case "create":
                        return CreateFile(@params);

                    case "read":
                        return ReadFile(@params);

                    case "update":
                        return UpdateFile(@params);

                    case "attach_ui_document":
                        return AttachUIDocument(@params);

                    case "create_panel_settings":
                        return CreatePanelSettings(@params);

                    case "update_panel_settings":
                        return UpdatePanelSettings(@params);

                    case "get_visual_tree":
                        return GetVisualTree(@params);

                    case "render_ui":
                        return RenderUI(@params);

                    case "link_stylesheet":
                        return LinkStylesheet(@params);

                    case "delete":
                        return DeleteFile(@params);

                    case "list":
                        return ListUIAssets(@params);

                    case "detach_ui_document":
                        return DetachUIDocument(@params);

                    case "modify_visual_element":
                        return ModifyVisualElement(@params);

                    default:
                        return new ErrorResponse($"Unknown action: {action}");
                }
            }
            catch (Exception ex)
            {
                return new ErrorResponse(ex.Message, new { stackTrace = ex.StackTrace });
            }
        }

        private static string ValidatePath(string path, out string error)
        {
            error = null;
            if (string.IsNullOrEmpty(path))
            {
                error = "'path' parameter is required.";
                return null;
            }

            path = AssetPathUtility.SanitizeAssetPath(path);
            if (path == null)
            {
                error = "Invalid path: contains traversal sequences.";
                return null;
            }

            string ext = Path.GetExtension(path);
            if (!ValidExtensions.Contains(ext))
            {
                error = $"Invalid file extension '{ext}'. Must be .uxml or .uss.";
                return null;
            }

            return path;
        }

        private static object CreateFile(JObject @params)
        {
            var p = new ToolParams(@params);
            string path = ValidatePath(p.Get("path"), out string pathError);
            if (pathError != null) return new ErrorResponse(pathError);

            string contents;
            try
            {
                contents = GetDecodedContents(p);
            }
            catch (ArgumentException ex)
            {
                return new ErrorResponse(ex.Message);
            }

            if (contents == null)
            {
                return new ErrorResponse("'contents' parameter is required for create.");
            }

            string fullPath = Path.Combine(Application.dataPath,
                path.Substring("Assets/".Length));
            fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);

            if (File.Exists(fullPath))
            {
                return new ErrorResponse($"File already exists at {path}. Use 'update' action to overwrite.");
            }

            string dir = Path.GetDirectoryName(fullPath);
            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            bool isUxml = path.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase);
            var validationWarnings = new List<string>();

            if (isUxml)
            {
                string xmlError = ValidateUxmlContent(contents, validationWarnings);
                if (xmlError != null)
                {
                    return new ErrorResponse($"UXML validation failed — file was NOT written. {xmlError}");
                }
                contents = EnsureEditorExtensionMode(contents);
            }

            File.WriteAllText(fullPath, contents, Utf8NoBom);
            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);

            if (isUxml)
            {
                ValidateUxmlPostImport(path, validationWarnings);
            }

            string ext = Path.GetExtension(path).TrimStart('.');
            if (validationWarnings.Count > 0)
            {
                return new SuccessResponse(
                    $"Created {ext} file at {path} with {validationWarnings.Count} warning(s)",
                    new { path, validationWarnings });
            }

            return new SuccessResponse($"Created {ext} file at {path}",
                new { path });
        }

        private static object ReadFile(JObject @params)
        {
            var p = new ToolParams(@params);
            string path = ValidatePath(p.Get("path"), out string pathError);
            if (pathError != null) return new ErrorResponse(pathError);

            string fullPath = Path.Combine(Application.dataPath,
                path.Substring("Assets/".Length));
            fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);

            if (!File.Exists(fullPath))
            {
                return new ErrorResponse($"File not found: {path}");
            }

            string contents = File.ReadAllText(fullPath, Encoding.UTF8);
            string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(contents));

            return new SuccessResponse($"Read {Path.GetExtension(path).TrimStart('.')} file at {path}",
                new
                {
                    path,
                    contents,
                    encodedContents = encoded,
                    contentsEncoded = true,
                    lengthBytes = Encoding.UTF8.GetByteCount(contents)
                });
        }

        private static object UpdateFile(JObject @params)
        {
            var p = new ToolParams(@params);
            string path = ValidatePath(p.Get("path"), out string pathError);
            if (pathError != null) return new ErrorResponse(pathError);

            string contents;
            try
            {
                contents = GetDecodedContents(p);
            }
            catch (ArgumentException ex)
            {
                return new ErrorResponse(ex.Message);
            }

            if (contents == null)
            {
                return new ErrorResponse("'contents' parameter is required for update.");
            }

            string fullPath = Path.Combine(Application.dataPath,
                path.Substring("Assets/".Length));
            fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);

            if (!File.Exists(fullPath))
            {
                return new ErrorResponse($"File not found: {path}. Use 'create' action for new files.");
            }

            bool isUxml = path.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase);
            var validationWarnings = new List<string>();

            if (isUxml)
            {
                string xmlError = ValidateUxmlContent(contents, validationWarnings);
                if (xmlError != null)
                {
                    return new ErrorResponse($"UXML validation failed — file was NOT updated. {xmlError}");
                }
                contents = EnsureEditorExtensionMode(contents);
            }

            File.WriteAllText(fullPath, contents, Utf8NoBom);
            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);

            if (isUxml)
            {
                ValidateUxmlPostImport(path, validationWarnings);
            }

            string ext = Path.GetExtension(path).TrimStart('.');
            if (validationWarnings.Count > 0)
            {
                return new SuccessResponse(
                    $"Updated {ext} file at {path} with {validationWarnings.Count} warning(s)",
                    new { path, validationWarnings });
            }

            return new SuccessResponse($"Updated {ext} file at {path}",
                new { path });
        }

        private static object AttachUIDocument(JObject @params)
        {
            var p = new ToolParams(@params);

            var targetResult = p.GetRequired("target");
            var targetError = targetResult.GetOrError(out string target);
            if (targetError != null) return targetError;

            var sourceResult = p.GetRequired("source_asset");
            var sourceError = sourceResult.GetOrError(out string sourceAssetPath);
            if (sourceError != null) return sourceError;

            sourceAssetPath = AssetPathUtility.SanitizeAssetPath(sourceAssetPath);
            if (sourceAssetPath == null)
            {
                return new ErrorResponse("Invalid source_asset path.");
            }

            // Find the GameObject
            var goInstruction = new JObject { ["find"] = target };
            GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
            if (go == null)
            {
                return new ErrorResponse($"Could not find target GameObject: {target}");
            }

            // Load the VisualTreeAsset
            var vta = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(sourceAssetPath);
            if (vta == null)
            {
                return new ErrorResponse($"Could not load VisualTreeAsset at: {sourceAssetPath}");
            }

            // Load or create PanelSettings
            string panelSettingsPath = p.Get("panel_settings") ?? p.Get("panelSettings");
            PanelSettings panelSettings = null;

            if (!string.IsNullOrEmpty(panelSettingsPath))
            {
                panelSettingsPath = AssetPathUtility.SanitizeAssetPath(panelSettingsPath);
                if (panelSettingsPath != null)
                {
                    panelSettings = AssetDatabase.LoadAssetAtPath<PanelSettings>(panelSettingsPath);
                }
                if (panelSettings == null)
                {
                    return new ErrorResponse($"Could not load PanelSettings at: {panelSettingsPath}");
                }
            }
            else
            {
                // Find existing or create default PanelSettings
                string[] guids = AssetDatabase.FindAssets("t:PanelSettings");
                if (guids.Length > 0)
                {
                    string existingPath = AssetDatabase.GUIDToAssetPath(guids[0]);
                    panelSettings = AssetDatabase.LoadAssetAtPath<PanelSettings>(existingPath);
                }

                if (panelSettings == null)
                {
                    panelSettings = CreateDefaultPanelSettings("Assets/UI/DefaultPanelSettings.asset");
                    if (panelSettings == null)
                    {
                        return new ErrorResponse("Failed to create default PanelSettings.");
                    }
                }
            }

            Undo.RecordObject(go, "Attach UIDocument");

            // Add or get UIDocument component
            var uiDoc = go.GetComponent<UIDocument>();
            if (uiDoc == null)
            {
                uiDoc = Undo.AddComponent<UIDocument>(go);
            }

            uiDoc.visualTreeAsset = vta;
            uiDoc.panelSettings = panelSettings;

            int sortOrder = p.GetInt("sort_order") ?? 0;
            uiDoc.sortingOrder = sortOrder;

            EditorUtility.SetDirty(go);

            return new SuccessResponse($"Attached UIDocument to {go.name}",
                new
                {
                    gameObject = go.name,
                    sourceAsset = sourceAssetPath,
                    panelSettings = AssetDatabase.GetAssetPath(panelSettings),
                    sortOrder
                });
        }

        private static object CreatePanelSettings(JObject @params)
        {
            var p = new ToolParams(@params);

            var pathResult = p.GetRequired("path");
            var pathError = pathResult.GetOrError(out string path);
            if (pathError != null) return pathError;

            path = AssetPathUtility.SanitizeAssetPath(path);
            if (path == null)
            {
                return new ErrorResponse("Invalid path: contains traversal sequences.");
            }

            if (!path.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
            {
                path += ".asset";
            }

            if (AssetDatabase.LoadAssetAtPath<PanelSettings>(path) != null)
            {
                return new ErrorResponse($"PanelSettings already exists at {path}");
            }

            var ps = CreateDefaultPanelSettings(path);
            if (ps == null)
            {
                return new ErrorResponse("Failed to create PanelSettings asset.");
            }

            // Apply any settings passed as a flat dict
            JToken settingsToken = p.GetRaw("settings");
            var changes = new List<string>();
            if (settingsToken is JObject settingsObj)
            {
                ApplyPanelSettingsProperties(ps, settingsObj, changes);
            }
            else
            {
                // Legacy: support top-level scale_mode / reference_resolution
                string scaleMode = p.Get("scale_mode");
                if (!string.IsNullOrEmpty(scaleMode))
                {
                    if (Enum.TryParse<PanelScaleMode>(scaleMode, true, out var mode))
                    {
                        ps.scaleMode = mode;
                        changes.Add("scaleMode");
                    }
                }

                JToken refResToken = p.GetRaw("reference_resolution");
                if (refResToken is JObject refRes)
                {
                    int w = refRes["width"]?.ToObject<int>() ?? 1920;
                    int h = refRes["height"]?.ToObject<int>() ?? 1080;
                    ps.referenceResolution = new Vector2Int(w, h);
                    changes.Add("referenceResolution");
                }
            }

            EditorUtility.SetDirty(ps);
            AssetDatabase.SaveAssets();

            return new SuccessResponse($"Created PanelSettings at {path}",
                new { path, applied = changes });
        }

        private static object UpdatePanelSettings(JObject @params)
        {
            var p = new ToolParams(@params);

            var pathResult = p.GetRequired("path");
            var pathError = pathResult.GetOrError(out string path);
            if (pathError != null) return pathError;

            path = AssetPathUtility.SanitizeAssetPath(path);
            if (path == null)
                return new ErrorResponse("Invalid path: contains traversal sequences.");

            if (!path.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
                path += ".asset";

            var ps = AssetDatabase.LoadAssetAtPath<PanelSettings>(path);
            if (ps == null)
                return new ErrorResponse($"No PanelSettings found at {path}");

            JToken settingsToken = p.GetRaw("settings");
            if (settingsToken is not JObject settingsObj || settingsObj.Count == 0)
                return new ErrorResponse("'settings' dict is required with at least one property to update.");

            var changes = new List<string>();
            ApplyPanelSettingsProperties(ps, settingsObj, changes);

            if (changes.Count == 0)
                return new ErrorResponse("No recognised properties were applied. Check the key names.");

            EditorUtility.SetDirty(ps);
            AssetDatabase.SaveAssets();

            return new SuccessResponse($"Updated PanelSettings at {path}",
                new { path, applied = changes });
        }

        private static PanelSettings CreateDefaultPanelSettings(string path)
        {
            string dir = Path.GetDirectoryName(path);
            if (!string.IsNullOrEmpty(dir))
            {
                EnsureFolderExists(dir);
            }

            var ps = ScriptableObject.CreateInstance<PanelSettings>();
            AssetDatabase.CreateAsset(ps, path);
            AssetDatabase.SaveAssets();
            return ps;
        }

        /// <summary>
        /// Generic, data-driven applicator for PanelSettings properties.
        /// Accepts a flat JObject where each key maps to a PanelSettings property.
        /// Recognised keys (case-insensitive matching via snake_case/camelCase):
        ///   scaleMode, referenceResolution, screenMatchMode, match,
        ///   referenceDpi, fallbackDpi, sortingOrder, targetDisplay,
        ///   clearColor, colorClearValue, clearDepthStencil,
        ///   themeStyleSheet, dynamicAtlasSettings.
        /// </summary>
        private static void ApplyPanelSettingsProperties(PanelSettings ps, JObject settings, List<string> changes)
        {
            foreach (var prop in settings)
            {
                string key = NormalizeKey(prop.Key);
                JToken val = prop.Value;

                switch (key)
                {
                    // ── Enum properties ─────────────────────────────────────
                    case "scalemode":
                        if (TryParseEnum<PanelScaleMode>(val, out var sm)) { ps.scaleMode = sm; changes.Add("scaleMode"); }
                        break;

                    case "screenmatchmode":
                        if (TryParseEnum<PanelScreenMatchMode>(val, out var smm)) { ps.screenMatchMode = smm; changes.Add("screenMatchMode"); }
                        break;

                    // ── Numeric properties ──────────────────────────────────
                    case "match":
                        if (TryFloat(val, out float matchVal)) { ps.match = Mathf.Clamp01(matchVal); changes.Add("match"); }
                        break;

                    case "referencedpi":
                        if (TryFloat(val, out float refDpi)) { ps.referenceDpi = refDpi; changes.Add("referenceDpi"); }
                        break;

                    case "fallbackdpi":
                        if (TryFloat(val, out float fbDpi)) { ps.fallbackDpi = fbDpi; changes.Add("fallbackDpi"); }
                        break;

                    case "sortingorder":
                        if (TryInt(val, out int so)) { ps.sortingOrder = so; changes.Add("sortingOrder"); }
                        break;

                    case "targetdisplay":
                        if (TryInt(val, out int td)) { ps.targetDisplay = td; changes.Add("targetDisplay"); }
                        break;

                    // ── Bool properties ──────────────────────────────────────
                    case "clearcolor":
                        ps.clearColor = ParamCoercion.CoerceBool(val, false);
                        changes.Add("clearColor");
                        break;

                    case "cleardepthstencil":
                        ps.clearDepthStencil = ParamCoercion.CoerceBool(val, false);
                        changes.Add("clearDepthStencil");
                        break;

                    // ── Composite properties ────────────────────────────────
                    case "referenceresolution":
                        if (val is JObject resObj)
                        {
                            int w = resObj["width"]?.ToObject<int>() ?? ps.referenceResolution.x;
                            int h = resObj["height"]?.ToObject<int>() ?? ps.referenceResolution.y;
                            ps.referenceResolution = new Vector2Int(w, h);
                            changes.Add("referenceResolution");
                        }
                        break;

                    case "colorclearvalue":
                        if (TryParseColor(val, out Color clr)) { ps.colorClearValue = clr; changes.Add("colorClearValue"); }
                        break;

                    case "dynamicatlassettings":
                        if (val is JObject daObj) { ApplyDynamicAtlasSettings(ps, daObj, changes); }
                        break;

                    // ── Asset reference properties ──────────────────────────
                    case "themestylesheet":
                    {
                        string tsPath = val?.ToString();
                        if (!string.IsNullOrEmpty(tsPath))
                        {
                            var ts = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(tsPath);
                            if (ts != null) { ps.themeStyleSheet = ts; changes.Add("themeStyleSheet"); }
                        }
                        break;
                    }

                    // unknown keys are silently ignored
                }
            }
        }

        private static void ApplyDynamicAtlasSettings(PanelSettings ps, JObject da, List<string> changes)
        {
            var daCopy = ps.dynamicAtlasSettings;

            if (da["minAtlasSize"] != null && TryInt(da["minAtlasSize"], out int minSize))
                daCopy.minAtlasSize = minSize;
            if (da["maxAtlasSize"] != null && TryInt(da["maxAtlasSize"], out int maxSize))
                daCopy.maxAtlasSize = maxSize;
            if (da["maxSubTextureSize"] != null && TryInt(da["maxSubTextureSize"], out int maxSub))
                daCopy.maxSubTextureSize = maxSub;
            if (da["activeFilters"] != null && TryParseEnum<DynamicAtlasFilters>(da["activeFilters"], out var af))
                daCopy.activeFilters = af;

            ps.dynamicAtlasSettings = daCopy;
            changes.Add("dynamicAtlasSettings");
        }

        // ── Tiny helpers to keep the switch compact ─────────────────────────

        private static string NormalizeKey(string key)
        {
            // Strip underscores and lowercase so "scale_mode", "scaleMode", "ScaleMode"
            // all match the same case label.
            return key.Replace("_", "").ToLowerInvariant();
        }

        private static bool TryParseEnum<T>(JToken token, out T result) where T : struct, Enum
        {
            result = default;
            string s = token?.ToString();
            return !string.IsNullOrEmpty(s) && Enum.TryParse(s, true, out result);
        }

        private static bool TryFloat(JToken token, out float result)
        {
            result = 0f;
            if (token == null) return false;
            if (token.Type == JTokenType.Float || token.Type == JTokenType.Integer)
            {
                result = token.ToObject<float>();
                return true;
            }
            return float.TryParse(token.ToString(), out result);
        }

        private static bool TryInt(JToken token, out int result)
        {
            result = 0;
            if (token == null) return false;
            if (token.Type == JTokenType.Integer)
            {
                result = token.ToObject<int>();
                return true;
            }
            return int.TryParse(token.ToString(), out result);
        }

        private static bool TryParseColor(JToken token, out Color color)
        {
            color = Color.clear;
            if (token == null) return false;

            // Accept "#RRGGBB", "#RRGGBBAA", or {r,g,b,a} object
            if (token.Type == JTokenType.String)
            {
                return ColorUtility.TryParseHtmlString(token.ToString(), out color);
            }

            if (token is JObject cObj)
            {
                color = new Color(
                    cObj["r"]?.ToObject<float>() ?? 0f,
                    cObj["g"]?.ToObject<float>() ?? 0f,
                    cObj["b"]?.ToObject<float>() ?? 0f,
                    cObj["a"]?.ToObject<float>() ?? 1f
                );
                return true;
            }

            return false;
        }

        private static void EnsureFolderExists(string assetFolderPath)
        {
            if (AssetDatabase.IsValidFolder(assetFolderPath))
                return;

            string[] parts = assetFolderPath.Replace('\\', '/').Split('/');
            string current = parts[0]; // "Assets"
            for (int i = 1; i < parts.Length; i++)
            {
                string next = current + "/" + parts[i];
                if (!AssetDatabase.IsValidFolder(next))
                {
                    AssetDatabase.CreateFolder(current, parts[i]);
                }
                current = next;
            }
        }

        private static object GetVisualTree(JObject @params)
        {
            var p = new ToolParams(@params);

            var targetResult = p.GetRequired("target");
            var targetError = targetResult.GetOrError(out string target);
            if (targetError != null) return targetError;

            int maxDepth = p.GetInt("max_depth") ?? 10;

            var goInstruction = new JObject { ["find"] = target };
            GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
            if (go == null)
            {
                return new ErrorResponse($"Could not find target GameObject: {target}");
            }

            var uiDoc = go.GetComponent<UIDocument>();
            if (uiDoc == null)
            {
                return new ErrorResponse($"GameObject {go.name} has no UIDocument component.");
            }

            var root = uiDoc.rootVisualElement;
            if (root == null)
            {
                return new SuccessResponse($"UIDocument on {go.name} has no visual tree (not yet built).",
                    new
                    {
                        gameObject = go.name,
                        sourceAsset = uiDoc.visualTreeAsset != null
                            ? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
                            : null,
                        tree = (object)null
                    });
            }

            var tree = SerializeVisualElement(root, 0, maxDepth);

            return new SuccessResponse($"Visual tree for UIDocument on {go.name}",
                new
                {
                    gameObject = go.name,
                    sourceAsset = uiDoc.visualTreeAsset != null
                        ? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
                        : null,
                    tree
                });
        }

        private static object SerializeVisualElement(VisualElement element, int depth, int maxDepth)
        {
            var result = new Dictionary<string, object>
            {
                ["type"] = element.GetType().Name,
                ["name"] = element.name ?? "",
                ["classes"] = new List<string>(element.GetClasses()),
            };

            // Include basic computed style info
            var style = new Dictionary<string, object>();
            var resolved = element.resolvedStyle;

            if (resolved.width > 0) style["width"] = resolved.width;
            if (resolved.height > 0) style["height"] = resolved.height;
            if (resolved.color != Color.clear)
                style["color"] = ColorToHex(resolved.color);
            if (resolved.backgroundColor != Color.clear)
                style["backgroundColor"] = ColorToHex(resolved.backgroundColor);
            if (resolved.fontSize > 0) style["fontSize"] = resolved.fontSize;

            if (style.Count > 0)
                result["resolvedStyle"] = style;

            // Include text content for labels/buttons
            if (element is TextElement textEl && !string.IsNullOrEmpty(textEl.text))
            {
                result["text"] = textEl.text;
            }

            // Serialize children
            if (depth < maxDepth && element.childCount > 0)
            {
                var children = new List<object>();
                foreach (var child in element.Children())
                {
                    children.Add(SerializeVisualElement(child, depth + 1, maxDepth));
                }
                result["children"] = children;
            }
            else if (element.childCount > 0)
            {
                result["childCount"] = element.childCount;
                result["truncated"] = true;
            }

            return result;
        }

        // ---- Render UI ----

        // Persistent RenderTextures keyed by PanelSettings instance ID so the panel
        // renders into them automatically every frame.
        private static readonly Dictionary<int, RenderTexture> s_panelRTs = new();

        // Play-mode coroutine capture state.  Only one capture is in-flight at a
        // time; concurrent render_ui calls while a capture is pending are rejected
        // with an explicit error.
        private static Texture2D s_pendingCaptureTex;
        private static bool s_pendingCaptureDone;
        private static bool s_pendingCaptureStarted;

        private static object RenderUI(JObject @params)
        {
            var p = new ToolParams(@params);

            string target = p.Get("target");
            string uxmlPath = p.Get("path");
            int width = p.GetInt("width") ?? 1920;
            int height = p.GetInt("height") ?? 1080;
            bool includeImage = p.GetBool("include_image") || p.GetBool("includeImage");
            int maxResolution = p.GetInt("max_resolution") ?? p.GetInt("maxResolution") ?? 640;
            string fileName = p.Get("file_name") ?? p.Get("fileName");
            string outputFolderOverride = p.Get("output_folder") ?? p.Get("outputFolder");

            if (string.IsNullOrEmpty(target) && string.IsNullOrEmpty(uxmlPath))
            {
                return new ErrorResponse("Either 'target' (GameObject with UIDocument) or 'path' (UXML asset path) is required.");
            }

            string resolvedFolderSpec = ScreenshotPreferences.Resolve(outputFolderOverride);
            string resolvedFolderAbs;
            try
            {
                resolvedFolderAbs = ScreenshotUtility.ResolveFolderAbsolute(resolvedFolderSpec);
            }
            catch (InvalidOperationException ex)
            {
                return new ErrorResponse(ex.Message);
            }

            // ── Play-mode capture via ScreenCapture coroutine ──────────────────────
            // PanelSettings.targetTexture is read in the same frame it is assigned,
            // so the RT is always blank in a synchronous tool call.  In play mode we
            // dispatch a WaitForEndOfFrame coroutine that uses ScreenCapture, which
            // captures the fully-composited game view (including UI Toolkit overlays).
            // First call: queues the capture and returns "pending".
            // Second call: result is ready – save PNG and return data.
            if (Application.isPlaying)
            {
                // Build the output paths (used by both the pending and ready branches)
                string resolvedPlayName = string.IsNullOrWhiteSpace(fileName)
                    ? $"ui-render-{DateTime.Now:yyyyMMdd-HHmmss}.png"
                    : fileName.Trim();
                if (!resolvedPlayName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
                    resolvedPlayName += ".png";

                Directory.CreateDirectory(resolvedFolderAbs);
                string playFullPath = Path.Combine(resolvedFolderAbs, resolvedPlayName).Replace('\\', '/');
                playFullPath = EnsureUniqueFilePath(playFullPath);
                string playProjectRelPath = ScreenshotUtility.ToProjectRelativePath(playFullPath);

                // ── Case 1: capture is ready ──────────────────────────────────────
                if (s_pendingCaptureDone && s_pendingCaptureTex != null)
                {
                    var captureTex = s_pendingCaptureTex;
                    s_pendingCaptureDone = false;
                    s_pendingCaptureTex = null;

                    int captureW = captureTex.width;
                    int captureH = captureTex.height;
                    byte[] capturePng = captureTex.EncodeToPNG();
                    UnityEngine.Object.DestroyImmediate(captureTex);

                    File.WriteAllBytes(playFullPath, capturePng);
                    if (ScreenshotUtility.IsUnderAssets(playProjectRelPath))
                        AssetDatabase.ImportAsset(playProjectRelPath, ImportAssetOptions.ForceSynchronousImport);

                    var playData = new Dictionary<string, object>
                    {
                        { "path", playProjectRelPath },
                        { "fullPath", playFullPath },
                        { "width", captureW },
                        { "height", captureH },
                        { "hasContent", true },
                    };

                    if (!string.IsNullOrEmpty(target)) playData["gameObject"] = target;
                    if (!string.IsNullOrEmpty(uxmlPath)) playData["sourceAsset"] = uxmlPath;

                    if (includeImage)
                    {
                        int targetMax = maxResolution > 0 ? maxResolution : 640;
                        Texture2D downscaled = null;
                        try
                        {
                            var fullTex = new Texture2D(captureW, captureH, TextureFormat.RGBA32, false);
                            fullTex.LoadImage(capturePng);
                            if (captureW > targetMax || captureH > targetMax)
                            {
                                downscaled = ScreenshotUtility.DownscaleTexture(fullTex, targetMax);
                                playData["imageBase64"] = Convert.ToBase64String(downscaled.EncodeToPNG());
                                playData["imageWidth"] = downscaled.width;
                                playData["imageHeight"] = downscaled.height;
                            }
                            else
                            {
                                playData["imageBase64"] = Convert.ToBase64String(capturePng);
                                playData["imageWidth"] = captureW;
                                playData["imageHeight"] = captureH;
                            }
                            UnityEngine.Object.DestroyImmediate(fullTex);
                        }
                        finally
                        {
                            if (downscaled != null) UnityEngine.Object.DestroyImmediate(downscaled);
                        }
                    }

                    return new SuccessResponse($"UI render saved to '{playProjectRelPath}'.", playData);
                }

                // ── Case 2: start a new capture ───────────────────────────────────
                // Only one capture in flight at a time.  If one is already pending,
                // reject rather than silently overwriting the state.
                if (s_pendingCaptureStarted)
                {
                    return new ErrorResponse(
                        "Cannot capture: another capture is already in progress.",
                        new { retry_after_ms = 100, reason = "capture_in_progress" });
                }

                s_pendingCaptureDone = false;
                s_pendingCaptureTex = null;
                s_pendingCaptureStarted = true;
                ScreenshotCapturer.Begin(1, tex =>
                {
                    s_pendingCaptureTex = tex;
                    s_pendingCaptureDone = true;
                    s_pendingCaptureStarted = false;
                });

                return new SuccessResponse(
                    "Play-mode screenshot capture queued (WaitForEndOfFrame). Call render_ui again to retrieve the rendered image.",
                    new Dictionary<string, object>
                    {
                        { "pending", true },
                        { "gameObject", (object)target ?? uxmlPath },
                        { "note", "A screen capture was scheduled for the end of this frame. Call render_ui once more to get the result." }
                    });
            }
            // ── End play-mode branch ────────────────────────────────────────────────

            // Resolve UIDocument
            UIDocument uiDoc = null;
            GameObject tempGo = null;
            PanelSettings tempPs = null;

            try
            {
                if (!string.IsNullOrEmpty(target))
                {
                    var goInstruction = new JObject { ["find"] = target };
                    GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
                    if (go == null)
                        return new ErrorResponse($"Could not find target GameObject: {target}");

                    uiDoc = go.GetComponent<UIDocument>();
                    if (uiDoc == null)
                        return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
                }
                else
                {
                    uxmlPath = AssetPathUtility.SanitizeAssetPath(uxmlPath);
                    if (uxmlPath == null)
                        return new ErrorResponse("Invalid UXML path.");

                    var vta = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxmlPath);
                    if (vta == null)
                        return new ErrorResponse($"Could not load VisualTreeAsset at: {uxmlPath}");

                    tempGo = new GameObject("__MCP_UI_Render_Temp__");
                    tempGo.hideFlags = HideFlags.HideAndDontSave;
                    uiDoc = tempGo.AddComponent<UIDocument>();

                    string[] guids = AssetDatabase.FindAssets("t:PanelSettings");
                    PanelSettings ps = null;
                    if (guids.Length > 0)
                        ps = AssetDatabase.LoadAssetAtPath<PanelSettings>(AssetDatabase.GUIDToAssetPath(guids[0]));
                    if (ps == null)
                    {
                        ps = CreateDefaultPanelSettings("Assets/UI/DefaultPanelSettings.asset");
                        tempPs = ps;
                    }

                    uiDoc.panelSettings = ps;
                    uiDoc.visualTreeAsset = vta;
                }

                if (uiDoc.panelSettings == null)
                    return new ErrorResponse("UIDocument has no PanelSettings assigned.");

                var panelSettings = uiDoc.panelSettings;
                int psId = panelSettings.GetInstanceIDCompat();

                // Check if we already have a persistent RT assigned to this PanelSettings.
                // If the RT exists and its size matches, the panel has been rendering into it.
                // If not, create one and assign it — content will be available on the next call.
                // Look up from our cache rather than panelSettings.targetTexture,
                // because we set targetTexture = null after each successful read
                // to restore on-screen rendering.  The RT itself stays alive in s_panelRTs.
                bool rtJustAssigned = false;
                RenderTexture rt = null;

                if (s_panelRTs.TryGetValue(psId, out var cachedRt) && cachedRt != null)
                {
                    if (cachedRt.width == width && cachedRt.height == height)
                    {
                        rt = cachedRt;
                        // Re-attach if it was detached after the previous read
                        if (panelSettings.targetTexture != rt)
                        {
                            panelSettings.targetTexture = rt;
                            rtJustAssigned = true;

                            uiDoc.rootVisualElement?.MarkDirtyRepaint();
                            EditorUtility.SetDirty(panelSettings);
                            UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
                            Canvas.ForceUpdateCanvases();
                        }
                    }
                    else
                    {
                        // Size changed — release the old RT
                        panelSettings.targetTexture = null;
                        string oldPath = AssetDatabase.GetAssetPath(cachedRt);
                        cachedRt.Release();
                        if (!string.IsNullOrEmpty(oldPath))
                            AssetDatabase.DeleteAsset(oldPath);
                        else
                            UnityEngine.Object.DestroyImmediate(cachedRt);
                        s_panelRTs.Remove(psId);
                    }
                }

                if (rt == null)
                {
                    // Create RT as an asset so PanelSettings can serialize the reference properly
                    rt = new RenderTexture(width, height, 32, RenderTextureFormat.ARGB32);
                    rt.name = $"MCP_UI_Render_{psId}";
                    rt.Create();

                    string rtFolder = "Assets/UI";
                    if (!AssetDatabase.IsValidFolder(rtFolder))
                        AssetDatabase.CreateFolder("Assets", "UI");
                    string rtAssetPath = $"{rtFolder}/RT_MCP_UI_Render_{psId}.renderTexture";
                    AssetDatabase.CreateAsset(rt, rtAssetPath);
                    AssetDatabase.SaveAssets();

                    panelSettings.targetTexture = rt;
                    s_panelRTs[psId] = rt;
                    rtJustAssigned = true;

                    // Mark dirty and force editor repaint so the panel renders into the RT
                    uiDoc.rootVisualElement?.MarkDirtyRepaint();
                    EditorUtility.SetDirty(panelSettings);
                    UnityEditorInternal.InternalEditorUtility.RepaintAllViews();

                    // Force a synchronous layout + repaint pass
                    Canvas.ForceUpdateCanvases();
                }

                // Read pixels from the RT
                RenderTexture prevActive = RenderTexture.active;
                RenderTexture.active = rt;
                var tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
                tex.ReadPixels(new Rect(0, 0, width, height), 0, 0);
                tex.Apply();
                RenderTexture.active = prevActive;

                // Restore targetTexture to null so the UI renders back to the
                // actual display / camera.  The RT stays cached in s_panelRTs
                // and will be re-attached on the next render_ui call.
                if (!rtJustAssigned)
                {
                    panelSettings.targetTexture = null;
                    EditorUtility.SetDirty(panelSettings);
                }

                // Check if any content was rendered
                bool hasContent = false;
                var pixels = tex.GetPixels32();
                for (int i = 0; i < pixels.Length; i += Mathf.Max(1, pixels.Length / 100))
                {
                    if (pixels[i].a > 0) { hasContent = true; break; }
                }

                // Save to Screenshots folder
                string resolvedName = string.IsNullOrWhiteSpace(fileName)
                    ? $"ui-render-{DateTime.Now:yyyyMMdd-HHmmss}.png"
                    : fileName.Trim();
                if (!resolvedName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
                    resolvedName += ".png";

                Directory.CreateDirectory(resolvedFolderAbs);
                string fullPath = Path.Combine(resolvedFolderAbs, resolvedName).Replace('\\', '/');
                fullPath = EnsureUniqueFilePath(fullPath);

                byte[] png = tex.EncodeToPNG();
                File.WriteAllBytes(fullPath, png);

                string projectRelPath = ScreenshotUtility.ToProjectRelativePath(fullPath);
                if (ScreenshotUtility.IsUnderAssets(projectRelPath))
                    AssetDatabase.ImportAsset(projectRelPath, ImportAssetOptions.ForceSynchronousImport);

                var data = new Dictionary<string, object>
                {
                    { "path", projectRelPath },
                    { "fullPath", fullPath },
                    { "width", width },
                    { "height", height },
                    { "hasContent", hasContent },
                };

                if (rtJustAssigned)
                    data["note"] = "RenderTexture was just assigned to PanelSettings. Call render_ui again to capture the rendered UI.";

                if (!string.IsNullOrEmpty(target))
                    data["gameObject"] = target;
                if (!string.IsNullOrEmpty(uxmlPath))
                    data["sourceAsset"] = uxmlPath;

                if (includeImage)
                {
                    int targetMax = maxResolution > 0 ? maxResolution : 640;
                    Texture2D downscaled = null;
                    try
                    {
                        if (width > targetMax || height > targetMax)
                        {
                            downscaled = ScreenshotUtility.DownscaleTexture(tex, targetMax);
                            data["imageBase64"] = Convert.ToBase64String(downscaled.EncodeToPNG());
                            data["imageWidth"] = downscaled.width;
                            data["imageHeight"] = downscaled.height;
                        }
                        else
                        {
                            data["imageBase64"] = Convert.ToBase64String(png);
                            data["imageWidth"] = width;
                            data["imageHeight"] = height;
                        }
                    }
                    finally
                    {
                        if (downscaled != null) UnityEngine.Object.DestroyImmediate(downscaled);
                    }
                }

                UnityEngine.Object.DestroyImmediate(tex);

                string msg = hasContent
                    ? $"UI rendered to '{projectRelPath}'."
                    : rtJustAssigned
                        ? $"RenderTexture assigned to PanelSettings. Call render_ui again to capture the rendered content."
                        : $"UI render saved to '{projectRelPath}' (no visible content detected).";

                return new SuccessResponse(msg, data);
            }
            finally
            {
                if (tempGo != null) UnityEngine.Object.DestroyImmediate(tempGo);
                if (tempPs != null)
                {
                    string tempPsPath = AssetDatabase.GetAssetPath(tempPs);
                    if (!string.IsNullOrEmpty(tempPsPath))
                        AssetDatabase.DeleteAsset(tempPsPath);
                    else
                        UnityEngine.Object.DestroyImmediate(tempPs, true);
                }
            }
        }

        // ---- Link Stylesheet ----

        private static object LinkStylesheet(JObject @params)
        {
            var p = new ToolParams(@params);

            string uxmlPathRaw = p.Get("path");
            string uxmlPath = ValidatePath(uxmlPathRaw, out string pathError);
            if (pathError != null) return new ErrorResponse(pathError);

            // Validate the UXML path is actually a .uxml
            if (!uxmlPath.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase))
                return new ErrorResponse("'path' must point to a .uxml file.");

            string stylesheetPath = p.Get("stylesheet");
            if (string.IsNullOrEmpty(stylesheetPath))
                return new ErrorResponse("'stylesheet' parameter is required.");

            stylesheetPath = AssetPathUtility.SanitizeAssetPath(stylesheetPath);
            if (stylesheetPath == null)
                return new ErrorResponse("Invalid stylesheet path: contains traversal sequences.");

            if (!stylesheetPath.EndsWith(".uss", StringComparison.OrdinalIgnoreCase))
                return new ErrorResponse("'stylesheet' must point to a .uss file.");

            // Read the UXML file
            string fullPath = Path.Combine(Application.dataPath,
                uxmlPath.Substring("Assets/".Length)).Replace('/', Path.DirectorySeparatorChar);

            if (!File.Exists(fullPath))
                return new ErrorResponse($"UXML file not found: {uxmlPath}");

            string content = File.ReadAllText(fullPath, Encoding.UTF8);

            // Check if stylesheet is already linked
            if (content.Contains($"src=\"{stylesheetPath}\"") ||
                content.Contains($"src=\"project://database/{stylesheetPath}\""))
            {
                return new SuccessResponse($"Stylesheet already linked in '{uxmlPath}'.",
                    new { path = uxmlPath, stylesheet = stylesheetPath, alreadyLinked = true });
            }

            // Find the insertion point (after the opening <ui:UXML ...> or <UXML ...> tag)
            int insertIdx = FindUxmlBodyStart(content);
            if (insertIdx < 0)
                return new ErrorResponse("Could not find insertion point. Ensure UXML has a root <ui:UXML> or <UXML> element.");

            string styleTag = $"\n    <ui:Style src=\"project://database/{stylesheetPath}\" />";
            content = content.Insert(insertIdx, styleTag);

            File.WriteAllText(fullPath, content, Utf8NoBom);
            AssetDatabase.ImportAsset(uxmlPath, ImportAssetOptions.ForceUpdate);

            return new SuccessResponse($"Linked stylesheet '{stylesheetPath}' to '{uxmlPath}'.",
                new { path = uxmlPath, stylesheet = stylesheetPath });
        }

        // ---- Delete ----

        private static object DeleteFile(JObject @params)
        {
            var p = new ToolParams(@params);
            string path = ValidatePath(p.Get("path"), out string pathError);
            if (pathError != null) return new ErrorResponse(pathError);

            string fullPath = Path.Combine(Application.dataPath,
                path.Substring("Assets/".Length));
            fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);

            if (!File.Exists(fullPath))
            {
                return new ErrorResponse($"File not found: {path}");
            }

            try
            {
                bool success = AssetDatabase.DeleteAsset(path);
                if (!success)
                {
                    return new ErrorResponse($"Failed to delete file through AssetDatabase: '{path}'");
                }

                // Fallback: if file still exists after AssetDatabase.DeleteAsset
                if (File.Exists(fullPath))
                {
                    File.Delete(fullPath);
                }

                return new SuccessResponse($"Deleted {Path.GetExtension(path).TrimStart('.')} file at {path}",
                    new { path });
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Failed to delete '{path}': {e.Message}");
            }
        }

        // ---- List UI Assets ----

        private static object ListUIAssets(JObject @params)
        {
            var p = new ToolParams(@params);
            string scope = p.Get("path") ?? "Assets";
            string filterType = p.Get("filter_type") ?? p.Get("filterType");
            int pageSize = p.GetInt("page_size") ?? p.GetInt("pageSize") ?? 50;
            int pageNumber = p.GetInt("page_number") ?? p.GetInt("pageNumber") ?? 1;

            scope = AssetPathUtility.SanitizeAssetPath(scope);
            if (scope == null)
            {
                return new ErrorResponse("Invalid path: contains traversal sequences.");
            }

            string[] folderScope = AssetDatabase.IsValidFolder(scope)
                ? new[] { scope }
                : null;

            // Find UXML and USS assets based on filter
            var allAssets = new List<object>();

            bool includeUxml = string.IsNullOrEmpty(filterType) ||
                               filterType.Equals("uxml", StringComparison.OrdinalIgnoreCase) ||
                               filterType.Equals("VisualTreeAsset", StringComparison.OrdinalIgnoreCase);
            bool includeUss = string.IsNullOrEmpty(filterType) ||
                              filterType.Equals("uss", StringComparison.OrdinalIgnoreCase) ||
                              filterType.Equals("StyleSheet", StringComparison.OrdinalIgnoreCase);
            bool includePanelSettings = string.IsNullOrEmpty(filterType) ||
                                        filterType.Equals("PanelSettings", StringComparison.OrdinalIgnoreCase);

            if (includeUxml)
            {
                string[] guids = AssetDatabase.FindAssets("t:VisualTreeAsset", folderScope);
                foreach (string guid in guids)
                {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                    if (!string.IsNullOrEmpty(assetPath))
                    {
                        allAssets.Add(new Dictionary<string, object>
                        {
                            ["path"] = assetPath,
                            ["type"] = "uxml",
                            ["name"] = Path.GetFileName(assetPath),
                        });
                    }
                }
            }

            if (includeUss)
            {
                string[] guids = AssetDatabase.FindAssets("t:StyleSheet", folderScope);
                foreach (string guid in guids)
                {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                    if (!string.IsNullOrEmpty(assetPath))
                    {
                        allAssets.Add(new Dictionary<string, object>
                        {
                            ["path"] = assetPath,
                            ["type"] = "uss",
                            ["name"] = Path.GetFileName(assetPath),
                        });
                    }
                }
            }

            if (includePanelSettings)
            {
                string[] guids = AssetDatabase.FindAssets("t:PanelSettings", folderScope);
                foreach (string guid in guids)
                {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                    if (!string.IsNullOrEmpty(assetPath))
                    {
                        allAssets.Add(new Dictionary<string, object>
                        {
                            ["path"] = assetPath,
                            ["type"] = "PanelSettings",
                            ["name"] = Path.GetFileName(assetPath),
                        });
                    }
                }
            }

            int total = allAssets.Count;
            int startIndex = (pageNumber - 1) * pageSize;
            var paged = allAssets.Skip(startIndex).Take(pageSize).ToList();

            return new SuccessResponse(
                $"Found {total} UI asset(s). Returning page {pageNumber} ({paged.Count} items).",
                new
                {
                    total,
                    pageSize,
                    pageNumber,
                    assets = paged,
                });
        }

        // ---- Detach UIDocument ----

        private static object DetachUIDocument(JObject @params)
        {
            var p = new ToolParams(@params);

            var targetResult = p.GetRequired("target");
            var targetError = targetResult.GetOrError(out string target);
            if (targetError != null) return targetError;

            var goInstruction = new JObject { ["find"] = target };
            GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
            if (go == null)
            {
                return new ErrorResponse($"Could not find target GameObject: {target}");
            }

            var uiDoc = go.GetComponent<UIDocument>();
            if (uiDoc == null)
            {
                return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
            }

            string sourceAsset = uiDoc.visualTreeAsset != null
                ? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
                : null;

            Undo.DestroyObjectImmediate(uiDoc);
            EditorUtility.SetDirty(go);

            return new SuccessResponse($"Removed UIDocument from {go.name}",
                new
                {
                    gameObject = go.name,
                    removedSourceAsset = sourceAsset,
                });
        }

        // ---- Modify Visual Element ----

        private static object ModifyVisualElement(JObject @params)
        {
            var p = new ToolParams(@params);

            var targetResult = p.GetRequired("target");
            var targetError = targetResult.GetOrError(out string target);
            if (targetError != null) return targetError;

            string elementName = p.Get("element_name") ?? p.Get("elementName");
            if (string.IsNullOrEmpty(elementName))
            {
                return new ErrorResponse("'element_name' parameter is required.");
            }

            var goInstruction = new JObject { ["find"] = target };
            GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
            if (go == null)
            {
                return new ErrorResponse($"Could not find target GameObject: {target}");
            }

            var uiDoc = go.GetComponent<UIDocument>();
            if (uiDoc == null)
            {
                return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
            }

            var root = uiDoc.rootVisualElement;
            if (root == null)
            {
                return new ErrorResponse($"UIDocument on {go.name} has no visual tree (not yet built).");
            }

            // Find the target element by name
            var element = root.Q(elementName);
            if (element == null)
            {
                return new ErrorResponse($"Visual element with name '{elementName}' not found in the visual tree.");
            }

            var modifications = new List<string>();

            // Set text content (Label, Button, etc.)
            string text = p.Get("text");
            if (text != null && element is TextElement textEl)
            {
                textEl.text = text;
                modifications.Add($"text='{text}'");
            }
            else if (text != null)
            {
                return new ErrorResponse($"Element '{elementName}' ({element.GetType().Name}) does not support text content.");
            }

            // Add CSS classes
            JToken addClassesToken = p.GetRaw("add_classes") ?? p.GetRaw("addClasses");
            if (addClassesToken is JArray addArr)
            {
                foreach (var cls in addArr)
                {
                    string className = cls.ToString();
                    if (!element.ClassListContains(className))
                    {
                        element.AddToClassList(className);
                        modifications.Add($"+class '{className}'");
                    }
                }
            }

            // Remove CSS classes
            JToken removeClassesToken = p.GetRaw("remove_classes") ?? p.GetRaw("removeClasses");
            if (removeClassesToken is JArray removeArr)
            {
                foreach (var cls in removeArr)
                {
                    string className = cls.ToString();
                    if (element.ClassListContains(className))
                    {
                        element.RemoveFromClassList(className);
                        modifications.Add($"-class '{className}'");
                    }
                }
            }

            // Toggle CSS classes
            JToken toggleClassesToken = p.GetRaw("toggle_classes") ?? p.GetRaw("toggleClasses");
            if (toggleClassesToken is JArray toggleArr)
            {
                foreach (var cls in toggleArr)
                {
                    string className = cls.ToString();
                    element.ToggleInClassList(className);
                    modifications.Add($"~class '{className}'");
                }
            }

            // Set inline styles
            JToken styleToken = p.GetRaw("style") ?? p.GetRaw("inline_style") ?? p.GetRaw("inlineStyle");
            if (styleToken is JObject styleObj)
            {
                ApplyInlineStyles(element, styleObj, modifications);
            }

            // Set enabled/disabled
            bool? enabled = p.GetNullableBool("enabled");
            if (enabled.HasValue)
            {
                element.SetEnabled(enabled.Value);
                modifications.Add($"enabled={enabled.Value}");
            }

            // Set visibility
            string visibility = p.Get("visible");
            if (visibility != null)
            {
                bool isVisible = visibility.Equals("true", StringComparison.OrdinalIgnoreCase) ||
                                 visibility == "1";
                element.style.display = isVisible ? DisplayStyle.Flex : DisplayStyle.None;
                modifications.Add($"visible={isVisible}");
            }

            // Set tooltip
            string tooltip = p.Get("tooltip");
            if (tooltip != null)
            {
                element.tooltip = tooltip;
                modifications.Add($"tooltip='{tooltip}'");
            }

            // Filter out [skipped] entries so they don't count as real modifications
            var applied = modifications.Where(m => !m.StartsWith("[skipped]")).ToList();
            var skipped = modifications.Where(m => m.StartsWith("[skipped]")).ToList();

            if (applied.Count == 0)
            {
                string msg = skipped.Count > 0
                    ? $"No modifications applied. Skipped unsupported styles: {string.Join(", ", skipped)}"
                    : "No modifications specified. Provide at least one of: text, add_classes, remove_classes, toggle_classes, style, enabled, visible, tooltip.";
                return new ErrorResponse(msg);
            }

            var responseData = new Dictionary<string, object>
            {
                { "gameObject", go.name },
                { "elementName", elementName },
                { "elementType", element.GetType().Name },
                { "modifications", applied },
                { "currentClasses", new List<string>(element.GetClasses()) },
            };
            if (skipped.Count > 0)
                responseData["skipped"] = skipped;

            return new SuccessResponse(
                $"Modified element '{elementName}' on {go.name}: {string.Join(", ", applied)}",
                responseData);
        }

        private static void ApplyInlineStyles(VisualElement element, JObject styleObj, List<string> modifications)
        {
            foreach (var prop in styleObj)
            {
                string key = prop.Key;
                JToken val = prop.Value;

                switch (key.ToLowerInvariant())
                {
                    case "backgroundcolor":
                    case "background-color":
                        if (ColorUtility.TryParseHtmlString(val.ToString(), out Color bgColor))
                        {
                            element.style.backgroundColor = bgColor;
                            modifications.Add($"backgroundColor={val}");
                        }
                        break;

                    case "color":
                        if (ColorUtility.TryParseHtmlString(val.ToString(), out Color fgColor))
                        {
                            element.style.color = fgColor;
                            modifications.Add($"color={val}");
                        }
                        break;

                    case "fontsize":
                    case "font-size":
                        element.style.fontSize = val.ToObject<float>();
                        modifications.Add($"fontSize={val}");
                        break;

                    case "width":
                        element.style.width = val.ToObject<float>();
                        modifications.Add($"width={val}");
                        break;

                    case "height":
                        element.style.height = val.ToObject<float>();
                        modifications.Add($"height={val}");
                        break;

                    case "opacity":
                        element.style.opacity = val.ToObject<float>();
                        modifications.Add($"opacity={val}");
                        break;

                    case "display":
                        if (Enum.TryParse<DisplayStyle>(val.ToString(), true, out var display))
                        {
                            element.style.display = display;
                            modifications.Add($"display={val}");
                        }
                        break;

                    case "visibility":
                        if (Enum.TryParse<Visibility>(val.ToString(), true, out var vis))
                        {
                            element.style.visibility = vis;
                            modifications.Add($"visibility={val}");
                        }
                        break;

                    case "flexgrow":
                    case "flex-grow":
                        element.style.flexGrow = val.ToObject<float>();
                        modifications.Add($"flexGrow={val}");
                        break;

                    case "flexshrink":
                    case "flex-shrink":
                        element.style.flexShrink = val.ToObject<float>();
                        modifications.Add($"flexShrink={val}");
                        break;

                    case "marginleft":
                    case "margin-left":
                        element.style.marginLeft = val.ToObject<float>();
                        modifications.Add($"marginLeft={val}");
                        break;

                    case "marginright":
                    case "margin-right":
                        element.style.marginRight = val.ToObject<float>();
                        modifications.Add($"marginRight={val}");
                        break;

                    case "margintop":
                    case "margin-top":
                        element.style.marginTop = val.ToObject<float>();
                        modifications.Add($"marginTop={val}");
                        break;

                    case "marginbottom":
                    case "margin-bottom":
                        element.style.marginBottom = val.ToObject<float>();
                        modifications.Add($"marginBottom={val}");
                        break;

                    case "paddingleft":
                    case "padding-left":
                        element.style.paddingLeft = val.ToObject<float>();
                        modifications.Add($"paddingLeft={val}");
                        break;

                    case "paddingright":
                    case "padding-right":
                        element.style.paddingRight = val.ToObject<float>();
                        modifications.Add($"paddingRight={val}");
                        break;

                    case "paddingtop":
                    case "padding-top":
                        element.style.paddingTop = val.ToObject<float>();
                        modifications.Add($"paddingTop={val}");
                        break;

                    case "paddingbottom":
                    case "padding-bottom":
                        element.style.paddingBottom = val.ToObject<float>();
                        modifications.Add($"paddingBottom={val}");
                        break;

                    case "borderradius":
                    case "border-radius":
                        float radius = val.ToObject<float>();
                        element.style.borderTopLeftRadius = radius;
                        element.style.borderTopRightRadius = radius;
                        element.style.borderBottomLeftRadius = radius;
                        element.style.borderBottomRightRadius = radius;
                        modifications.Add($"borderRadius={val}");
                        break;

                    default:
                        modifications.Add($"[skipped] {key} (unsupported inline style)");
                        break;
                }
            }
        }

        private static bool? GetNullableBool(this ToolParams p, string key)
        {
            var raw = p.GetRaw(key);
            if (raw == null) return null;
            if (raw.Type == JTokenType.Boolean) return raw.ToObject<bool>();
            string s = raw.ToString();
            if (bool.TryParse(s, out bool result)) return result;
            return null;
        }

        /// <summary>
        /// Finds the index right after the closing '>' of the root UXML element opening tag.
        /// Returns -1 if not found or if the root tag is self-closing.
        /// </summary>
        private static int FindUxmlBodyStart(string content)
        {
            int searchFrom = 0;
            while (true)
            {
                int idx = content.IndexOf("<ui:UXML", searchFrom, StringComparison.OrdinalIgnoreCase);
                if (idx < 0)
                    idx = content.IndexOf("<UXML", searchFrom, StringComparison.OrdinalIgnoreCase);
                if (idx < 0)
                    return -1;

                // Skip matches inside XML comments (<!-- ... -->)
                int commentStart = content.LastIndexOf("<!--", idx, StringComparison.Ordinal);
                if (commentStart >= 0)
                {
                    int commentEnd = content.IndexOf("-->", commentStart + 4, StringComparison.Ordinal);
                    if (commentEnd >= 0 && commentEnd + 3 > idx)
                    {
                        searchFrom = commentEnd + 3;
                        continue;
                    }
                }

                int closeTag = content.IndexOf('>', idx);
                if (closeTag < 0) return -1;
                // Self-closing tag cannot have children
                if (closeTag > 0 && content[closeTag - 1] == '/') return -1;

                return closeTag + 1;
            }
        }

        // ---- Helpers ----

        private static string EnsureUniqueFilePath(string path)
        {
            if (!File.Exists(path)) return path;
            string dir = Path.GetDirectoryName(path) ?? string.Empty;
            string baseName = Path.GetFileNameWithoutExtension(path);
            string ext = Path.GetExtension(path);
            int counter = 1;
            string candidate;
            do
            {
                candidate = Path.Combine(dir, $"{baseName}-{counter}{ext}").Replace('\\', '/');
                counter++;
            } while (File.Exists(candidate));
            return candidate;
        }

        private static string ColorToHex(Color c)
        {
            return $"#{ColorUtility.ToHtmlStringRGBA(c)}";
        }

        private static string GetDecodedContents(ToolParams p)
        {
            bool isEncoded = p.GetBool("contents_encoded") || p.GetBool("contentsEncoded");

            if (isEncoded)
            {
                string encoded = p.Get("encoded_contents") ?? p.Get("encodedContents");
                if (!string.IsNullOrEmpty(encoded))
                {
                    try
                    {
                        return Encoding.UTF8.GetString(Convert.FromBase64String(encoded));
                    }
                    catch (FormatException ex)
                    {
                        throw new ArgumentException(
                            "Parameter 'encodedContents' must be valid base64 when 'contentsEncoded' is true.",
                            ex);
                    }
                }
            }

            return p.Get("contents");
        }

        /// <summary>
        /// Validates UXML content before writing to disk.
        /// Returns null if valid, or an error message if malformed.
        /// Populates warnings list with non-fatal issues.
        /// Uses XmlParserContext to pre-declare common UXML namespace prefixes
        /// (ui, uie, engine, editor) since Unity's parser is more lenient than System.Xml.
        /// </summary>

        /// <summary>
        /// Ensures the root UXML element has editor-extension-mode attribute.
        /// UI Builder requires this to open the file. Injects "False" if missing.
        /// </summary>
        private static string EnsureEditorExtensionMode(string contents)
        {
            if (contents.Contains("editor-extension-mode"))
                return contents;

            int idx = contents.IndexOf("<ui:UXML", StringComparison.Ordinal);
            if (idx < 0)
                idx = contents.IndexOf("<UXML", StringComparison.Ordinal);
            if (idx < 0)
                return contents;

            int closeTag = contents.IndexOf('>', idx);
            if (closeTag < 0)
                return contents;

            bool selfClosing = contents[closeTag - 1] == '/';
            int insertPos = selfClosing ? closeTag - 1 : closeTag;

            return contents.Substring(0, insertPos)
                 + " editor-extension-mode=\"False\""
                 + contents.Substring(insertPos);
        }

        private static string ValidateUxmlContent(string contents, List<string> warnings)
        {
            if (string.IsNullOrWhiteSpace(contents))
                return "UXML content is empty.";

            var nt = new NameTable();
            var nsMgr = new XmlNamespaceManager(nt);
            nsMgr.AddNamespace("ui", "UnityEngine.UIElements");
            nsMgr.AddNamespace("uie", "UnityEditor.UIElements");
            nsMgr.AddNamespace("engine", "UnityEngine.UIElements");
            nsMgr.AddNamespace("editor", "UnityEditor.UIElements");
            var ctx = new XmlParserContext(nt, nsMgr, null, XmlSpace.Default);

            string rootLocalName = null;
            try
            {
                using (var reader = XmlReader.Create(new StringReader(contents), null, ctx))
                {
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && rootLocalName == null)
                            rootLocalName = reader.LocalName;
                    }
                }
            }
            catch (XmlException ex)
            {
                return $"Malformed XML at line {ex.LineNumber}, position {ex.LinePosition}: {ex.Message}";
            }

            if (rootLocalName == null)
                return "UXML content has no root element.";

            if (rootLocalName != "UXML")
                warnings.Add($"Root element is <{rootLocalName}>, expected <UXML> or <ui:UXML>.");

            if (!contents.Contains("UnityEngine.UIElements"))
            {
                warnings.Add("Missing namespace declaration xmlns:ui=\"UnityEngine.UIElements\". " +
                              "UI Builder may fail to open this file.");
            }

            return null;
        }

        /// <summary>
        /// Validates a UXML asset after import by attempting to load it as a VisualTreeAsset.
        /// </summary>
        private static void ValidateUxmlPostImport(string assetPath, List<string> warnings)
        {
            var asset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(assetPath);
            if (asset == null)
            {
                warnings.Add("Unity failed to parse the UXML file. " +
                              "The file was written but UI Builder will not be able to open it. " +
                              "Check the console for details.");
            }
        }
    }
}