using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEditor;
using UnityEngine;

namespace RunlevelSystems.DevPlus1.EditorTools
{
    [Serializable]
    public class RLProjectAnalysisData
    {
        public string projectName;
        public string unityVersion;
        public string generatedAt;
        public List<RLSceneInfo> scenes = new List<RLSceneInfo>();
        public List<RLScriptInfo> scripts = new List<RLScriptInfo>();
        public List<RLPrefabInfo> prefabs = new List<RLPrefabInfo>();
        public RLGitReportSummary gitReports = new RLGitReportSummary();
        public List<string> suggestedFirstFiles = new List<string>();
        public List<string> risksOrUnknowns = new List<string>();
    }

    [Serializable]
    public class RLSceneInfo
    {
        public string scenePath;
        public string sceneName;
        public int buildIndex = -1;
        public int rootGameObjectCount;
        public int totalGameObjects;
        public int activeGameObjects;
        public int inactiveGameObjects;
        public int missingScriptCount;
        public int missingReferenceCount;
        public List<string> rootGameObjects = new List<string>();
        public List<RLGameObjectInfo> gameObjects = new List<RLGameObjectInfo>();
        public List<RLUnityEventInfo> unityEvents = new List<RLUnityEventInfo>();
        public string notes;
    }

    [Serializable]
    public class RLGameObjectInfo
    {
        public string hierarchyPath;
        public bool activeSelf;
        public string tag;
        public int layer;
        public List<string> components = new List<string>();
        public List<string> attachedScripts = new List<string>();
        public List<string> referencedObjects = new List<string>();
        public int missingScriptCount;
        public int missingReferenceCount;
    }

    [Serializable]
    public class RLScriptInfo
    {
        public string scriptPath;
        public string className;
        public string baseClass;
        public bool isMonoBehaviour;
        public bool isScriptableObject;
        public List<string> lifecycleMethods = new List<string>();
        public List<string> publicMethods = new List<string>();
        public List<string> serializedFields = new List<string>();
        public List<string> publicFields = new List<string>();
        public List<string> unityApiUsage = new List<string>();
        public string possibleRole;
    }

    [Serializable]
    public class RLPrefabInfo
    {
        public string prefabPath;
        public List<string> components = new List<string>();
        public List<string> attachedScripts = new List<string>();
        public List<string> nestedPrefabs = new List<string>();
        public List<string> importantReferences = new List<string>();
        public int missingScriptCount;
        public int missingReferenceCount;
    }

    [Serializable]
    public class RLUnityEventInfo
    {
        public string sourcePath;
        public string gameObjectPath;
        public string componentName;
        public string eventName;
        public string targetObject;
        public string targetComponent;
        public string targetMethod;
    }

    [Serializable]
    public class RLGitReportSummary
    {
        public bool reportsFolderFound;
        public bool validationReportFound;
        public bool validationFoundErrors;
        public int validationWarnings = -1;
        public int validationErrors = -1;
        public bool apiReferenceFound;
        public bool filePurposeFound;
        public bool staticCallMapFound;
        public bool unityScriptReportFound;
        public List<string> likelyEntryPoints = new List<string>();
        public List<string> importantFiles = new List<string>();
        public List<string> foundReports = new List<string>();
        public List<string> missingReports = new List<string>();
        public string notes;
    }

    public static class RLReportExporter
    {
        public const string RootFolder = "Assets/RL_DevPlus1";
        public const string ReportFolder = RootFolder + "/Reports";

        public static void EnsureFolders()
        {
            EnsureAssetFolder("Assets", "RL_DevPlus1");
            EnsureAssetFolder(RootFolder, "Reports");
            EnsureAssetFolder(RootFolder, "Docs");
            EnsureAssetFolder(RootFolder, "Runtime");
        }

        public static string AbsoluteReportFolder
        {
            get { return Path.GetFullPath(Path.Combine(Application.dataPath, "RL_DevPlus1/Reports")); }
        }

        public static void ExportAll(RLProjectAnalysisData data)
        {
            EnsureFolders();
            WriteProjectSummary(data);
            WriteSceneMap(data);
            WriteGameObjectMap(data);
            WriteScriptMap(data);
            WriteEventMap(data);
            WritePrefabMap(data);
            WriteExecutionOrder(data);
            WriteMissingReferences(data);
            WriteGitSummary(data.gitReports);
            WriteProjectDataJson(data);
            WriteAIContext(data);
            WriteReportIndex();
            AssetDatabase.Refresh();
        }

