unity-mcp/Editor/Tools/ManageAsset.cs

using UnityEngine;
using UnityEditor;
using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;
using UnityMCP.Editor.Helpers; // For Response class
using System.Globalization;

namespace UnityMCP.Editor.Tools
{
    /// <summary>
    /// Handles asset management operations within the Unity project.
    /// </summary>
    public static class ManageAsset
    {
        // --- Main Handler ---

        // Define the list of valid actions
        private static readonly List<string> ValidActions = new List<string>
        {
            "import", "create", "modify", "delete", "duplicate",
            "move", "rename", "search", "get_info", "create_folder",
            "get_components"
        };

        public static object HandleCommand(JObject @params)
        {
            string action = @params["action"]?.ToString().ToLower();
            if (string.IsNullOrEmpty(action))
            {
                return Response.Error("Action parameter is required.");
            }

            // Check if the action is valid before switching
            if (!ValidActions.Contains(action))
            {
                string validActionsList = string.Join(", ", ValidActions);
                return Response.Error($"Unknown action: '{action}'. Valid actions are: {validActionsList}");
            }

            // Common parameters
            string path = @params["path"]?.ToString();

            try
            {
                switch (action)
                {
                    case "import":
                        // Note: Unity typically auto-imports. This might re-import or configure import settings.
                        return ReimportAsset(path, @params["properties"] as JObject);
                    case "create":
                        return CreateAsset(@params);
                    case "modify":
                        return ModifyAsset(path, @params["properties"] as JObject);
                    case "delete":
                        return DeleteAsset(path);
                    case "duplicate":
                        return DuplicateAsset(path, @params["destination"]?.ToString());
                    case "move": // Often same as rename if within Assets/
                    case "rename":
                        return MoveOrRenameAsset(path, @params["destination"]?.ToString());
                    case "search":
                         return SearchAssets(@params);
                    case "get_info":
                         return GetAssetInfo(path, @params["generatePreview"]?.ToObject<bool>() ?? false);
                    case "create_folder": // Added specific action for clarity
                         return CreateFolder(path);
                    case "get_components":
                         return GetComponentsFromAsset(path);

                    default:
                        // This error message is less likely to be hit now, but kept here as a fallback or for potential future modifications.
                        string validActionsListDefault = string.Join(", ", ValidActions);
                        return Response.Error($"Unknown action: '{action}'. Valid actions are: {validActionsListDefault}");
                }
            }
            catch (Exception e)
            {
                 Debug.LogError($"[ManageAsset] Action '{action}' failed for path '{path}': {e}");
                 return Response.Error($"Internal error processing action '{action}' on '{path}': {e.Message}");
            }
        }

        // --- Action Implementations ---

        private static object ReimportAsset(string path, JObject properties)
        {
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for reimport.");
            string fullPath = SanitizeAssetPath(path);
            if (!AssetExists(fullPath)) return Response.Error($"Asset not found at path: {fullPath}");

            try
            {
                // TODO: Apply importer properties before reimporting?
                // This is complex as it requires getting the AssetImporter, casting it,
                // applying properties via reflection or specific methods, saving, then reimporting.
                if (properties != null && properties.HasValues)
                {
                    Debug.LogWarning("[ManageAsset.Reimport] Modifying importer properties before reimport is not fully implemented yet.");
                    // AssetImporter importer = AssetImporter.GetAtPath(fullPath);
                    // if (importer != null) { /* Apply properties */ AssetDatabase.WriteImportSettingsIfDirty(fullPath); }
                }

                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);
                // AssetDatabase.Refresh(); // Usually ImportAsset handles refresh
                return Response.Success($"Asset '{fullPath}' reimported.", GetAssetData(fullPath));
            }
            catch (Exception e)
            {
                return Response.Error($"Failed to reimport asset '{fullPath}': {e.Message}");
            }
        }

        private static object CreateAsset(JObject @params)
        {
            string path = @params["path"]?.ToString();
            string assetType = @params["assetType"]?.ToString();
            JObject properties = @params["properties"] as JObject;

            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for create.");
            if (string.IsNullOrEmpty(assetType)) return Response.Error("'assetType' is required for create.");

            string fullPath = SanitizeAssetPath(path);
            string directory = Path.GetDirectoryName(fullPath);

