using System;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json.Linq;
using UnityEditor;
using UnityEngine;
using MCPForUnity.Editor.Helpers;

namespace MCPForUnity.Editor.Tools
{
    /// <summary>
    /// Handles procedural texture generation operations.
    /// Supports patterns (checkerboard, stripes, dots, grid, brick),
    /// gradients, noise, and direct pixel manipulation.
    /// </summary>
    [McpForUnityTool("manage_texture", AutoRegister = false)]
    public static class ManageTexture
    {
        private const int MaxTextureDimension = 1024;
        private const int MaxTexturePixels = 1024 * 1024;
        private const int MaxNoiseWork = 4000000;
        private static readonly List<string> ValidActions = new List<string>
        {
            "create",
            "modify",
            "delete",
            "create_sprite",
            "apply_pattern",
            "apply_gradient",
            "apply_noise"
        };

        private static ErrorResponse ValidateDimensions(int width, int height, List<string> warnings)
        {
            if (width <= 0 || height <= 0)
                return new ErrorResponse($"Invalid dimensions: {width}x{height}. Must be positive.");
            if (width > MaxTextureDimension || height > MaxTextureDimension)
                warnings.Add($"Dimensions exceed recommended max {MaxTextureDimension} per side (got {width}x{height}).");
            long totalPixels = (long)width * height;
            if (totalPixels > MaxTexturePixels)
                warnings.Add($"Total pixels exceed recommended max {MaxTexturePixels} (got {width}x{height}).");
            return null;
        }


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

            if (!ValidActions.Contains(action))
            {
                string validActionsList = string.Join(", ", ValidActions);
                return new ErrorResponse(
                    $"Unknown action: '{action}'. Valid actions are: {validActionsList}"
                );
            }

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

            try
            {
                switch (action)
                {
                    case "create":
                    case "create_sprite":
                        return CreateTexture(@params, action == "create_sprite");
                    case "modify":
                        return ModifyTexture(@params);
                    case "delete":
                        return DeleteTexture(path);
                    case "apply_pattern":
                        return ApplyPattern(@params);
                    case "apply_gradient":
                        return ApplyGradient(@params);
                    case "apply_noise":
                        return ApplyNoise(@params);
                    default:
                        return new ErrorResponse($"Unknown action: '{action}'");
                }
            }
            catch (Exception e)
            {
                McpLog.Error($"[ManageTexture] Action '{action}' failed: {e}");
                return new ErrorResponse($"Internal error processing action '{action}': {e.Message}");
            }
        }

        // --- Action Implementations ---

        private static object CreateTexture(JObject @params, bool asSprite)
        {
            string path = @params["path"]?.ToString();
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' is required for create.");

            string imagePath = @params["imagePath"]?.ToString();
            bool hasImage = !string.IsNullOrEmpty(imagePath);

            int width = @params["width"]?.ToObject<int>() ?? 64;
            int height = @params["height"]?.ToObject<int>() ?? 64;
            List<string> warnings = new List<string>();

            // Validate dimensions
            if (!hasImage)
            {
                var dimensionError = ValidateDimensions(width, height, warnings);
                if (dimensionError != null)
                    return dimensionError;
            }

            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
            EnsureDirectoryExists(fullPath);