        public static void WriteGitSummary(RLGitReportSummary git)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Git Report Summary");
            sb.AppendLine();
            sb.AppendLine("- Git reports folder found: " + BoolText(git.reportsFolderFound));
            sb.AppendLine("- Validation report found: " + BoolText(git.validationReportFound));
            sb.AppendLine("- Validation found errors: " + BoolText(git.validationFoundErrors));
            sb.AppendLine("- Validation warnings: " + ValueOrUnknown(git.validationWarnings));
            sb.AppendLine("- Validation errors: " + ValueOrUnknown(git.validationErrors));
            sb.AppendLine("- API reference found: " + BoolText(git.apiReferenceFound));
            sb.AppendLine("- File purpose report found: " + BoolText(git.filePurposeFound));
            sb.AppendLine("- Static call map found: " + BoolText(git.staticCallMapFound));
            sb.AppendLine("- Unity script report found: " + BoolText(git.unityScriptReportFound));
            AppendList(sb, "Likely Entry Points From Git Reports", git.likelyEntryPoints);
            AppendList(sb, "Important Files From Git Reports", git.importantFiles);
            AppendList(sb, "Found Reports", git.foundReports);
            AppendList(sb, "Missing Reports", git.missingReports);
            sb.AppendLine("## Notes");
            sb.AppendLine();
            sb.AppendLine(string.IsNullOrEmpty(git.notes) ? "Best-effort import only. Missing Git reports are allowed." : git.notes);
            WriteReport("RL_Unity_Git_Report_Summary.md", sb.ToString());
        }

        private static void WriteProjectSummary(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Project Summary");
            sb.AppendLine();
            sb.AppendLine("- Project name: " + data.projectName);
            sb.AppendLine("- Unity version: " + data.unityVersion);
            sb.AppendLine("- Generated at: " + data.generatedAt);
            sb.AppendLine("- Scenes analyzed: " + data.scenes.Count);
            sb.AppendLine("- Scripts analyzed: " + data.scripts.Count);
            sb.AppendLine("- Prefabs analyzed: " + data.prefabs.Count);
            sb.AppendLine("- Missing scripts detected: " + CountMissingScripts(data));
            sb.AppendLine("- Missing references detected: " + CountMissingReferences(data));
            sb.AppendLine();
            sb.AppendLine("This report is best-effort and needs manual confirmation before project changes are made.");
            WriteReport("RL_Unity_Project_Summary.md", sb.ToString());
        }

        private static void WriteSceneMap(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Scene Map");
            sb.AppendLine();
            foreach (RLSceneInfo scene in data.scenes)
            {
                sb.AppendLine("## " + scene.sceneName);
                sb.AppendLine();
                sb.AppendLine("- Scene path: `" + scene.scenePath + "`");
                sb.AppendLine("- Build index: " + scene.buildIndex);
                sb.AppendLine("- Root GameObjects: " + scene.rootGameObjectCount);
                sb.AppendLine("- Total GameObjects: " + scene.totalGameObjects);
                sb.AppendLine("- Active/Inactive: " + scene.activeGameObjects + "/" + scene.inactiveGameObjects);
                sb.AppendLine("- Missing scripts: " + scene.missingScriptCount);
                sb.AppendLine("- Missing references: " + scene.missingReferenceCount);
                AppendList(sb, "Root GameObjects", scene.rootGameObjects);
                if (!string.IsNullOrEmpty(scene.notes))
                {
                    sb.AppendLine("Notes: " + scene.notes);
                    sb.AppendLine();
                }
            }
            WriteReport("RL_Unity_Scene_Map.md", sb.ToString());
        }

        private static void WriteGameObjectMap(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity GameObject Map");
            sb.AppendLine();
            foreach (RLSceneInfo scene in data.scenes)
            {
                sb.AppendLine("## Scene: " + scene.sceneName);
                sb.AppendLine();
                foreach (RLGameObjectInfo go in scene.gameObjects)
                {
                    sb.AppendLine("- `" + go.hierarchyPath + "` | active=" + go.activeSelf + " | tag=" + go.tag + " | layer=" + go.layer + " | components=" + string.Join(", ", go.components.ToArray()));
                }
                sb.AppendLine();
            }
            WriteReport("RL_Unity_GameObject_Map.md", sb.ToString());
        }

