using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json.Linq;
using UnityEditor;
using UnityEngine;

#if UNITY_VFX_GRAPH
using UnityEngine.VFX;
#endif

namespace MCPForUnity.Editor.Tools.Vfx
{
    /// <summary>
    /// Asset management operations for VFX Graph.
    /// Handles creating, assigning, and listing VFX assets.
    /// Requires com.unity.visualeffectgraph package and UNITY_VFX_GRAPH symbol.
    /// </summary>
    internal static class VfxGraphAssets
    {
#if !UNITY_VFX_GRAPH
        public static object CreateAsset(JObject @params)
        {
            return new { success = false, message = "VFX Graph package (com.unity.visualeffectgraph) not installed" };
        }

        public static object AssignAsset(JObject @params)
        {
            return new { success = false, message = "VFX Graph package (com.unity.visualeffectgraph) not installed" };
        }

        public static object ListTemplates(JObject @params)
        {
            return new { success = false, message = "VFX Graph package (com.unity.visualeffectgraph) not installed" };
        }

        public static object ListAssets(JObject @params)
        {
            return new { success = false, message = "VFX Graph package (com.unity.visualeffectgraph) not installed" };
        }
#else
        private static readonly string[] SupportedVfxGraphVersions = { "12.1" };

        /// <summary>
        /// Creates a new VFX Graph asset file from a template.
        /// </summary>
        public static object CreateAsset(JObject @params)
        {
            string assetName = @params["assetName"]?.ToString();
            string folderPath = @params["folderPath"]?.ToString() ?? "Assets/VFX";
            string template = @params["template"]?.ToString() ?? "empty";

            if (string.IsNullOrEmpty(assetName))
            {
                return new { success = false, message = "assetName is required" };
            }

            string versionError = ValidateVfxGraphVersion();
            if (!string.IsNullOrEmpty(versionError))
            {
                return new { success = false, message = versionError };
            }

            // Ensure folder exists
            if (!AssetDatabase.IsValidFolder(folderPath))
            {
                string[] folders = folderPath.Split('/');
                string currentPath = folders[0];
                for (int i = 1; i < folders.Length; i++)
                {
                    string newPath = currentPath + "/" + folders[i];
                    if (!AssetDatabase.IsValidFolder(newPath))
                    {
                        AssetDatabase.CreateFolder(currentPath, folders[i]);
                    }
                    currentPath = newPath;
                }
            }

            string assetPath = $"{folderPath}/{assetName}.vfx";

            // Check if asset already exists
            if (AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(assetPath) != null)
            {
                bool overwrite = @params["overwrite"]?.ToObject<bool>() ?? false;
                if (!overwrite)
                {
                    return new { success = false, message = $"Asset already exists at {assetPath}. Set overwrite=true to replace." };
                }
                AssetDatabase.DeleteAsset(assetPath);
            }

            // Find template asset and copy it
            string templatePath = FindTemplate(template);
            string templateAssetPath = TryGetAssetPathFromFileSystem(templatePath);
            VisualEffectAsset newAsset = null;

            if (!string.IsNullOrEmpty(templateAssetPath))
            {
                // Copy the asset to create a new VFX Graph asset
                if (!AssetDatabase.CopyAsset(templateAssetPath, assetPath))
                {
                    return new { success = false, message = $"Failed to copy VFX template from {templateAssetPath}" };
                }
                AssetDatabase.Refresh();
                newAsset = AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(assetPath);
            }
            else
            {
                return new { success = false, message = "VFX template not found. Add a .vfx template asset or install VFX Graph templates." };
            }

            if (newAsset == null)
            {
                return new { success = false, message = "Failed to create VFX asset. Try using a template from list_templates." };
            }

            return new
            {
                success = true,
                message = $"Created VFX asset: {assetPath}",
                data = new
                {
                    assetPath = assetPath,
                    assetName = newAsset.name,
                    template = template
                }
            };
        }