            try
            {
                var fillColorToken = @params["fillColor"];
                var patternToken = @params["pattern"];
                var pixelsToken = @params["pixels"];

                if (hasImage && (fillColorToken != null || patternToken != null || pixelsToken != null))
                {
                    return new ErrorResponse("imagePath cannot be combined with fillColor, pattern, or pixels.");
                }

                int patternSize = 8;
                if (!hasImage && patternToken != null)
                {
                    patternSize = @params["patternSize"]?.ToObject<int>() ?? 8;
                    if (patternSize <= 0)
                        return new ErrorResponse("patternSize must be greater than 0.");
                }

                Texture2D texture;
                if (hasImage)
                {
                    string resolvedImagePath = ResolveImagePath(imagePath);
                    if (!File.Exists(resolvedImagePath))
                        return new ErrorResponse($"Image file not found at '{imagePath}'.");

                    byte[] imageBytes = File.ReadAllBytes(resolvedImagePath);
                    texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
                    if (!texture.LoadImage(imageBytes))
                    {
                        UnityEngine.Object.DestroyImmediate(texture);
                        return new ErrorResponse($"Failed to load image from '{imagePath}'.");
                    }

                    width = texture.width;
                    height = texture.height;
                    var imageDimensionError = ValidateDimensions(width, height, warnings);
                    if (imageDimensionError != null)
                    {
                        UnityEngine.Object.DestroyImmediate(texture);
                        return imageDimensionError;
                    }
                }
                else
                {
                    texture = new Texture2D(width, height, TextureFormat.RGBA32, false);

                    // Check for fill color
                    if (fillColorToken != null && fillColorToken.Type == JTokenType.Array)
                    {
                        Color32 fillColor = TextureOps.ParseColor32(fillColorToken as JArray);
                        TextureOps.FillTexture(texture, fillColor);
                    }

                    // Check for pattern
                    if (patternToken != null)
                    {
                        string pattern = patternToken.ToString();
                        var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
                        ApplyPatternToTexture(texture, pattern, palette, patternSize);
                    }

                    // Check for direct pixel data
                    if (pixelsToken != null)
                    {
                        TextureOps.ApplyPixelData(texture, pixelsToken, width, height);
                    }

                    // If nothing specified, create transparent texture
                    if (fillColorToken == null && patternToken == null && pixelsToken == null)
                    {
                        TextureOps.FillTexture(texture, new Color32(0, 0, 0, 0));
                    }
                }

                texture.Apply();

                // Save to disk
                byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
                if (imageData == null || imageData.Length == 0)
                {
                    UnityEngine.Object.DestroyImmediate(texture);
                    return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
                }
                File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);

                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);

                // Configure texture importer settings if provided
                JToken importSettingsToken = @params["importSettings"];
                JToken spriteSettingsToken = @params["spriteSettings"];

                if (importSettingsToken != null)
                {
                    ConfigureTextureImporter(fullPath, importSettingsToken);
                }
                else if (asSprite || spriteSettingsToken != null)
                {
                    // Legacy sprite configuration
                    ConfigureAsSprite(fullPath, spriteSettingsToken);
                }

                // Clean up memory
                UnityEngine.Object.DestroyImmediate(texture);
                foreach (var warning in warnings)
                {
                    McpLog.Warn($"[ManageTexture] {warning}");
                }

