using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;
using UnityObject = UnityEngine.Object;

namespace Amanotes.Core
{
    internal partial class AmaDevSettings
    {
        [SerializeField] internal LogV2Config logV2 = new LogV2Config();

        [Serializable]
        internal class LogV2Config
        {
            public bool enabled = true;
            public bool forceCleanUp;
            public UnityObject codeGenerateFolder;
            public string className = "LogV2";

            [HideInInspector][SerializeField] private string classTemplate =
                "using Debug = UnityEngine.Debug;\n" +
                "using UnityObject = UnityEngine.Object;\n\n" +
                "public partial class $CLASS_NAME$\n" +
                "{\n" +
                "    private static void Log(string tag, string message, UnityObject context)\n" +
                "    {\n" +
                "        Debug.Log($\"[{tag}] {message}\", context);\n" +
                "    }\n\n" +
                "    private static void LogWarning(string tag, string message, UnityObject context)\n" +
                "    {\n" +
                "        Debug.LogWarning($\"[{tag}] {message}\", context);\n" +
                "    }\n\n" +
                "    private static void LogError(string tag, string message, UnityObject context)\n" +
                "    {\n" +
                "        Debug.LogError($\"[{tag}] {message}\", context);\n" +
                "    }\n" +
                "}";

            public List<SymbolInfo> tags = new List<SymbolInfo>();

            public string codeGeneratePath
            {
                get
                {
                    string path = AssetDatabase.GetAssetPath(codeGenerateFolder);
                    if (AssetDatabase.IsValidFolder(path)) return path;
                    var defaultPath = "Assets/Generated/LogV2";
                    var asset = AssetDatabase.LoadAssetAtPath<UnityObject>(defaultPath);
                    if (asset != null) codeGenerateFolder = asset;
                    return defaultPath;
                }
            }

            public void GenerateLogger()
            {
                if (!enabled) return;

                bool hasFolder = Directory.Exists(codeGeneratePath);
                if (hasFolder && forceCleanUp) { Directory.Delete(codeGeneratePath, true); hasFolder = false; }
                if (!hasFolder) Directory.CreateDirectory(codeGeneratePath);

                string filePath = Path.Combine(codeGeneratePath, $"{className}.cs");
                if (!File.Exists(filePath))
                {
                    File.WriteAllText(filePath, classTemplate.Replace("$CLASS_NAME$", className));
                    AssetDatabase.ImportAsset(filePath);
                }

                var validFiles = new HashSet<string> { Path.GetFullPath(filePath) };

                for (var i = 0; i < tags.Count; i++)
                {
                    string tag = tags[i].name;
                    filePath = Path.Combine(codeGeneratePath, $"{className}.{tag}.cs");
                    File.WriteAllText(filePath, GenerateTagClassContent(tag));
                    AssetDatabase.ImportAsset(filePath);
                    validFiles.Add(Path.GetFullPath(filePath));
                }

                CleanStaleFiles(validFiles);
            }

            private void CleanStaleFiles(HashSet<string> validFiles)
            {
                var files = Directory.GetFiles(codeGeneratePath, $"{className}*.cs");
                for (int i = 0; i < files.Length; i++)
                {
                    if (validFiles.Contains(Path.GetFullPath(files[i]))) continue;
                    File.Delete(files[i]);
                    var meta = files[i] + ".meta";
                    if (File.Exists(meta)) File.Delete(meta);
                }
            }

            private string GenerateTagClassContent(string tag)
            {
                return $@"using System.Diagnostics;
using UnityObject = UnityEngine.Object;

public partial class {className}
{{
    public static class {tag}
    {{
        [Conditional(nameof({tag}))]
        public static void Log(string message, UnityObject context = null) => {className}.Log(nameof({tag}), message, context);

        [Conditional(nameof({tag}))]
        public static void LogWarning(string message, UnityObject context = null) => {className}.LogWarning(nameof({tag}), message, context);

        [Conditional(nameof({tag}))]
        public static void LogError(string message, UnityObject context = null) => {className}.LogError(nameof({tag}), message, context);
    }}
}}";
            }
        }
    }
}