        /// <summary>
        /// Finds VFX template path by name.
        /// </summary>
        private static string FindTemplate(string templateName)
        {
            // Get the actual filesystem path for the VFX Graph package using PackageManager API
            var packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath("Packages/com.unity.visualeffectgraph");

            var searchPaths = new List<string>();

            if (packageInfo != null)
            {
                // Use the resolved path from PackageManager (handles Library/PackageCache paths)
                searchPaths.Add(System.IO.Path.Combine(packageInfo.resolvedPath, "Editor/Templates"));
                searchPaths.Add(System.IO.Path.Combine(packageInfo.resolvedPath, "Samples"));
            }

            // Also search project-local paths
            searchPaths.Add("Assets/VFX/Templates");

            string[] templatePatterns = new[]
            {
                $"{templateName}.vfx",
                $"VFX{templateName}.vfx",
                $"Simple{templateName}.vfx",
                $"{templateName}VFX.vfx"
            };

            foreach (string basePath in searchPaths)
            {
                string searchRoot = basePath;
                if (basePath.StartsWith("Assets/"))
                {
                    searchRoot = System.IO.Path.Combine(UnityEngine.Application.dataPath, basePath.Substring("Assets/".Length));
                }

                if (!System.IO.Directory.Exists(searchRoot))
                {
                    continue;
                }

                foreach (string pattern in templatePatterns)
                {
                    string[] files = System.IO.Directory.GetFiles(searchRoot, pattern, System.IO.SearchOption.AllDirectories);
                    if (files.Length > 0)
                    {
                        return files[0];
                    }
                }

                // Also search by partial match
                try
                {
                    string[] allVfxFiles = System.IO.Directory.GetFiles(searchRoot, "*.vfx", System.IO.SearchOption.AllDirectories);
                    foreach (string file in allVfxFiles)
                    {
                        if (System.IO.Path.GetFileNameWithoutExtension(file).ToLower().Contains(templateName.ToLower()))
                        {
                            return file;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"Failed to search VFX templates under '{searchRoot}': {ex.Message}");
                }
            }

            // Search in project assets
            string[] guids = AssetDatabase.FindAssets("t:VisualEffectAsset " + templateName);
            if (guids.Length > 0)
            {
                string assetPath = AssetDatabase.GUIDToAssetPath(guids[0]);
                // Convert asset path (e.g., "Assets/...") to absolute filesystem path
                if (!string.IsNullOrEmpty(assetPath) && assetPath.StartsWith("Assets/"))
                {
                    return System.IO.Path.Combine(UnityEngine.Application.dataPath, assetPath.Substring("Assets/".Length));
                }
                if (!string.IsNullOrEmpty(assetPath) && assetPath.StartsWith("Packages/"))
                {
                    var info = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath);
                    if (info != null)
                    {
                        string relPath = assetPath.Substring(("Packages/" + info.name + "/").Length);
                        return System.IO.Path.Combine(info.resolvedPath, relPath);
                    }
                }
                return null;
            }

            return null;
        }

        /// <summary>
        /// Assigns a VFX asset to a VisualEffect component.
        /// </summary>
        public static object AssignAsset(JObject @params)
        {
            VisualEffect vfx = VfxGraphCommon.FindVisualEffect(@params);
            if (vfx == null)
            {
                return new { success = false, message = "VisualEffect component not found" };
            }

            string assetPath = @params["assetPath"]?.ToString();
            if (string.IsNullOrEmpty(assetPath))
            {
                return new { success = false, message = "assetPath is required" };
            }

            // Validate and normalize path
            // Reject absolute paths, parent directory traversal, and backslashes
            if (assetPath.Contains("\\") || assetPath.Contains("..") || System.IO.Path.IsPathRooted(assetPath))
            {
                return new { success = false, message = "Invalid assetPath: traversal and absolute paths are not allowed" };
            }

            if (assetPath.StartsWith("Packages/"))
            {
                return new { success = false, message = "Invalid assetPath: VFX assets must live under Assets/." };
            }

            if (!assetPath.StartsWith("Assets/"))
            {
                assetPath = "Assets/" + assetPath;
            }
            if (!assetPath.EndsWith(".vfx"))
            {
                assetPath += ".vfx";
            }

            // Verify the normalized path doesn't escape the project
            string fullPath = System.IO.Path.Combine(UnityEngine.Application.dataPath, assetPath.Substring("Assets/".Length));
            string canonicalProjectRoot = System.IO.Path.GetFullPath(UnityEngine.Application.dataPath);
            string canonicalAssetPath = System.IO.Path.GetFullPath(fullPath);
            if (!canonicalAssetPath.StartsWith(canonicalProjectRoot + System.IO.Path.DirectorySeparatorChar) &&
                canonicalAssetPath != canonicalProjectRoot)
            {
                return new { success = false, message = "Invalid assetPath: would escape project directory" };
            }

