using System.IO;
using UnityEditor;
using UnityEngine;

namespace MCPForUnity.Editor.Helpers
{
    /// <summary>
    /// Manages package lifecycle events including first-time installation,
    /// version updates, and legacy installation detection.
    /// Consolidates the functionality of PackageInstaller and PackageDetector.
    /// </summary>
    [InitializeOnLoad]
    public static class PackageLifecycleManager
    {
        private const string VersionKeyPrefix = "MCPForUnity.InstalledVersion:";
        private const string LegacyInstallFlagKey = "MCPForUnity.ServerInstalled"; // For migration
        private const string InstallErrorKeyPrefix = "MCPForUnity.InstallError:"; // Stores last installation error

        static PackageLifecycleManager()
        {
            // Schedule the check for after Unity is fully loaded
            EditorApplication.delayCall += CheckAndInstallServer;
        }

        private static void CheckAndInstallServer()
        {
            try
            {
                string currentVersion = GetPackageVersion();
                string versionKey = VersionKeyPrefix + currentVersion;
                bool hasRunForThisVersion = EditorPrefs.GetBool(versionKey, false);

                // Check for conditions that require installation/verification
                bool isFirstTimeInstall = !EditorPrefs.HasKey(LegacyInstallFlagKey) && !hasRunForThisVersion;
                bool legacyPresent = LegacyRootsExist();
                bool canonicalMissing = !File.Exists(
                    Path.Combine(ServerInstaller.GetServerPath(), "server.py")
                );

                // Run if: first install, version update, legacy detected, or canonical missing
                if (isFirstTimeInstall || !hasRunForThisVersion || legacyPresent || canonicalMissing)
                {
                    PerformInstallation(currentVersion, versionKey, isFirstTimeInstall);
                }
            }
            catch (System.Exception ex)
            {
                McpLog.Info($"Package lifecycle check failed: {ex.Message}. Open Window > MCP For Unity if needed.", always: false);
            }
        }

        private static void PerformInstallation(string version, string versionKey, bool isFirstTimeInstall)
        {
            string error = null;

            try
            {
                ServerInstaller.EnsureServerInstalled();

                // Mark as installed for this version
                EditorPrefs.SetBool(versionKey, true);

                // Migrate legacy flag if this is first time
                if (isFirstTimeInstall)
                {
                    EditorPrefs.SetBool(LegacyInstallFlagKey, true);
                }

                // Clean up old version keys (keep only current version)
                CleanupOldVersionKeys(version);

                // Clean up legacy preference keys
                CleanupLegacyPrefs();

                // Only log success if server was actually embedded and copied
                if (ServerInstaller.HasEmbeddedServer() && isFirstTimeInstall)
                {
                    McpLog.Info("MCP server installation completed successfully.");
                }
            }
            catch (System.Exception ex)
            {
                error = ex.Message;

                // Store the error for display in the UI, but don't mark as handled
                // This allows the user to manually rebuild via the "Rebuild Server" button
                string errorKey = InstallErrorKeyPrefix + version;
                EditorPrefs.SetString(errorKey, ex.Message ?? "Unknown error");
                
                // Don't mark as installed - user needs to manually rebuild
            }

            if (!string.IsNullOrEmpty(error))
            {
                McpLog.Info($"Server installation failed: {error}. Use Window > MCP For Unity > Rebuild Server to retry.", always: false);
            }
        }

        private static string GetPackageVersion()
        {
            try
            {
                var info = UnityEditor.PackageManager.PackageInfo.FindForAssembly(
                    typeof(PackageLifecycleManager).Assembly
                );
                if (info != null && !string.IsNullOrEmpty(info.version))
                {
                    return info.version;
                }
            }
            catch { }

            // Fallback to embedded server version
            return GetEmbeddedServerVersion();
        }

        private static string GetEmbeddedServerVersion()
        {
            try
            {
                if (ServerPathResolver.TryFindEmbeddedServerSource(out var embeddedSrc))
                {
                    var versionPath = Path.Combine(embeddedSrc, "server_version.txt");
                    if (File.Exists(versionPath))
                    {
                        return File.ReadAllText(versionPath)?.Trim() ?? "unknown";
                    }
                }
            }
            catch { }
            return "unknown";
        }

        private static bool LegacyRootsExist()
        {
            try
            {
                string home = System.Environment.GetFolderPath(
                    System.Environment.SpecialFolder.UserProfile
                ) ?? string.Empty;

                string[] legacyRoots =
                {
                    Path.Combine(home, ".config", "UnityMCP", "UnityMcpServer", "src"),
                    Path.Combine(home, ".local", "share", "UnityMCP", "UnityMcpServer", "src")
                };

                foreach (var root in legacyRoots)
                {
                    try
                    {
                        if (File.Exists(Path.Combine(root, "server.py")))
                        {
                            return true;
                        }
                    }
                    catch { }
                }
            }
            catch { }
            return false;
        }

        private static void CleanupOldVersionKeys(string currentVersion)
        {
            try
            {
                // Get all EditorPrefs keys that start with our version prefix
                // Note: Unity doesn't provide a way to enumerate all keys, so we can only
                // clean up known legacy keys. Future versions will be cleaned up when
                // a newer version runs.
                // This is a best-effort cleanup.
            }
            catch { }
        }

        private static void CleanupLegacyPrefs()
        {
            try
            {
                // Clean up old preference keys that are no longer used
                string[] legacyKeys =
                {
                    "MCPForUnity.ServerSrc",
                    "MCPForUnity.PythonDirOverride",
                    "MCPForUnity.LegacyDetectLogged" // Old prefix without version
                };

                foreach (var key in legacyKeys)
                {
                    try
                    {
                        if (EditorPrefs.HasKey(key))
                        {
                            EditorPrefs.DeleteKey(key);
                        }
                    }
                    catch { }
                }
            }
            catch { }
        }

        /// <summary>
        /// Gets the last installation error for the current package version, if any.
        /// Returns null if there was no error or the error has been cleared.
        /// </summary>
        public static string GetLastInstallError()
        {
            try
            {
                string currentVersion = GetPackageVersion();
                string errorKey = InstallErrorKeyPrefix + currentVersion;
                if (EditorPrefs.HasKey(errorKey))
                {
                    return EditorPrefs.GetString(errorKey, null);
                }
            }
            catch { }
            return null;
        }

        /// <summary>
        /// Clears the last installation error. Should be called after a successful manual rebuild.
        /// </summary>
        public static void ClearLastInstallError()
        {
            try
            {
                string currentVersion = GetPackageVersion();
                string errorKey = InstallErrorKeyPrefix + currentVersion;
                if (EditorPrefs.HasKey(errorKey))
                {
                    EditorPrefs.DeleteKey(errorKey);
                }
            }
            catch { }
        }
    }
}