            // Ensure directory exists
            if (!Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), directory)))
            {
                Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), directory));
                AssetDatabase.Refresh(); // Make sure Unity knows about the new folder
            }

            if (AssetExists(fullPath)) return Response.Error($"Asset already exists at path: {fullPath}");

            try
            {
                UnityEngine.Object newAsset = null;
                string lowerAssetType = assetType.ToLowerInvariant();

                // Handle common asset types
                if (lowerAssetType == "folder")
                {
                    return CreateFolder(path); // Use dedicated method
                }
                else if (lowerAssetType == "material")
                {
                    Material mat = new Material(Shader.Find("Standard")); // Default shader
                    // TODO: Apply properties from JObject (e.g., shader name, color, texture assignments)
                    if(properties != null) ApplyMaterialProperties(mat, properties);
                    AssetDatabase.CreateAsset(mat, fullPath);
                    newAsset = mat;
                }
                 else if (lowerAssetType == "scriptableobject")
                 {
                     string scriptClassName = properties?["scriptClass"]?.ToString();
                     if (string.IsNullOrEmpty(scriptClassName)) return Response.Error("'scriptClass' property required when creating ScriptableObject asset.");
                     
                     Type scriptType = FindType(scriptClassName);
                      if (scriptType == null || !typeof(ScriptableObject).IsAssignableFrom(scriptType))
                     {
                         return Response.Error($"Script class '{scriptClassName}' not found or does not inherit from ScriptableObject.");
                     }
                     
                     ScriptableObject so = ScriptableObject.CreateInstance(scriptType);
                     // TODO: Apply properties from JObject to the ScriptableObject instance?
                     AssetDatabase.CreateAsset(so, fullPath);
                     newAsset = so;
                 }
                 else if (lowerAssetType == "prefab")
                 {
                      // Creating prefabs usually involves saving an existing GameObject hierarchy.
                      // A common pattern is to create an empty GameObject, configure it, and then save it.
                      return Response.Error("Creating prefabs programmatically usually requires a source GameObject. Use manage_gameobject to create/configure, then save as prefab via a separate mechanism or future enhancement.");
                      // Example (conceptual): 
                      // GameObject source = GameObject.Find(properties["sourceGameObject"].ToString());
                      // if(source != null) PrefabUtility.SaveAsPrefabAsset(source, fullPath);
                 }
                // TODO: Add more asset types (Animation Controller, Scene, etc.)
                else
                {
                    // Generic creation attempt (might fail or create empty files)
                    // For some types, just creating the file might be enough if Unity imports it.
                    // File.Create(Path.Combine(Directory.GetCurrentDirectory(), fullPath)).Close();
                    // AssetDatabase.ImportAsset(fullPath); // Let Unity try to import it
                    // newAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(fullPath);
                    return Response.Error($"Creation for asset type '{assetType}' is not explicitly supported yet. Supported: Folder, Material, ScriptableObject.");
                }

                if (newAsset == null && !Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), fullPath))) // Check if it wasn't a folder and asset wasn't created
                {
                    return Response.Error($"Failed to create asset '{assetType}' at '{fullPath}'. See logs for details.");
                }

                AssetDatabase.SaveAssets();
                // AssetDatabase.Refresh(); // CreateAsset often handles refresh
                return Response.Success($"Asset '{fullPath}' created successfully.", GetAssetData(fullPath));
            }
            catch (Exception e)
            {
                return Response.Error($"Failed to create asset at '{fullPath}': {e.Message}");
            }
        }
        
         private static object CreateFolder(string path)
        {
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for create_folder.");
            string fullPath = SanitizeAssetPath(path);
            string parentDir = Path.GetDirectoryName(fullPath);
            string folderName = Path.GetFileName(fullPath);

            if (AssetExists(fullPath))
            {
                 // Check if it's actually a folder already
                 if (AssetDatabase.IsValidFolder(fullPath)) 
                 {
                      return Response.Success($"Folder already exists at path: {fullPath}", GetAssetData(fullPath));
                 }
                 else 
                 {
                     return Response.Error($"An asset (not a folder) already exists at path: {fullPath}");
                 }
            }

            try
            {
                 // Ensure parent exists
                if (!string.IsNullOrEmpty(parentDir) && !AssetDatabase.IsValidFolder(parentDir)) {
                    // Recursively create parent folders if needed (AssetDatabase handles this internally)
                    // Or we can do it manually: Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), parentDir)); AssetDatabase.Refresh();
                }

                string guid = AssetDatabase.CreateFolder(parentDir, folderName);
                 if (string.IsNullOrEmpty(guid)) {
                     return Response.Error($"Failed to create folder '{fullPath}'. Check logs and permissions.");
                 }
                 
                // AssetDatabase.Refresh(); // CreateFolder usually handles refresh
                return Response.Success($"Folder '{fullPath}' created successfully.", GetAssetData(fullPath));
            }
            catch (Exception e)
            {
                return Response.Error($"Failed to create folder '{fullPath}': {e.Message}");
            }
        }

        private static object ModifyAsset(string path, JObject properties)
        { 
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for modify.");
            if (properties == null || !properties.HasValues) return Response.Error("'properties' are required for modify.");
            
            string fullPath = SanitizeAssetPath(path);
            if (!AssetExists(fullPath)) return Response.Error($"Asset not found at path: {fullPath}");

            try
            {
                UnityEngine.Object asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(fullPath);
                if (asset == null) return Response.Error($"Failed to load asset at path: {fullPath}");

                bool modified = false; // Flag to track if any changes were made

                // --- NEW: Handle GameObject / Prefab Component Modification ---
                if (asset is GameObject gameObject)
                {
                    // Iterate through the properties JSON: keys are component names, values are properties objects for that component
                    foreach (var prop in properties.Properties())
                    {
                        string componentName = prop.Name; // e.g., "Collectible"
                        // Check if the value associated with the component name is actually an object containing properties
                        if (prop.Value is JObject componentProperties && componentProperties.HasValues) // e.g., {"bobSpeed": 2.0}
                        {
                            // Find the component on the GameObject using the name from the JSON key
                            // Using GetComponent(string) is convenient but might require exact type name or be ambiguous.
                            // Consider using FindType helper if needed for more complex scenarios.
                            Component targetComponent = gameObject.GetComponent(componentName);

                            if (targetComponent != null)
                            {
                                // Apply the nested properties (e.g., bobSpeed) to the found component instance
                                // Use |= to ensure 'modified' becomes true if any component is successfully modified
                                modified |= ApplyObjectProperties(targetComponent, componentProperties);
                            }
                            else
                            {
                                // Log a warning if a specified component couldn't be found
                                Debug.LogWarning($"[ManageAsset.ModifyAsset] Component '{componentName}' not found on GameObject '{gameObject.name}' in asset '{fullPath}'. Skipping modification for this component.");
                            }
                        }
                        else
                        {
                            // Log a warning if the structure isn't {"ComponentName": {"prop": value}}
                            // We could potentially try to apply this property directly to the GameObject here if needed,
                            // but the primary goal is component modification.
                             Debug.LogWarning($"[ManageAsset.ModifyAsset] Property '{prop.Name}' for GameObject modification should have a JSON object value containing component properties. Value was: {prop.Value.Type}. Skipping.");
                        }
                    }
                    // Note: 'modified' is now true if ANY component property was successfully changed.
                }
                // --- End NEW ---

                // --- Existing logic for other asset types (now as else-if) ---
                // Example: Modifying a Material
                else if (asset is Material material)
                {
                     // Apply properties directly to the material. If this modifies, it sets modified=true.
                     // Use |= in case the asset was already marked modified by previous logic (though unlikely here)
                     modified |= ApplyMaterialProperties(material, properties);
                }
                // Example: Modifying a ScriptableObject
                 else if (asset is ScriptableObject so)
                 {
                      // Apply properties directly to the ScriptableObject.
                      modified |= ApplyObjectProperties(so, properties); // General helper
                 }
                 // Example: Modifying TextureImporter settings
                 else if (asset is Texture) {
                     AssetImporter importer = AssetImporter.GetAtPath(fullPath);
                     if (importer is TextureImporter textureImporter)
                     {
                          bool importerModified = ApplyObjectProperties(textureImporter, properties);
                          if (importerModified) {
                               // Importer settings need saving and reimporting
                               AssetDatabase.WriteImportSettingsIfDirty(fullPath);
                               AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate); // Reimport to apply changes
                               modified = true; // Mark overall operation as modified
                          }
                     }
                     else {
                          Debug.LogWarning($"Could not get TextureImporter for {fullPath}.");
                     }
                 }
                // TODO: Add modification logic for other common asset types (Models, AudioClips importers, etc.)
                else // Fallback for other asset types OR direct properties on non-GameObject assets
                {
                    // This block handles non-GameObject/Material/ScriptableObject/Texture assets.
                    // Attempts to apply properties directly to the asset itself.
                    Debug.LogWarning($"[ManageAsset.ModifyAsset] Asset type '{asset.GetType().Name}' at '{fullPath}' is not explicitly handled for component modification. Attempting generic property setting on the asset itself.");
                    modified |= ApplyObjectProperties(asset, properties);
                }
                // --- End Existing Logic ---

                // Check if any modification happened (either component or direct asset modification)
                if (modified)
                {
                    // Mark the asset as dirty (important for prefabs/SOs) so Unity knows to save it.
                    EditorUtility.SetDirty(asset);
                    // Save all modified assets to disk.
                    AssetDatabase.SaveAssets();
                    // Refresh might be needed in some edge cases, but SaveAssets usually covers it.
                    // AssetDatabase.Refresh();
                    return Response.Success($"Asset '{fullPath}' modified successfully.", GetAssetData(fullPath));
                } else {
                     // If no changes were made (e.g., component not found, property names incorrect, value unchanged), return a success message indicating nothing changed.
                    return Response.Success($"No applicable or modifiable properties found for asset '{fullPath}'. Check component names, property names, and values.", GetAssetData(fullPath));
                    // Previous message: return Response.Success($"No applicable properties found to modify for asset '{fullPath}'.", GetAssetData(fullPath));
                }
            }
            catch (Exception e)
            {
                // Log the detailed error internally
                 Debug.LogError($"[ManageAsset] Action 'modify' failed for path '{path}': {e}");
                 // Return a user-friendly error message
                 return Response.Error($"Failed to modify asset '{fullPath}': {e.Message}");
            }
        }

        private static object DeleteAsset(string path)
        {
             if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for delete.");
             string fullPath = SanitizeAssetPath(path);
             if (!AssetExists(fullPath)) return Response.Error($"Asset not found at path: {fullPath}");

            try
            {
                bool success = AssetDatabase.DeleteAsset(fullPath);
                if (success)
                {
                     // AssetDatabase.Refresh(); // DeleteAsset usually handles refresh
                     return Response.Success($"Asset '{fullPath}' deleted successfully.");
                }
                else
                {
                    // This might happen if the file couldn't be deleted (e.g., locked)
                    return Response.Error($"Failed to delete asset '{fullPath}'. Check logs or if the file is locked.");
                }
            }
            catch (Exception e)
            {
                 return Response.Error($"Error deleting asset '{fullPath}': {e.Message}");
            }
        }

        private static object DuplicateAsset(string path, string destinationPath)
        {
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for duplicate.");
            
            string sourcePath = SanitizeAssetPath(path);
            if (!AssetExists(sourcePath)) return Response.Error($"Source asset not found at path: {sourcePath}");

            string destPath;
            if (string.IsNullOrEmpty(destinationPath))
            {
                 // Generate a unique path if destination is not provided
                 destPath = AssetDatabase.GenerateUniqueAssetPath(sourcePath);
            }
            else
            {
                 destPath = SanitizeAssetPath(destinationPath);
                 if (AssetExists(destPath)) return Response.Error($"Asset already exists at destination path: {destPath}");
                 // Ensure destination directory exists
                 EnsureDirectoryExists(Path.GetDirectoryName(destPath));
            }
            
            try
            {
                bool success = AssetDatabase.CopyAsset(sourcePath, destPath);
                 if (success)
                 {
                      // AssetDatabase.Refresh();
                      return Response.Success($"Asset '{sourcePath}' duplicated to '{destPath}'.", GetAssetData(destPath));
                 }
                 else
                 {
                     return Response.Error($"Failed to duplicate asset from '{sourcePath}' to '{destPath}'.");
                 }
            }
            catch (Exception e)
            {
                 return Response.Error($"Error duplicating asset '{sourcePath}': {e.Message}");
            }
        }

         private static object MoveOrRenameAsset(string path, string destinationPath)
        {
             if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for move/rename.");
             if (string.IsNullOrEmpty(destinationPath)) return Response.Error("'destination' path is required for move/rename.");
             
             string sourcePath = SanitizeAssetPath(path);
             string destPath = SanitizeAssetPath(destinationPath);

             if (!AssetExists(sourcePath)) return Response.Error($"Source asset not found at path: {sourcePath}");
             if (AssetExists(destPath)) return Response.Error($"An asset already exists at the destination path: {destPath}");

            // Ensure destination directory exists
            EnsureDirectoryExists(Path.GetDirectoryName(destPath));

            try
            {
                 // Validate will return an error string if failed, null if successful
                string error = AssetDatabase.ValidateMoveAsset(sourcePath, destPath);
                 if (!string.IsNullOrEmpty(error))
                 {
                     return Response.Error($"Failed to move/rename asset from '{sourcePath}' to '{destPath}': {error}");
                 }

                 string guid = AssetDatabase.MoveAsset(sourcePath, destPath);
                  if (!string.IsNullOrEmpty(guid)) // MoveAsset returns the new GUID on success
                  {
                       // AssetDatabase.Refresh(); // MoveAsset usually handles refresh
                       return Response.Success($"Asset moved/renamed from '{sourcePath}' to '{destPath}'.", GetAssetData(destPath));
                  }
                  else
                  {
                       // This case might not be reachable if ValidateMoveAsset passes, but good to have
                       return Response.Error($"MoveAsset call failed unexpectedly for '{sourcePath}' to '{destPath}'.");
                  }
            }
             catch (Exception e)
            {
                 return Response.Error($"Error moving/renaming asset '{sourcePath}': {e.Message}");
            }
        }
        
        private static object SearchAssets(JObject @params)
        {
            string searchPattern = @params["searchPattern"]?.ToString();
            string filterType = @params["filterType"]?.ToString();
            string pathScope = @params["path"]?.ToString(); // Use path as folder scope
            string filterDateAfterStr = @params["filterDateAfter"]?.ToString();
            int pageSize = @params["pageSize"]?.ToObject<int?>() ?? 50; // Default page size
            int pageNumber = @params["pageNumber"]?.ToObject<int?>() ?? 1; // Default page number (1-based)
            bool generatePreview = @params["generatePreview"]?.ToObject<bool>() ?? false;

            List<string> searchFilters = new List<string>();
            if (!string.IsNullOrEmpty(searchPattern)) searchFilters.Add(searchPattern);
            if (!string.IsNullOrEmpty(filterType)) searchFilters.Add($"t:{filterType}");

            string[] folderScope = null;
            if (!string.IsNullOrEmpty(pathScope))
            {
                 folderScope = new string[] { SanitizeAssetPath(pathScope) };
                 if (!AssetDatabase.IsValidFolder(folderScope[0])) {
                     // Maybe the user provided a file path instead of a folder?
                     // We could search in the containing folder, or return an error.
                     Debug.LogWarning($"Search path '{folderScope[0]}' is not a valid folder. Searching entire project.");
                     folderScope = null; // Search everywhere if path isn't a folder
                 }
            }

            DateTime? filterDateAfter = null;
             if (!string.IsNullOrEmpty(filterDateAfterStr)) {
                 if (DateTime.TryParse(filterDateAfterStr, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out DateTime parsedDate)) {
                     filterDateAfter = parsedDate;
                 } else {
                     Debug.LogWarning($"Could not parse filterDateAfter: '{filterDateAfterStr}'. Expected ISO 8601 format.");
                 }
             }

            try
            {
                 string[] guids = AssetDatabase.FindAssets(string.Join(" ", searchFilters), folderScope);
                 List<object> results = new List<object>();
                int totalFound = 0;

                 foreach (string guid in guids)
                 {
                    string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                    if (string.IsNullOrEmpty(assetPath)) continue;
                    
                    // Apply date filter if present
                    if (filterDateAfter.HasValue) {
                         DateTime lastWriteTime = File.GetLastWriteTimeUtc(Path.Combine(Directory.GetCurrentDirectory(), assetPath));
                         if (lastWriteTime <= filterDateAfter.Value) {
                             continue; // Skip assets older than or equal to the filter date
                         }
                    }
                    
                    totalFound++; // Count matching assets before pagination
                    results.Add(GetAssetData(assetPath, generatePreview));
                }

                // Apply pagination
                 int startIndex = (pageNumber - 1) * pageSize;
                 var pagedResults = results.Skip(startIndex).Take(pageSize).ToList();

                 return Response.Success($"Found {totalFound} asset(s). Returning page {pageNumber} ({pagedResults.Count} assets).", new {
                    totalAssets = totalFound,
                    pageSize = pageSize,
                    pageNumber = pageNumber,
                    assets = pagedResults
                 });
            }
             catch (Exception e)
            {
                 return Response.Error($"Error searching assets: {e.Message}");
            }
        }

        private static object GetAssetInfo(string path, bool generatePreview)
        {
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for get_info.");
            string fullPath = SanitizeAssetPath(path);
            if (!AssetExists(fullPath)) return Response.Error($"Asset not found at path: {fullPath}");

            try
            {
                 return Response.Success("Asset info retrieved.", GetAssetData(fullPath, generatePreview));
            }
             catch (Exception e)
            {
                 return Response.Error($"Error getting info for asset '{fullPath}': {e.Message}");
            }
        }

        /// <summary>
        /// Retrieves components attached to a GameObject asset (like a Prefab).
        /// </summary>
        /// <param name="path">The asset path of the GameObject or Prefab.</param>
        /// <returns>A response object containing a list of component type names or an error.</returns>
        private static object GetComponentsFromAsset(string path)
        {
            // 1. Validate input path
            if (string.IsNullOrEmpty(path)) return Response.Error("'path' is required for get_components.");
            
            // 2. Sanitize and check existence
            string fullPath = SanitizeAssetPath(path);
            if (!AssetExists(fullPath)) return Response.Error($"Asset not found at path: {fullPath}");

            try
            {
                // 3. Load the asset
                UnityEngine.Object asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(fullPath);
                if (asset == null) return Response.Error($"Failed to load asset at path: {fullPath}");

                // 4. Check if it's a GameObject (Prefabs load as GameObjects)
                GameObject gameObject = asset as GameObject;
                if (gameObject == null)
                {
                    // Also check if it's *directly* a Component type (less common for primary assets)
                    Component componentAsset = asset as Component;
                    if (componentAsset != null) {
                        // If the asset itself *is* a component, maybe return just its info?
                        // This is an edge case. Let's stick to GameObjects for now.
                        return Response.Error($"Asset at '{fullPath}' is a Component ({asset.GetType().FullName}), not a GameObject. Components are typically retrieved *from* a GameObject.");
                    }
                    return Response.Error($"Asset at '{fullPath}' is not a GameObject (Type: {asset.GetType().FullName}). Cannot get components from this asset type.");
                }

                // 5. Get components
                Component[] components = gameObject.GetComponents<Component>();
                
                // 6. Format component data
                List<object> componentList = components.Select(comp => new {
                    typeName = comp.GetType().FullName,
                    instanceID = comp.GetInstanceID(),
                    // TODO: Add more component-specific details here if needed in the future? 
                    //       Requires reflection or specific handling per component type.
                }).ToList<object>(); // Explicit cast for clarity if needed

                // 7. Return success response
                return Response.Success($"Found {componentList.Count} component(s) on asset '{fullPath}'.", componentList);
            }
            catch (Exception e)
            {
                Debug.LogError($"[ManageAsset.GetComponentsFromAsset] Error getting components for '{fullPath}': {e}");
                return Response.Error($"Error getting components for asset '{fullPath}': {e.Message}");
            }
        }

        // --- Internal Helpers ---

        /// <summary>
        /// Ensures the asset path starts with "Assets/".
        /// </summary>
        private static string SanitizeAssetPath(string path)
        {
            if (string.IsNullOrEmpty(path)) return path;
            path = path.Replace('\\', '/'); // Normalize separators
            if (!path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
            {
                return "Assets/" + path.TrimStart('/');
            }
            return path;
        }

        /// <summary>
        /// Checks if an asset exists at the given path (file or folder).
        /// </summary>
        private static bool AssetExists(string sanitizedPath)
        {
            // AssetDatabase APIs are generally preferred over raw File/Directory checks for assets.
            // Check if it's a known asset GUID.
            if (!string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(sanitizedPath)))
            {
                return true;
            }
            // AssetPathToGUID might not work for newly created folders not yet refreshed.
             // Check directory explicitly for folders.
            if(Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), sanitizedPath))) {
                 // Check if it's considered a *valid* folder by Unity
                 return AssetDatabase.IsValidFolder(sanitizedPath);
            }
            // Check file existence for non-folder assets.
             if(File.Exists(Path.Combine(Directory.GetCurrentDirectory(), sanitizedPath))){
                 return true; // Assume if file exists, it's an asset or will be imported
             }

            return false;
            // Alternative: return !string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(sanitizedPath));
        }

        /// <summary>
        /// Ensures the directory for a given asset path exists, creating it if necessary.
        /// </summary>
        private static void EnsureDirectoryExists(string directoryPath)
        {
            if (string.IsNullOrEmpty(directoryPath)) return;
            string fullDirPath = Path.Combine(Directory.GetCurrentDirectory(), directoryPath);
            if (!Directory.Exists(fullDirPath))
            {
                Directory.CreateDirectory(fullDirPath);
                AssetDatabase.Refresh(); // Let Unity know about the new folder
            }
        }

        /// <summary>
        /// Applies properties from JObject to a Material.
        /// </summary>
         private static bool ApplyMaterialProperties(Material mat, JObject properties)
        {
             if (mat == null || properties == null) return false;
             bool modified = false;

             // Example: Set shader
             if (properties["shader"]?.Type == JTokenType.String) {
                 Shader newShader = Shader.Find(properties["shader"].ToString());
                 if (newShader != null && mat.shader != newShader) {
                     mat.shader = newShader;
                     modified = true;
                 }
             }
             // Example: Set color property
             if (properties["color"] is JObject colorProps) {
                  string propName = colorProps["name"]?.ToString() ?? "_Color"; // Default main color
                  if (colorProps["value"] is JArray colArr && colArr.Count >= 3) {
                      try {
                          Color newColor = new Color(
                              colArr[0].ToObject<float>(), 
                              colArr[1].ToObject<float>(), 
                              colArr[2].ToObject<float>(), 
                              colArr.Count > 3 ? colArr[3].ToObject<float>() : 1.0f
                          );
                          if(mat.HasProperty(propName) && mat.GetColor(propName) != newColor) {
                               mat.SetColor(propName, newColor);
                               modified = true;
                          }
                      } catch (Exception ex) { Debug.LogWarning($"Error parsing color property '{propName}': {ex.Message}"); }
                  }
             }
             // Example: Set float property
             if (properties["float"] is JObject floatProps) {
                  string propName = floatProps["name"]?.ToString();
                  if (!string.IsNullOrEmpty(propName) && floatProps["value"]?.Type == JTokenType.Float || floatProps["value"]?.Type == JTokenType.Integer) {
                       try {
                           float newVal = floatProps["value"].ToObject<float>();
                           if (mat.HasProperty(propName) && mat.GetFloat(propName) != newVal) {
                                mat.SetFloat(propName, newVal);
                                modified = true;
                           }
                       } catch (Exception ex) { Debug.LogWarning($"Error parsing float property '{propName}': {ex.Message}"); }
                  }
             }
             // Example: Set texture property
             if (properties["texture"] is JObject texProps) {
                  string propName = texProps["name"]?.ToString() ?? "_MainTex"; // Default main texture
                  string texPath = texProps["path"]?.ToString();
                  if (!string.IsNullOrEmpty(texPath)) {
                       Texture newTex = AssetDatabase.LoadAssetAtPath<Texture>(SanitizeAssetPath(texPath));
                       if (newTex != null && mat.HasProperty(propName) && mat.GetTexture(propName) != newTex) {
                           mat.SetTexture(propName, newTex);
                           modified = true;
                       }
                       else if(newTex == null) {
                            Debug.LogWarning($"Texture not found at path: {texPath}");
                       }
                  }
             }
             
             // TODO: Add handlers for other property types (Vectors, Ints, Keywords, RenderQueue, etc.)
             return modified;
        }
        
        /// <summary>
        /// Generic helper to set properties on any UnityEngine.Object using reflection.
        /// </summary>
        private static bool ApplyObjectProperties(UnityEngine.Object target, JObject properties)
        {
            if (target == null || properties == null) return false;
            bool modified = false;
            Type type = target.GetType();

            foreach (var prop in properties.Properties())
            {
                string propName = prop.Name;
                JToken propValue = prop.Value;
                if (SetPropertyOrField(target, propName, propValue, type))
                {
                     modified = true;
                }
            }
            return modified;
        }
        
        /// <summary>
        /// Helper to set a property or field via reflection, handling basic types and Unity objects.
        /// </summary>
        private static bool SetPropertyOrField(object target, string memberName, JToken value, Type type = null)
        {
            type = type ?? target.GetType();
            System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.IgnoreCase;

            try
            {
                System.Reflection.PropertyInfo propInfo = type.GetProperty(memberName, flags);
                if (propInfo != null && propInfo.CanWrite)
                {
                    object convertedValue = ConvertJTokenToType(value, propInfo.PropertyType);
                    if (convertedValue != null && !object.Equals(propInfo.GetValue(target), convertedValue))
                    {
                        propInfo.SetValue(target, convertedValue);
                        return true;
                    }
                }
                else
                {
                    System.Reflection.FieldInfo fieldInfo = type.GetField(memberName, flags);
                    if (fieldInfo != null)
                    { 
                        object convertedValue = ConvertJTokenToType(value, fieldInfo.FieldType);
                         if (convertedValue != null && !object.Equals(fieldInfo.GetValue(target), convertedValue))
                         {
                            fieldInfo.SetValue(target, convertedValue);
                            return true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                 Debug.LogWarning($"[SetPropertyOrField] Failed to set '{memberName}' on {type.Name}: {ex.Message}");
            }
            return false;
        }
        
         /// <summary>
        /// Simple JToken to Type conversion for common Unity types and primitives.
        /// </summary>
        private static object ConvertJTokenToType(JToken token, Type targetType)
        {
             try
             {
                 if (token == null || token.Type == JTokenType.Null) return null;

                 if (targetType == typeof(string)) return token.ToObject<string>();
                 if (targetType == typeof(int)) return token.ToObject<int>();
                 if (targetType == typeof(float)) return token.ToObject<float>();
                 if (targetType == typeof(bool)) return token.ToObject<bool>();
                 if (targetType == typeof(Vector2) && token is JArray arrV2 && arrV2.Count == 2) 
                     return new Vector2(arrV2[0].ToObject<float>(), arrV2[1].ToObject<float>());
                 if (targetType == typeof(Vector3) && token is JArray arrV3 && arrV3.Count == 3) 
                     return new Vector3(arrV3[0].ToObject<float>(), arrV3[1].ToObject<float>(), arrV3[2].ToObject<float>());
                if (targetType == typeof(Vector4) && token is JArray arrV4 && arrV4.Count == 4) 
                     return new Vector4(arrV4[0].ToObject<float>(), arrV4[1].ToObject<float>(), arrV4[2].ToObject<float>(), arrV4[3].ToObject<float>());
                 if (targetType == typeof(Quaternion) && token is JArray arrQ && arrQ.Count == 4)
                     return new Quaternion(arrQ[0].ToObject<float>(), arrQ[1].ToObject<float>(), arrQ[2].ToObject<float>(), arrQ[3].ToObject<float>());
                 if (targetType == typeof(Color) && token is JArray arrC && arrC.Count >= 3) // Allow RGB or RGBA
                     return new Color(arrC[0].ToObject<float>(), arrC[1].ToObject<float>(), arrC[2].ToObject<float>(), arrC.Count > 3 ? arrC[3].ToObject<float>() : 1.0f);
                if (targetType.IsEnum)
                    return Enum.Parse(targetType, token.ToString(), true); // Case-insensitive enum parsing
                
                 // Handle loading Unity Objects (Materials, Textures, etc.) by path
                 if (typeof(UnityEngine.Object).IsAssignableFrom(targetType) && token.Type == JTokenType.String)
                 { 
                     string assetPath = SanitizeAssetPath(token.ToString());
                     UnityEngine.Object loadedAsset = AssetDatabase.LoadAssetAtPath(assetPath, targetType);
                     if (loadedAsset == null) {
                          Debug.LogWarning($"[ConvertJTokenToType] Could not load asset of type {targetType.Name} from path: {assetPath}");
                     }
                     return loadedAsset; 
                 }

                 // Fallback: Try direct conversion (might work for other simple value types)
                 return token.ToObject(targetType); 
             }
             catch (Exception ex)
             {
                 Debug.LogWarning($"[ConvertJTokenToType] Could not convert JToken '{token}' (type {token.Type}) to type '{targetType.Name}': {ex.Message}");
                 return null;
             }
        }

        /// <summary>
        /// Helper to find a Type by name, searching relevant assemblies.
        /// Needed for creating ScriptableObjects or finding component types by name.
        /// </summary>
        private static Type FindType(string typeName)
        {
            if (string.IsNullOrEmpty(typeName)) return null;

            // Try direct lookup first (common Unity types often don't need assembly qualified name)
             var type = Type.GetType(typeName) ?? 
                       Type.GetType($"UnityEngine.{typeName}, UnityEngine.CoreModule") ??
                       Type.GetType($"UnityEngine.UI.{typeName}, UnityEngine.UI") ??
                       Type.GetType($"UnityEditor.{typeName}, UnityEditor.CoreModule");

            if (type != null) return type;

            // If not found, search loaded assemblies (slower but more robust for user scripts)
             foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                 // Look for non-namespaced first
                 type = assembly.GetType(typeName, false, true); // throwOnError=false, ignoreCase=true
                 if (type != null) return type;
                 
                 // Check common namespaces if simple name given
                 type = assembly.GetType("UnityEngine." + typeName, false, true);
                 if (type != null) return type;
                 type = assembly.GetType("UnityEditor." + typeName, false, true);
                 if (type != null) return type;
                 // Add other likely namespaces if needed (e.g., specific plugins)
            }

            Debug.LogWarning($"[FindType] Type '{typeName}' not found in any loaded assembly.");
            return null; // Not found
        }

        // --- Data Serialization ---

        /// <summary>
        /// Creates a serializable representation of an asset.
        /// </summary>
        private static object GetAssetData(string path, bool generatePreview = false)
        {
            if (string.IsNullOrEmpty(path) || !AssetExists(path)) return null;
            
            string guid = AssetDatabase.AssetPathToGUID(path);
            Type assetType = AssetDatabase.GetMainAssetTypeAtPath(path);
            UnityEngine.Object asset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
            string previewBase64 = null;
            int previewWidth = 0;
            int previewHeight = 0;

            if (generatePreview && asset != null)
            {
                 Texture2D preview = AssetPreview.GetAssetPreview(asset);

                if (preview != null)
                {
                     try {
                         // Ensure texture is readable for EncodeToPNG
                         // Creating a temporary readable copy is safer
                         RenderTexture rt = RenderTexture.GetTemporary(preview.width, preview.height);
                         Graphics.Blit(preview, rt);
                         RenderTexture previous = RenderTexture.active;
                         RenderTexture.active = rt;
                         Texture2D readablePreview = new Texture2D(preview.width, preview.height);
                         readablePreview.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
                         readablePreview.Apply();
                         RenderTexture.active = previous;
                         RenderTexture.ReleaseTemporary(rt);

                         byte[] pngData = readablePreview.EncodeToPNG();
                         previewBase64 = Convert.ToBase64String(pngData);
                         previewWidth = readablePreview.width;
                         previewHeight = readablePreview.height;
                         UnityEngine.Object.DestroyImmediate(readablePreview); // Clean up temp texture

                     } catch (Exception ex) {
                          Debug.LogWarning($"Failed to generate readable preview for '{path}': {ex.Message}. Preview might not be readable.");
                         // Fallback: Try getting static preview if available?
                         // Texture2D staticPreview = AssetPreview.GetMiniThumbnail(asset);
                     }
                }
                 else
                 {
                     Debug.LogWarning($"Could not get asset preview for {path} (Type: {assetType?.Name}). Is it supported?");
                 }
            }

            return new
            {
                path = path,
                guid = guid,
                assetType = assetType?.FullName ?? "Unknown",
                name = Path.GetFileNameWithoutExtension(path),
                fileName = Path.GetFileName(path),
                isFolder = AssetDatabase.IsValidFolder(path),
                instanceID = asset?.GetInstanceID() ?? 0,
                lastWriteTimeUtc = File.GetLastWriteTimeUtc(Path.Combine(Directory.GetCurrentDirectory(), path)).ToString("o"), // ISO 8601
                // --- Preview Data ---
                 previewBase64 = previewBase64, // PNG data as Base64 string
                 previewWidth = previewWidth,
                 previewHeight = previewHeight
                 // TODO: Add more metadata? Importer settings? Dependencies?
            };
        }
    }
}