            var asset = AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(assetPath);
            if (asset == null)
            {
                // Try searching by name
                string searchName = System.IO.Path.GetFileNameWithoutExtension(assetPath);
                string[] guids = AssetDatabase.FindAssets($"t:VisualEffectAsset {searchName}");
                if (guids.Length > 0)
                {
                    assetPath = AssetDatabase.GUIDToAssetPath(guids[0]);
                    asset = AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(assetPath);
                }
            }

            if (asset == null)
            {
                return new { success = false, message = $"VFX asset not found: {assetPath}" };
            }

            Undo.RecordObject(vfx, "Assign VFX Asset");
            vfx.visualEffectAsset = asset;
            EditorUtility.SetDirty(vfx);

            return new
            {
                success = true,
                message = $"Assigned VFX asset '{asset.name}' to {vfx.gameObject.name}",
                data = new
                {
                    gameObject = vfx.gameObject.name,
                    assetName = asset.name,
                    assetPath = assetPath
                }
            };
        }

        /// <summary>
        /// Lists available VFX templates.
        /// </summary>
        public static object ListTemplates(JObject @params)
        {
            var templates = new List<object>();
            var seenPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            // Get the actual filesystem path for the VFX Graph package using PackageManager API
            var packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath("Packages/com.unity.visualeffectgraph");

            var searchPaths = new List<string>();

            if (packageInfo != null)
            {
                // Use the resolved path from PackageManager (handles Library/PackageCache paths)
                searchPaths.Add(System.IO.Path.Combine(packageInfo.resolvedPath, "Editor/Templates"));
                searchPaths.Add(System.IO.Path.Combine(packageInfo.resolvedPath, "Samples"));
            }

            // Also search project-local paths
            searchPaths.Add("Assets/VFX/Templates");
            searchPaths.Add("Assets/VFX");

            // Precompute normalized package path for comparison
            string normalizedPackagePath = null;
            if (packageInfo != null)
            {
                normalizedPackagePath = packageInfo.resolvedPath.Replace("\\", "/");
            }

            // Precompute the Assets base path for converting absolute paths to project-relative
            string assetsBasePath = Application.dataPath.Replace("\\", "/");

            foreach (string basePath in searchPaths)
            {
                if (!System.IO.Directory.Exists(basePath))
                {
                    continue;
                }

                try
                {
                    string[] vfxFiles = System.IO.Directory.GetFiles(basePath, "*.vfx", System.IO.SearchOption.AllDirectories);
                    foreach (string file in vfxFiles)
                    {
                        string absolutePath = file.Replace("\\", "/");
                        string name = System.IO.Path.GetFileNameWithoutExtension(file);
                        bool isPackage = normalizedPackagePath != null && absolutePath.StartsWith(normalizedPackagePath);

                        // Convert absolute path to project-relative path
                        string projectRelativePath;
                        if (isPackage)
                        {
                            // For package paths, convert to Packages/... format
                            projectRelativePath = "Packages/" + packageInfo.name + absolutePath.Substring(normalizedPackagePath.Length);
                        }
                        else if (absolutePath.StartsWith(assetsBasePath))
                        {
                            // For project assets, convert to Assets/... format
                            projectRelativePath = "Assets" + absolutePath.Substring(assetsBasePath.Length);
                        }
                        else
                        {
                            // Fallback: use the absolute path if we can't determine the relative path
                            projectRelativePath = absolutePath;
                        }

                        string normalizedPath = projectRelativePath.Replace("\\", "/");
                        if (seenPaths.Add(normalizedPath))
                        {
                            templates.Add(new { name = name, path = projectRelativePath, source = isPackage ? "package" : "project" });
                        }
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"Failed to list VFX templates under '{basePath}': {ex.Message}");
                }
            }

            // Also search project assets
            string[] guids = AssetDatabase.FindAssets("t:VisualEffectAsset");
            foreach (string guid in guids)
            {
                string path = AssetDatabase.GUIDToAssetPath(guid);
                string normalizedPath = path.Replace("\\", "/");
                if (seenPaths.Add(normalizedPath))
                {
                    string name = System.IO.Path.GetFileNameWithoutExtension(path);
                    templates.Add(new { name = name, path = path, source = "project" });
                }
            }

            return new
            {
                success = true,
                data = new
                {
                    count = templates.Count,
                    templates = templates
                }
            };
        }