        private static void WriteScriptMap(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Script Map");
            sb.AppendLine();
            foreach (RLScriptInfo script in data.scripts)
            {
                sb.AppendLine("## `" + script.scriptPath + "`");
                sb.AppendLine();
                sb.AppendLine("- Class: " + script.className);
                sb.AppendLine("- Base class: " + script.baseClass);
                sb.AppendLine("- MonoBehaviour: " + BoolText(script.isMonoBehaviour));
                sb.AppendLine("- ScriptableObject: " + BoolText(script.isScriptableObject));
                sb.AppendLine("- Possible role: " + script.possibleRole);
                AppendList(sb, "Lifecycle Methods", script.lifecycleMethods);
                AppendList(sb, "Public Methods", script.publicMethods);
                AppendList(sb, "Serialized Fields", script.serializedFields);
                AppendList(sb, "Public Fields", script.publicFields);
                AppendList(sb, "Unity API Usage", script.unityApiUsage);
            }
            WriteReport("RL_Unity_Script_Map.md", sb.ToString());
        }

        private static void WriteEventMap(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Event Map");
            sb.AppendLine();
            bool any = false;
            foreach (RLSceneInfo scene in data.scenes)
            {
                foreach (RLUnityEventInfo evt in scene.unityEvents)
                {
                    any = true;
                    sb.AppendLine("- Scene `" + scene.scenePath + "` GameObject `" + evt.gameObjectPath + "` component `" + evt.componentName + "` event `" + evt.eventName + "` targets `" + evt.targetObject + "." + evt.targetMethod + "`");
                }
            }
            if (!any)
            {
                sb.AppendLine("No UnityEvent or Button callback bindings detected in analyzed scenes.");
            }
            WriteReport("RL_Unity_Event_Map.md", sb.ToString());
        }

        private static void WritePrefabMap(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Prefab Map");
            sb.AppendLine();
            foreach (RLPrefabInfo prefab in data.prefabs)
            {
                sb.AppendLine("## `" + prefab.prefabPath + "`");
                sb.AppendLine();
                AppendList(sb, "Components", prefab.components);
                AppendList(sb, "Attached Scripts", prefab.attachedScripts);
                AppendList(sb, "Nested Prefabs", prefab.nestedPrefabs);
                AppendList(sb, "Important References", prefab.importantReferences);
                sb.AppendLine("- Missing scripts: " + prefab.missingScriptCount);
                sb.AppendLine("- Missing references: " + prefab.missingReferenceCount);
                sb.AppendLine();
            }
            WriteReport("RL_Unity_Prefab_Map.md", sb.ToString());
        }

        private static void WriteExecutionOrder(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Execution Order");
            sb.AppendLine();
            sb.AppendLine("## Script Execution Order Settings");
            sb.AppendLine();
            bool any = false;
            string[] scriptGuids = AssetDatabase.FindAssets("t:MonoScript");
            foreach (string guid in scriptGuids)
            {
                string path = AssetDatabase.GUIDToAssetPath(guid);
                MonoScript script = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
                if (script == null)
                {
                    continue;
                }

                int order = MonoImporter.GetExecutionOrder(script);
                if (order != 0)
                {
                    any = true;
                    sb.AppendLine("- " + script.name + ": " + order);
                }
            }
            if (!any)
            {
                sb.AppendLine("- No custom script execution order detected.");
            }
            sb.AppendLine();
            sb.AppendLine("## Probable Runtime Order");
            sb.AppendLine();
            sb.AppendLine("- Scene load");
            sb.AppendLine("- Awake");
            sb.AppendLine("- OnEnable");
            sb.AppendLine("- Start");
            sb.AppendLine("- Update / FixedUpdate / LateUpdate");
            sb.AppendLine("- UnityEvents / UI callbacks");
            sb.AppendLine("- Scene transitions");
            AppendList(sb, "Lifecycle Methods By Script", BuildLifecycleLines(data.scripts));
            WriteReport("RL_Unity_Execution_Order.md", sb.ToString());
        }