                return new SuccessResponse(
                    $"Texture created at '{fullPath}' ({width}x{height})" + (asSprite ? " as sprite" : ""),
                    new
                    {
                        path = fullPath,
                        width,
                        height,
                        asSprite = asSprite || spriteSettingsToken != null || (importSettingsToken?["textureType"]?.ToString() == "Sprite"),
                        warnings = warnings.Count > 0 ? warnings : null
                    }
                );
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Failed to create texture: {e.Message}");
            }
        }

        private static object ModifyTexture(JObject @params)
        {
            string path = @params["path"]?.ToString();
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' is required for modify.");

            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
            if (!AssetExists(fullPath))
                return new ErrorResponse($"Texture not found at path: {fullPath}");

            try
            {
                Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(fullPath);
                if (texture == null)
                    return new ErrorResponse($"Failed to load texture at path: {fullPath}");

                // Make the texture readable
                string absolutePath = GetAbsolutePath(fullPath);
                byte[] fileData = File.ReadAllBytes(absolutePath);
                Texture2D editableTexture = new Texture2D(texture.width, texture.height, TextureFormat.RGBA32, false);
                editableTexture.LoadImage(fileData);

                // Apply modifications
                var setPixelsToken = @params["setPixels"] as JObject;
                if (setPixelsToken != null)
                {
                    int x = setPixelsToken["x"]?.ToObject<int>() ?? 0;
                    int y = setPixelsToken["y"]?.ToObject<int>() ?? 0;
                    int w = setPixelsToken["width"]?.ToObject<int>() ?? 1;
                    int h = setPixelsToken["height"]?.ToObject<int>() ?? 1;

                    if (w <= 0 || h <= 0)
                    {
                        UnityEngine.Object.DestroyImmediate(editableTexture);
                        return new ErrorResponse("setPixels width and height must be positive.");
                    }

                    var pixelsToken = setPixelsToken["pixels"];
                    var colorToken = setPixelsToken["color"];

                    if (pixelsToken != null)
                    {
                        TextureOps.ApplyPixelDataToRegion(editableTexture, pixelsToken, x, y, w, h);
                    }
                    else if (colorToken != null)
                    {
                        Color32 color = TextureOps.ParseColor32(colorToken as JArray);
                        int startX = Mathf.Max(0, x);
                        int startY = Mathf.Max(0, y);
                        int endX = Mathf.Min(x + w, editableTexture.width);
                        int endY = Mathf.Min(y + h, editableTexture.height);

                        for (int py = startY; py < endY; py++)
                        {
                            for (int px = startX; px < endX; px++)
                            {
                                editableTexture.SetPixel(px, py, color);
                            }
                        }
                    }
                    else
                    {
                        UnityEngine.Object.DestroyImmediate(editableTexture);
                        return new ErrorResponse("setPixels requires 'color' or 'pixels'.");
                    }
                }

                editableTexture.Apply();

                // Save back to disk
                byte[] imageData = TextureOps.EncodeTexture(editableTexture, fullPath);
                if (imageData == null || imageData.Length == 0)
                {
                    UnityEngine.Object.DestroyImmediate(editableTexture);
                    return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
                }
                File.WriteAllBytes(absolutePath, imageData);

                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);

                UnityEngine.Object.DestroyImmediate(editableTexture);

                return new SuccessResponse($"Texture modified: {fullPath}");
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Failed to modify texture: {e.Message}");
            }
        }

        private static object DeleteTexture(string path)
        {
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' is required for delete.");

            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
            if (!AssetExists(fullPath))
                return new ErrorResponse($"Texture not found at path: {fullPath}");

            try
            {
                bool success = AssetDatabase.DeleteAsset(fullPath);
                if (success)
                    return new SuccessResponse($"Texture deleted: {fullPath}");
                else
                    return new ErrorResponse($"Failed to delete texture: {fullPath}");
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Error deleting texture: {e.Message}");
            }
        }

        private static object ApplyPattern(JObject @params)
        {
            // Reuse CreateTexture with pattern
            return CreateTexture(@params, false);
        }

        private static object ApplyGradient(JObject @params)
        {
            string path = @params["path"]?.ToString();
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' is required for apply_gradient.");

            int width = @params["width"]?.ToObject<int>() ?? 64;
            int height = @params["height"]?.ToObject<int>() ?? 64;
            List<string> warnings = new List<string>();
            var dimensionError = ValidateDimensions(width, height, warnings);
            if (dimensionError != null)
                return dimensionError;
            string gradientType = @params["gradientType"]?.ToString() ?? "linear";
            float angle = @params["gradientAngle"]?.ToObject<float>() ?? 0f;

            var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
            if (palette == null || palette.Count < 2)
            {
                // Default gradient palette
                palette = new List<Color32> { new Color32(0, 0, 0, 255), new Color32(255, 255, 255, 255) };
            }

            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
            EnsureDirectoryExists(fullPath);

            Texture2D texture = null;
            try
            {
                texture = new Texture2D(width, height, TextureFormat.RGBA32, false);

                if (gradientType == "radial")
                {
                    ApplyRadialGradient(texture, palette);
                }
                else
                {
                    ApplyLinearGradient(texture, palette, angle);
                }

                texture.Apply();

                byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
                if (imageData == null || imageData.Length == 0)
                {
                    return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
                }
                File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);

                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);

                // Configure as sprite if requested
                JToken spriteSettingsToken = @params["spriteSettings"];
                if (spriteSettingsToken != null)
                {
                    ConfigureAsSprite(fullPath, spriteSettingsToken);
                }

                foreach (var warning in warnings)
                {
                    McpLog.Warn($"[ManageTexture] {warning}");
                }

                return new SuccessResponse(
                    $"Gradient texture created at '{fullPath}' ({width}x{height})",
                    new
                    {
                        path = fullPath,
                        width,
                        height,
                        gradientType,
                        warnings = warnings.Count > 0 ? warnings : null
                    }
                );
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Failed to create gradient texture: {e.Message}");
            }
            finally
            {
                if (texture != null)
                    UnityEngine.Object.DestroyImmediate(texture);
            }
        }

        private static object ApplyNoise(JObject @params)
        {
            string path = @params["path"]?.ToString();
            if (string.IsNullOrEmpty(path))
                return new ErrorResponse("'path' is required for apply_noise.");

            int width = @params["width"]?.ToObject<int>() ?? 64;
            int height = @params["height"]?.ToObject<int>() ?? 64;
            List<string> warnings = new List<string>();
            var dimensionError = ValidateDimensions(width, height, warnings);
            if (dimensionError != null)
                return dimensionError;
            float scale = @params["noiseScale"]?.ToObject<float>() ?? 0.1f;
            int octaves = @params["octaves"]?.ToObject<int>() ?? 1;
            if (octaves <= 0)
                return new ErrorResponse("octaves must be greater than 0.");
            long noiseWork = (long)width * height * octaves;
            if (noiseWork > MaxNoiseWork)
                warnings.Add($"Noise workload exceeds recommended max {MaxNoiseWork} (got {width}x{height}x{octaves}).");

            var palette = TextureOps.ParsePalette(@params["palette"] as JArray);
            if (palette == null || palette.Count < 2)
            {
                palette = new List<Color32> { new Color32(0, 0, 0, 255), new Color32(255, 255, 255, 255) };
            }

            string fullPath = AssetPathUtility.SanitizeAssetPath(path);
            EnsureDirectoryExists(fullPath);

            Texture2D texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
            try
            {
                ApplyPerlinNoise(texture, palette, scale, octaves);

                texture.Apply();

                byte[] imageData = TextureOps.EncodeTexture(texture, fullPath);
                if (imageData == null || imageData.Length == 0)
                {
                    return new ErrorResponse($"Failed to encode texture for '{fullPath}'");
                }
                File.WriteAllBytes(GetAbsolutePath(fullPath), imageData);

                AssetDatabase.ImportAsset(fullPath, ImportAssetOptions.ForceUpdate);

                // Configure as sprite if requested
                JToken spriteSettingsToken = @params["spriteSettings"];
                if (spriteSettingsToken != null)
                {
                    ConfigureAsSprite(fullPath, spriteSettingsToken);
                }

                foreach (var warning in warnings)
                {
                    McpLog.Warn($"[ManageTexture] {warning}");
                }

                return new SuccessResponse(
                    $"Noise texture created at '{fullPath}' ({width}x{height})",
                    new
                    {
                        path = fullPath,
                        width,
                        height,
                        noiseScale = scale,
                        octaves,
                        warnings = warnings.Count > 0 ? warnings : null
                    }
                );
            }
            catch (Exception e)
            {
                return new ErrorResponse($"Failed to create noise texture: {e.Message}");
            }
            finally
            {
                if (texture != null)
                    UnityEngine.Object.DestroyImmediate(texture);
            }
        }

        // --- Pattern Helpers ---

        private static void ApplyPatternToTexture(Texture2D texture, string pattern, List<Color32> palette, int patternSize)
        {
            if (palette == null || palette.Count == 0)
            {
                palette = new List<Color32> { new Color32(255, 255, 255, 255), new Color32(0, 0, 0, 255) };
            }

            int width = texture.width;
            int height = texture.height;

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    Color32 color = GetPatternColor(x, y, pattern, palette, patternSize, width, height);
                    texture.SetPixel(x, y, color);
                }
            }
        }

        private static Color32 GetPatternColor(int x, int y, string pattern, List<Color32> palette, int size, int width, int height)
        {
            int colorIndex = 0;

            switch (pattern.ToLower())
            {
                case "checkerboard":
                    colorIndex = ((x / size) + (y / size)) % 2;
                    break;

                case "stripes":
                case "stripes_v":
                    colorIndex = (x / size) % palette.Count;
                    break;

                case "stripes_h":
                    colorIndex = (y / size) % palette.Count;
                    break;

                case "stripes_diag":
                    colorIndex = ((x + y) / size) % palette.Count;
                    break;

                case "dots":
                    int cx = (x % (size * 2)) - size;
                    int cy = (y % (size * 2)) - size;
                    bool inDot = (cx * cx + cy * cy) < (size * size / 4);
                    colorIndex = inDot ? 1 : 0;
                    break;

                case "grid":
                    bool onGridLine = (x % size == 0) || (y % size == 0);
                    colorIndex = onGridLine ? 1 : 0;
                    break;

                case "brick":
                    int row = y / size;
                    int offset = (row % 2) * (size / 2);
                    bool onBorder = ((x + offset) % size == 0) || (y % size == 0);
                    colorIndex = onBorder ? 1 : 0;
                    break;

                default:
                    colorIndex = 0;
                    break;
            }

            return palette[Mathf.Clamp(colorIndex, 0, palette.Count - 1)];
        }

        // --- Gradient Helpers ---

        private static void ApplyLinearGradient(Texture2D texture, List<Color32> palette, float angle)
        {
            int width = texture.width;
            int height = texture.height;
            float radians = angle * Mathf.Deg2Rad;
            Vector2 dir = new Vector2(Mathf.Cos(radians), Mathf.Sin(radians));
            float denomX = Mathf.Max(1, width - 1);
            float denomY = Mathf.Max(1, height - 1);

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    float nx = x / denomX;
                    float ny = y / denomY;
                    float t = Vector2.Dot(new Vector2(nx, ny), dir);
                    t = Mathf.Clamp01((t + 1f) / 2f);

                    Color32 color = LerpPalette(palette, t);
                    texture.SetPixel(x, y, color);
                }
            }
        }

        private static void ApplyRadialGradient(Texture2D texture, List<Color32> palette)
        {
            int width = texture.width;
            int height = texture.height;
            float cx = width / 2f;
            float cy = height / 2f;
            float maxDist = Mathf.Sqrt(cx * cx + cy * cy);

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    float dx = x - cx;
                    float dy = y - cy;
                    float dist = Mathf.Sqrt(dx * dx + dy * dy);
                    float t = Mathf.Clamp01(dist / maxDist);

                    Color32 color = LerpPalette(palette, t);
                    texture.SetPixel(x, y, color);
                }
            }
        }

        private static Color32 LerpPalette(List<Color32> palette, float t)
        {
            if (palette.Count == 1) return palette[0];
            if (t <= 0) return palette[0];
            if (t >= 1) return palette[palette.Count - 1];

            float scaledT = t * (palette.Count - 1);
            int index = Mathf.FloorToInt(scaledT);
            float localT = scaledT - index;

            if (index >= palette.Count - 1)
                return palette[palette.Count - 1];

            Color c1 = palette[index];
            Color c2 = palette[index + 1];
            return Color.Lerp(c1, c2, localT);
        }

        // --- Noise Helpers ---

        private static void ApplyPerlinNoise(Texture2D texture, List<Color32> palette, float scale, int octaves)
        {
            int width = texture.width;
            int height = texture.height;

            // Random offset to ensure different patterns
            float offsetX = UnityEngine.Random.Range(0f, 1000f);
            float offsetY = UnityEngine.Random.Range(0f, 1000f);

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    float noiseValue = 0f;
                    float amplitude = 1f;
                    float frequency = 1f;
                    float maxValue = 0f;

                    for (int o = 0; o < octaves; o++)
                    {
                        float sampleX = (x + offsetX) * scale * frequency;
                        float sampleY = (y + offsetY) * scale * frequency;
                        noiseValue += Mathf.PerlinNoise(sampleX, sampleY) * amplitude;
                        maxValue += amplitude;
                        amplitude *= 0.5f;
                        frequency *= 2f;
                    }

                    float t = Mathf.Clamp01(noiseValue / maxValue);
                    Color32 color = LerpPalette(palette, t);
                    texture.SetPixel(x, y, color);
                }
            }
        }

        private static void ConfigureAsSprite(string path, JToken spriteSettings)
        {
            TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
            if (importer == null)
            {
                McpLog.Warn($"[ManageTexture] Could not get TextureImporter for {path}");
                return;
            }

            importer.textureType = TextureImporterType.Sprite;
            importer.spriteImportMode = SpriteImportMode.Single;

            if (spriteSettings != null && spriteSettings.Type == JTokenType.Object)
            {
                var settings = spriteSettings as JObject;

                // Pivot
                var pivotToken = settings["pivot"];
                if (pivotToken is JArray pivotArray && pivotArray.Count >= 2)
                {
                    importer.spritePivot = new Vector2(
                        pivotArray[0].ToObject<float>(),
                        pivotArray[1].ToObject<float>()
                    );
                }

                // Pixels per unit
                var ppuToken = settings["pixelsPerUnit"];
                if (ppuToken != null)
                {
                    importer.spritePixelsPerUnit = ppuToken.ToObject<float>();
                }
            }

            importer.SaveAndReimport();
        }

        private static void ConfigureTextureImporter(string path, JToken importSettings)
        {
            TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
            if (importer == null)
            {
                McpLog.Warn($"[ManageTexture] Could not get TextureImporter for {path}");
                return;
            }

            if (importSettings == null || importSettings.Type != JTokenType.Object)
            {
                return;
            }

            var settings = importSettings as JObject;

            // Texture Type
            var textureTypeToken = settings["textureType"];
            if (textureTypeToken != null)
            {
                string typeStr = textureTypeToken.ToString();
                if (TryParseEnum<TextureImporterType>(typeStr, out var textureType))
                {
                    importer.textureType = textureType;
                }
            }

            // Texture Shape
            var textureShapeToken = settings["textureShape"];
            if (textureShapeToken != null)
            {
                string shapeStr = textureShapeToken.ToString();
                if (TryParseEnum<TextureImporterShape>(shapeStr, out var textureShape))
                {
                    importer.textureShape = textureShape;
                }
            }

            // sRGB
            var srgbToken = settings["sRGBTexture"];
            if (srgbToken != null)
            {
                importer.sRGBTexture = srgbToken.ToObject<bool>();
            }

            // Alpha Source
            var alphaSourceToken = settings["alphaSource"];
            if (alphaSourceToken != null)
            {
                string alphaStr = alphaSourceToken.ToString();
                if (TryParseEnum<TextureImporterAlphaSource>(alphaStr, out var alphaSource))
                {
                    importer.alphaSource = alphaSource;
                }
            }

            // Alpha Is Transparency
            var alphaTransToken = settings["alphaIsTransparency"];
            if (alphaTransToken != null)
            {
                importer.alphaIsTransparency = alphaTransToken.ToObject<bool>();
            }

            // Readable
            var readableToken = settings["isReadable"];
            if (readableToken != null)
            {
                importer.isReadable = readableToken.ToObject<bool>();
            }

            // Mipmaps
            var mipmapToken = settings["mipmapEnabled"];
            if (mipmapToken != null)
            {
                importer.mipmapEnabled = mipmapToken.ToObject<bool>();
            }

            // Mipmap Filter
            var mipmapFilterToken = settings["mipmapFilter"];
            if (mipmapFilterToken != null)
            {
                string filterStr = mipmapFilterToken.ToString();
                if (TryParseEnum<TextureImporterMipFilter>(filterStr, out var mipmapFilter))
                {
                    importer.mipmapFilter = mipmapFilter;
                }
            }

            // Wrap Mode
            var wrapModeToken = settings["wrapMode"];
            if (wrapModeToken != null)
            {
                string wrapStr = wrapModeToken.ToString();
                if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
                {
                    importer.wrapMode = wrapMode;
                }
            }

            // Wrap Mode U
            var wrapModeUToken = settings["wrapModeU"];
            if (wrapModeUToken != null)
            {
                string wrapStr = wrapModeUToken.ToString();
                if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
                {
                    importer.wrapModeU = wrapMode;
                }
            }

            // Wrap Mode V
            var wrapModeVToken = settings["wrapModeV"];
            if (wrapModeVToken != null)
            {
                string wrapStr = wrapModeVToken.ToString();
                if (TryParseEnum<TextureWrapMode>(wrapStr, out var wrapMode))
                {
                    importer.wrapModeV = wrapMode;
                }
            }

            // Filter Mode
            var filterModeToken = settings["filterMode"];
            if (filterModeToken != null)
            {
                string filterStr = filterModeToken.ToString();
                if (TryParseEnum<FilterMode>(filterStr, out var filterMode))
                {
                    importer.filterMode = filterMode;
                }
            }

            // Aniso Level
            var anisoToken = settings["anisoLevel"];
            if (anisoToken != null)
            {
                importer.anisoLevel = anisoToken.ToObject<int>();
            }

            // Max Texture Size
            var maxSizeToken = settings["maxTextureSize"];
            if (maxSizeToken != null)
            {
                importer.maxTextureSize = maxSizeToken.ToObject<int>();
            }

            // Compression
            var compressionToken = settings["textureCompression"];
            if (compressionToken != null)
            {
                string compStr = compressionToken.ToString();
                if (TryParseEnum<TextureImporterCompression>(compStr, out var compression))
                {
                    importer.textureCompression = compression;
                }
            }

            // Crunched Compression
            var crunchedToken = settings["crunchedCompression"];
            if (crunchedToken != null)
            {
                importer.crunchedCompression = crunchedToken.ToObject<bool>();
            }

            // Compression Quality
            var qualityToken = settings["compressionQuality"];
            if (qualityToken != null)
            {
                importer.compressionQuality = qualityToken.ToObject<int>();
            }

            // --- Sprite-specific settings ---

            // Sprite Import Mode
            var spriteModeToken = settings["spriteImportMode"];
            if (spriteModeToken != null)
            {
                string modeStr = spriteModeToken.ToString();
                if (TryParseEnum<SpriteImportMode>(modeStr, out var spriteMode))
                {
                    importer.spriteImportMode = spriteMode;
                }
            }

            // Sprite Pixels Per Unit
            var ppuToken = settings["spritePixelsPerUnit"];
            if (ppuToken != null)
            {
                importer.spritePixelsPerUnit = ppuToken.ToObject<float>();
            }

            // Sprite Pivot
            var pivotToken = settings["spritePivot"];
            if (pivotToken is JArray pivotArray && pivotArray.Count >= 2)
            {
                importer.spritePivot = new Vector2(
                    pivotArray[0].ToObject<float>(),
                    pivotArray[1].ToObject<float>()
                );
            }

            // Apply sprite settings using TextureImporterSettings helper
            TextureImporterSettings importerSettings = new TextureImporterSettings();
            importer.ReadTextureSettings(importerSettings);

            bool settingsChanged = false;

            // Sprite Mesh Type
            var meshTypeToken = settings["spriteMeshType"];
            if (meshTypeToken != null)
            {
                string meshStr = meshTypeToken.ToString();
                if (TryParseEnum<SpriteMeshType>(meshStr, out var meshType))
                {
                    importerSettings.spriteMeshType = meshType;
                    settingsChanged = true;
                }
            }

            // Sprite Extrude
            var extrudeToken = settings["spriteExtrude"];
            if (extrudeToken != null)
            {
                importerSettings.spriteExtrude = (uint)extrudeToken.ToObject<int>();
                settingsChanged = true;
            }
            
            if (settingsChanged)
            {
                importer.SetTextureSettings(importerSettings);
            }

            importer.SaveAndReimport();
        }

        private static bool TryParseEnum<T>(string value, out T result) where T : struct
        {
            // Try exact match first
            if (Enum.TryParse<T>(value, true, out result))
            {
                return true;
            }

            // Try without common prefixes/suffixes
            string cleanValue = value.Replace("_", "").Replace("-", "");
            if (Enum.TryParse<T>(cleanValue, true, out result))
            {
                return true;
            }

            result = default;
            return false;
        }

        private static bool AssetExists(string path)
        {
            return !string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(path));
        }

        private static void EnsureDirectoryExists(string assetPath)
        {
            string directory = Path.GetDirectoryName(assetPath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(GetAbsolutePath(directory)))
            {
                Directory.CreateDirectory(GetAbsolutePath(directory));
                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
            }
        }

        private static string GetAbsolutePath(string assetPath)
        {
            return Path.Combine(Directory.GetCurrentDirectory(), assetPath);
        }

        private static string ResolveImagePath(string imagePath)
        {
            if (Path.IsPathRooted(imagePath))
                return imagePath;

            return Path.Combine(Directory.GetCurrentDirectory(), imagePath);
        }
    }
}