        /// <summary>
        /// Lists all VFX assets in the project.
        /// </summary>
        public static object ListAssets(JObject @params)
        {
            string searchFolder = @params["folder"]?.ToString();
            string searchPattern = @params["search"]?.ToString();

            string filter = "t:VisualEffectAsset";
            if (!string.IsNullOrEmpty(searchPattern))
            {
                filter += " " + searchPattern;
            }

            string[] guids;
            if (!string.IsNullOrEmpty(searchFolder))
            {
                if (searchFolder.Contains("\\") || searchFolder.Contains("..") || System.IO.Path.IsPathRooted(searchFolder))
                {
                    return new { success = false, message = "Invalid folder: traversal and absolute paths are not allowed" };
                }

                if (searchFolder.StartsWith("Packages/"))
                {
                    return new { success = false, message = "Invalid folder: VFX assets must live under Assets/." };
                }

                if (!searchFolder.StartsWith("Assets/"))
                {
                    searchFolder = "Assets/" + searchFolder;
                }

                string fullPath = System.IO.Path.Combine(UnityEngine.Application.dataPath, searchFolder.Substring("Assets/".Length));
                string canonicalProjectRoot = System.IO.Path.GetFullPath(UnityEngine.Application.dataPath);
                string canonicalSearchFolder = System.IO.Path.GetFullPath(fullPath);
                if (!canonicalSearchFolder.StartsWith(canonicalProjectRoot + System.IO.Path.DirectorySeparatorChar) &&
                    canonicalSearchFolder != canonicalProjectRoot)
                {
                    return new { success = false, message = "Invalid folder: would escape project directory" };
                }

                guids = AssetDatabase.FindAssets(filter, new[] { searchFolder });
            }
            else
            {
                guids = AssetDatabase.FindAssets(filter);
            }

            var assets = new List<object>();
            foreach (string guid in guids)
            {
                string path = AssetDatabase.GUIDToAssetPath(guid);
                var asset = AssetDatabase.LoadAssetAtPath<VisualEffectAsset>(path);
                if (asset != null)
                {
                    assets.Add(new
                    {
                        name = asset.name,
                        path = path,
                        guid = guid
                    });
                }
            }

            return new
            {
                success = true,
                data = new
                {
                    count = assets.Count,
                    assets = assets
                }
            };
        }

        private static string ValidateVfxGraphVersion()
        {
            var info = UnityEditor.PackageManager.PackageInfo.FindForAssetPath("Packages/com.unity.visualeffectgraph");
            if (info == null)
            {
                return "VFX Graph package (com.unity.visualeffectgraph) not installed";
            }

            if (IsVersionSupported(info.version))
            {
                return null;
            }

            string supported = string.Join(", ", SupportedVfxGraphVersions.Select(version => $"{version}.x"));
            return $"Unsupported VFX Graph version {info.version}. Supported versions: {supported}.";
        }

        private static bool IsVersionSupported(string installedVersion)
        {
            if (string.IsNullOrEmpty(installedVersion))
            {
                return false;
            }

            string normalized = installedVersion;
            int suffixIndex = normalized.IndexOfAny(new[] { '-', '+' });
            if (suffixIndex >= 0)
            {
                normalized = normalized.Substring(0, suffixIndex);
            }

            if (!Version.TryParse(normalized, out Version installed))
            {
                return false;
            }

            foreach (string supported in SupportedVfxGraphVersions)
            {
                if (!Version.TryParse(supported, out Version target))
                {
                    continue;
                }

                if (installed.Major == target.Major && installed.Minor == target.Minor)
                {
                    return true;
                }
            }

            return false;
        }

        private static string TryGetAssetPathFromFileSystem(string templatePath)
        {
            if (string.IsNullOrEmpty(templatePath))
            {
                return null;
            }

            string normalized = templatePath.Replace("\\", "/");
            string assetsRoot = Application.dataPath.Replace("\\", "/");

            if (normalized.StartsWith(assetsRoot + "/"))
            {
                return "Assets/" + normalized.Substring(assetsRoot.Length + 1);
            }

            var packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath("Packages/com.unity.visualeffectgraph");
            if (packageInfo != null)
            {
                string packageRoot = packageInfo.resolvedPath.Replace("\\", "/");
                if (normalized.StartsWith(packageRoot + "/"))
                {
                    return "Packages/" + packageInfo.name + "/" + normalized.Substring(packageRoot.Length + 1);
                }
            }

            return null;
        }
#endif
    }
}