        private static void WriteMissingReferences(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Missing References");
            sb.AppendLine();
            foreach (RLSceneInfo scene in data.scenes)
            {
                foreach (RLGameObjectInfo go in scene.gameObjects)
                {
                    if (go.missingScriptCount > 0 || go.missingReferenceCount > 0)
                    {
                        sb.AppendLine("- Scene `" + scene.scenePath + "` GameObject `" + go.hierarchyPath + "` missing scripts=" + go.missingScriptCount + " missing references=" + go.missingReferenceCount);
                    }
                }
            }
            foreach (RLPrefabInfo prefab in data.prefabs)
            {
                if (prefab.missingScriptCount > 0 || prefab.missingReferenceCount > 0)
                {
                    sb.AppendLine("- Prefab `" + prefab.prefabPath + "` missing scripts=" + prefab.missingScriptCount + " missing references=" + prefab.missingReferenceCount);
                }
            }
            if (sb.ToString().TrimEnd().EndsWith("References", StringComparison.Ordinal))
            {
                sb.AppendLine("No missing scripts or missing serialized object references detected in analyzed assets.");
            }
            WriteReport("RL_Unity_Missing_References.md", sb.ToString());
        }

        private static void WriteProjectDataJson(RLProjectAnalysisData data)
        {
            WriteReport("RL_Unity_Project_Data.json", JsonUtility.ToJson(data, true));
        }

        private static void WriteAIContext(RLProjectAnalysisData data)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel AI Project Context");
            sb.AppendLine();
            sb.AppendLine("This report is intended to be fed into AI/Codex before deeper Unity project work.");
            sb.AppendLine();
            sb.AppendLine("- Project name: " + data.projectName);
            sb.AppendLine("- Unity version: " + data.unityVersion);
            sb.AppendLine("- Main likely entry scene: " + GetLikelyEntryScene(data));
            sb.AppendLine("- Git validation status: " + (data.gitReports.validationFoundErrors ? "Detected customer code errors" : "No customer code errors detected or report missing"));
            AppendList(sb, "Scenes", SceneLines(data.scenes));
            AppendList(sb, "Important Managers/Controllers", ManagerLines(data.scripts));
            AppendList(sb, "MonoBehaviour Scripts", ScriptLines(data.scripts, true));
            AppendList(sb, "ScriptableObjects", ScriptLines(data.scripts, false));
            AppendList(sb, "Prefabs", PrefabLines(data.prefabs));
            AppendList(sb, "Scene Transitions", UsageLines(data.scripts, "SceneManager"));
            AppendList(sb, "Suggested First Files For AI To Inspect", data.suggestedFirstFiles);
            AppendList(sb, "Suggested Risks Or Unknowns", data.risksOrUnknowns);
            sb.AppendLine("## Limitations");
            sb.AppendLine();
            sb.AppendLine("- Best-effort static and editor inspection only.");
            sb.AppendLine("- Runtime-created objects, reflection, dependency injection, addressable content, and generated code may be incomplete.");
            sb.AppendLine("- Findings need manual confirmation before changes are made.");
            WriteReport("RL_AI_Project_Context.md", sb.ToString());
            WriteReport("RL_AI_Project_Context.json", JsonUtility.ToJson(data, true));
        }

        private static void WriteReportIndex()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("# Runlevel Unity Report Index");
            sb.AppendLine();
            sb.AppendLine("- `RL_Unity_Project_Summary.md`: high-level project counts and status.");
            sb.AppendLine("- `RL_Unity_Scene_Map.md`: scene paths, roots, counts, and missing reference totals.");
            sb.AppendLine("- `RL_Unity_GameObject_Map.md`: GameObject hierarchy and component overview.");
            sb.AppendLine("- `RL_Unity_Script_Map.md`: C# script lifecycle, fields, methods, and Unity API usage.");
            sb.AppendLine("- `RL_Unity_Event_Map.md`: detected UnityEvent and Button callback bindings.");
            sb.AppendLine("- `RL_Unity_Prefab_Map.md`: prefab components, scripts, nested prefabs, and missing references.");
            sb.AppendLine("- `RL_Unity_Execution_Order.md`: script execution order settings and probable lifecycle order.");
            sb.AppendLine("- `RL_Unity_Missing_References.md`: missing scripts and serialized reference issues.");
            sb.AppendLine("- `RL_Unity_Git_Report_Summary.md`: imported root `reports/` summary if available.");
            sb.AppendLine("- `RL_Unity_Project_Data.json`: AI-readable Unity analysis data.");
            sb.AppendLine("- `RL_AI_Project_Context.md`: primary AI/Codex context report.");
            sb.AppendLine("- `RL_AI_Project_Context.json`: machine-readable AI context data.");
            WriteReport("RL_Unity_Report_Index.md", sb.ToString());
        }

        public static void WriteReport(string fileName, string contents)
        {
            EnsureFolders();
            File.WriteAllText(Path.Combine(AbsoluteReportFolder, fileName), contents, Encoding.UTF8);
        }

        public static void RevealReportFolder()
        {
            EnsureFolders();
            EditorUtility.RevealInFinder(AbsoluteReportFolder);
        }

        private static void EnsureAssetFolder(string parent, string child)
        {
            string full = parent + "/" + child;
            if (!AssetDatabase.IsValidFolder(full))
            {
                AssetDatabase.CreateFolder(parent, child);
            }
        }

        private static string BoolText(bool value)
        {
            return value ? "yes" : "no";
        }

        private static string ValueOrUnknown(int value)
        {
            return value >= 0 ? value.ToString() : "unknown";
        }

        private static void AppendList(StringBuilder sb, string title, List<string> values)
        {
            sb.AppendLine("## " + title);
            sb.AppendLine();
            if (values == null || values.Count == 0)
            {
                sb.AppendLine("- None detected.");
            }
            else
            {
                foreach (string value in values)
                {
                    sb.AppendLine("- " + value);
                }
            }
            sb.AppendLine();
        }

        private static int CountMissingScripts(RLProjectAnalysisData data)
        {
            int count = 0;
            foreach (RLSceneInfo scene in data.scenes) count += scene.missingScriptCount;
            foreach (RLPrefabInfo prefab in data.prefabs) count += prefab.missingScriptCount;
            return count;
        }

        private static int CountMissingReferences(RLProjectAnalysisData data)
        {
            int count = 0;
            foreach (RLSceneInfo scene in data.scenes) count += scene.missingReferenceCount;
            foreach (RLPrefabInfo prefab in data.prefabs) count += prefab.missingReferenceCount;
            return count;
        }

        private static List<string> BuildLifecycleLines(List<RLScriptInfo> scripts)
        {
            List<string> lines = new List<string>();
            foreach (RLScriptInfo script in scripts)
            {
                if (script.lifecycleMethods.Count > 0)
                {
                    lines.Add(script.className + ": " + string.Join(", ", script.lifecycleMethods.ToArray()));
                }
            }
            return lines;
        }

        private static string GetLikelyEntryScene(RLProjectAnalysisData data)
        {
            foreach (RLSceneInfo scene in data.scenes)
            {
                if (scene.buildIndex == 0) return scene.scenePath;
            }
            return data.scenes.Count > 0 ? data.scenes[0].scenePath : "No scene analyzed";
        }

        private static List<string> SceneLines(List<RLSceneInfo> scenes)
        {
            List<string> lines = new List<string>();
            foreach (RLSceneInfo scene in scenes) lines.Add(scene.scenePath + " (" + scene.totalGameObjects + " GameObjects)");
            return lines;
        }

        private static List<string> ManagerLines(List<RLScriptInfo> scripts)
        {
            List<string> lines = new List<string>();
            foreach (RLScriptInfo script in scripts)
            {
                string lower = (script.className + " " + script.possibleRole).ToLowerInvariant();
                if (lower.Contains("manager") || lower.Contains("controller"))
                {
                    lines.Add(script.scriptPath + " - " + script.possibleRole);
                }
            }
            return lines;
        }

        private static List<string> ScriptLines(List<RLScriptInfo> scripts, bool monoBehaviour)
        {
            List<string> lines = new List<string>();
            foreach (RLScriptInfo script in scripts)
            {
                if ((monoBehaviour && script.isMonoBehaviour) || (!monoBehaviour && script.isScriptableObject))
                {
                    lines.Add(script.scriptPath + " - " + script.className);
                }
            }
            return lines;
        }

        private static List<string> PrefabLines(List<RLPrefabInfo> prefabs)
        {
            List<string> lines = new List<string>();
            foreach (RLPrefabInfo prefab in prefabs) lines.Add(prefab.prefabPath);
            return lines;
        }

        private static List<string> UsageLines(List<RLScriptInfo> scripts, string usage)
        {
            List<string> lines = new List<string>();
            foreach (RLScriptInfo script in scripts)
            {
                if (script.unityApiUsage.Contains(usage))
                {
                    lines.Add(script.scriptPath);
                }
            }
            return lines;
        }
    }
}