using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Collections.Generic;
using System.Collections;
using UnityEngine;
using Newtonsoft.Json.Linq;
using System.Linq;
using Sirenix.OdinInspector;
using UnityEditor;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class GoogleSheetManager : Singleton<GoogleSheetManager>
{
    [BoxGroup("기본 설정")] [Tooltip("true: google sheet, false: local json")] [SerializeField]
    private bool _isAccessGoogleSheet = true;

    [BoxGroup("기본 설정")]
    [Tooltip("구글 시트 -> 확장 프로그램 -> Apps Script -> 새 배포(웹 앱) or 배포 관리 -> 웹 앱 URL(~~~/exec)")]
    [SerializeField]
    private string _googleSheetUrl;

    [BoxGroup("기본 설정")]
    [Tooltip("적용시킬 시트의 이름을 적고, 여러 개의 시트를 적는 경우 '/'로 구분지어 시트 나열\nex) \"Sheet1/Sheet2\"")]
    [SerializeField]
    private string _availSheets = "Sheet1/Sheet2";

    [BoxGroup("기본 설정")] [Tooltip("Class, Json, So 생성 위치 \"/GenerateGoogleSheet\"")] [SerializeField]
    private string _generateFolderPath = "/0.Datas/02.Scripts/GenerateGoogleSheet/AutoCreated";

    [Title("버전 복구")] [BoxGroup("버전 복구")] [Tooltip("마지막 업데이트 시간")] [SerializeField, ReadOnly]
    private string _lastUpdated;

#if UNITY_EDITOR
    [BoxGroup("버전 복구")] [SerializeField, ValueDropdown(nameof(GetVersionOptions))]
    private int _restoreIndex;
#endif

    [Title("데이터 변경")]
    [BoxGroup("데이터 변경")]
    [LabelText("수정자 이름")]
    [SerializeField, Required("반드시 수정자 이름을 입력해야 합니다\n이력을 남길 때 표시될 사용자 이름입니다.")]
    private string _editorName;

    private string JsonPath => $"{Application.dataPath}{_generateFolderPath}/GoogleSheetJson.json";

    private const string ChangeLogPath = "Assets/0.Datas/02.Scripts/GenerateGoogleSheet/Logs/GoogleSheetChangeLog.asset";

    private string[] _availSheetArray;
    private string _json;
    
    [SerializeField, ReadOnly]
    private bool _refreshTrigger;
    private bool _alreadyCreatedSo;

    public static async Task<T> LoadSo<T>() where T : ScriptableObject
    {
        await Addressables.InitializeAsync().Task;

        string key = typeof(T).Name;
        var handle = Addressables.LoadAssetAsync<T>(key);
        await handle.Task;

        if (handle.Status == AsyncOperationStatus.Succeeded)
            return handle.Result;

        Debug.LogError($"[GoogleSheetManager] Addressable 로드 실패: {key}");
        return null;
    }

#if UNITY_EDITOR || DEVELOPMENT_BUILD
    [BoxGroup("데이터 변경")]
    [Button("데이터 최신화"), EnableIf(nameof(CanFetchData))]
    private async void FetchGoogleSheet()
    {
        _availSheetArray = _availSheets.Split('/');

        var prevLog = AssetDatabase.LoadAssetAtPath<GoogleSheetChangeLog>(ChangeLogPath);
        string previousJson = prevLog?.Logs.LastOrDefault()?.JsonSnapshot ?? "";

        if (_isAccessGoogleSheet)
        {
            if (!IsValidGoogleSheetUrl(_googleSheetUrl))
            {
                Debug.LogError("Google Sheet URL이 유효하지 않습니다.");
                return;
            }

            Debug.Log("구글 시트 데이터 읽는 중...");
            _json = await LoadDataGoogleSheet(_googleSheetUrl);
        }
        else
        {
            Debug.Log("Local Json 파일 읽는 중...");
            _json = LoadDataLocalJson();
        }

        if (_json == null)
        {
            Debug.Log("Json is null. 최신화 실패");
            return;
        }

        var diffs = GoogleSheetFetchHelper.CompareJsonDiff(previousJson, _json);
        if (diffs.Count > 0)
            GoogleSheetDiffViewer.ShowWindow(diffs);

        bool isJsonSaved = SaveFileOrSkip(JsonPath, _json);
        GenerateClassFilesPerSheet(_json);

        _lastUpdated = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

        if (isJsonSaved)
        {
            _refreshTrigger = true;
            SaveChangeLog(_json);
            EditorPrefs.SetBool("GoogleSheetManager_ShouldCreateSO", true);
            AssetDatabase.Refresh();
        }
    }

    private bool CanFetchData()
    {
        return !string.IsNullOrWhiteSpace(_editorName);
    }

    /// <summary>
    /// Json 로그 저장 
    /// </summary>
    private void SaveChangeLog(string json)
    {
        string logsDirectory = Path.GetDirectoryName(ChangeLogPath);
        if (!Directory.Exists(logsDirectory))
        {
            Directory.CreateDirectory(logsDirectory);
            AssetDatabase.ImportAsset(logsDirectory);
        }
        
        var log = AssetDatabase.LoadAssetAtPath<GoogleSheetChangeLog>(ChangeLogPath);
        if (log == null)
        {
            log = ScriptableObject.CreateInstance<GoogleSheetChangeLog>();
            AssetDatabase.CreateAsset(log, ChangeLogPath);
        }

        string previousJson = log.Logs.Count > 0 ? log.Logs[^1].JsonSnapshot : null;

        // 차이 비교
        if (!string.IsNullOrEmpty(previousJson))
        {
            string diffResult = GoogleSheetDiffHelper.GenerateDiff(previousJson, json);
            Debug.Log(diffResult);
        }

        string saveTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        log.Logs.Add(new GoogleSheetChangeLog.LogEntry
        {
            Editor = _editorName,
            Timestamp = saveTime,
            JsonSnapshot = json
        });

        EditorUtility.SetDirty(log);
        AssetDatabase.SaveAssets();
        SaveJsonBackup(json, saveTime);
        _editorName = null;
    }

    /// <summary>
    /// Json 백업
    /// </summary>
    private void SaveJsonBackup(string json, string saveTime)
    {
        string safeSaveTime = saveTime.Replace(":", "-"); // 윈도우 파일 이름 안전 처리
        string folderPath = Path.Combine(Application.dataPath, "0.Datas/02.Scripts/GenerateGoogleSheet/Backups");

        if (!Directory.Exists(folderPath))
            Directory.CreateDirectory(folderPath);

        string fileName = $"{safeSaveTime} by {_editorName}.json";
        string filePath = Path.Combine(folderPath, fileName);

        File.WriteAllText(filePath, json);
    }

    [BoxGroup("버전 복구")]
    [Button("선택한 버전과 현재 비교")]
    private void CompareWithSelectedVersion()
    {
        var log = AssetDatabase.LoadAssetAtPath<GoogleSheetChangeLog>(ChangeLogPath);
        if (log == null || _restoreIndex < 0 || _restoreIndex >= log.Logs.Count)
        {
            Debug.LogWarning("비교할 수 있는 로그가 없습니다.");
            return;
        }

        string restoreJson = log.Logs[_restoreIndex].JsonSnapshot;
        string currentJson = File.Exists(JsonPath) ? File.ReadAllText(JsonPath) : "";

        List<GoogleSheetDiff> diffs = GoogleSheetFetchHelper.CompareJsonDiff(currentJson, restoreJson);

        if (diffs.Count > 0)
        {
            GoogleSheetDiffViewer.ShowWindow(diffs, true); // 현재 → 선택 버전
            Debug.Log("[GoogleSheetManager] 선택한 버전과 현재 버전 간의 변경점을 표시합니다.");
        }
        else
        {
            Debug.Log("[GoogleSheetManager] 변경점 없음.");
        }
    }

    [BoxGroup("버전 복구")]
    [Button("선택한 버전으로 복구")]
    private void RestoreSelectedVersion()
    {
        var log = AssetDatabase.LoadAssetAtPath<GoogleSheetChangeLog>(ChangeLogPath);
        if (log == null || _restoreIndex < 0 || _restoreIndex >= log.Logs.Count)
        {
            Debug.LogWarning("복원할 수 있는 로그가 없습니다.");
            return;
        }

        string restoreJson = log.Logs[_restoreIndex].JsonSnapshot;
        string currentJson = File.Exists(JsonPath) ? File.ReadAllText(JsonPath) : "";

        List<GoogleSheetDiff> diffs = GoogleSheetFetchHelper.CompareJsonDiff(currentJson, restoreJson);

        if (diffs.Count > 0)
            GoogleSheetDiffViewer.ShowWindow(diffs); // 변경 전 → 변경 후

        // 복원 처리
        _json = restoreJson;

        SaveFileOrSkip(JsonPath, _json);
        CreateGoogleSheetSo();
        _lastUpdated = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

        Debug.Log($"[{log.Logs[_restoreIndex].Editor}]의 버전으로 복원 완료");
    }

    /// <summary>
    /// 버전 로그 드롭다운 함수
    /// </summary>
    private IEnumerable<ValueDropdownItem<int>> GetVersionOptions()
    {
        var log = AssetDatabase.LoadAssetAtPath<GoogleSheetChangeLog>(ChangeLogPath);
        if (log == null)
            yield break;

        for (int i = 0; i < log.Logs.Count; i++)
        {
            yield return new ValueDropdownItem<int>(
                $"{i} - {log.Logs[i].Timestamp} by {log.Logs[i].Editor}", i);
        }
    }

    /// <summary>
    /// 구글 시트 데이터 읽어오기
    /// </summary>
    private async Task<string> LoadDataGoogleSheet(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            try
            {
                byte[] dataBytes = await client.GetByteArrayAsync(url);
                return Encoding.UTF8.GetString(dataBytes);
            }
            catch (HttpRequestException e)
            {
                Debug.LogError($"Request error: {e.Message}");
                return null;
            }
        }
    }

    /// <summary>
    /// jSON 데이터 파일 읽어오기
    /// </summary>
    private string LoadDataLocalJson()
    {
        if (File.Exists(JsonPath))
        {
            return File.ReadAllText(JsonPath);
        }

        Debug.Log($"Json 파일이 존재하지 않습니다\n{JsonPath}");
        return null;
    }

    /// <summary>
    /// 파일 생성 및 비교
    /// </summary>
    private bool SaveFileOrSkip(string path, string contents)
    {
        string directoryPath = Path.GetDirectoryName(path);
        if (!Directory.Exists(directoryPath))
        {
            Directory.CreateDirectory(directoryPath);
        }

        if (File.Exists(path) && File.ReadAllText(path).Equals(contents))
            return false;

        File.WriteAllText(path, contents);
        return true;
    }

    private bool IsExistAvailSheets(string sheetName)
    {
        return Array.Exists(_availSheetArray, x => x == sheetName);
    }

    /// <summary>
    /// 유효한 구글 웹 앱 URL인지 확인
    /// </summary>
    private bool IsValidGoogleSheetUrl(string url)
    {
        return !string.IsNullOrEmpty(url)
               && url.StartsWith("https://script.google.com/macros/")
               && url.EndsWith("/exec");
    }

    private void GenerateClassFilesPerSheet(string jsonInput)
    {
        JObject jsonObject = JObject.Parse(jsonInput);
        string basePath = $"Assets{_generateFolderPath}";

        // enum 후보 수집
        Dictionary<string, HashSet<string>> enumCandidates = new();
        foreach (var jObject in jsonObject)
        {
            string className = jObject.Key;
            if (!IsExistAvailSheets(className)) continue;
            var items = (JArray)jObject.Value;
            if (items.Count < 2) continue;

            for (int i = 1; i < items.Count; i++)
            {
                foreach (var property in ((JObject)items[i]).Properties())
                {
                    string rawName = property.Name;
                    if (!rawName.Contains("_Enum")) continue;

                    string[] parts = rawName.Split(':');
                    string enumTypeName =
                        parts.Length > 1 ? parts[1].Replace("_Enum", "") : rawName.Replace("_Enum", "");
                    string enumValue = NormalizeEnumKey(property.Value.ToString());

                    if (!enumCandidates.ContainsKey(enumTypeName))
                        enumCandidates[enumTypeName] = new();

                    enumCandidates[enumTypeName].Add(enumValue);
                }
            }
        }

        // EnumTypes.cs 생성
        StringBuilder enumCode = new();
        enumCode.AppendLine("// <auto-generated>");
        enumCode.AppendLine("using System;\n");

        foreach (var kvp in enumCandidates)
        {
            enumCode.AppendLine($"public enum {kvp.Key} \n{{");
            enumCode.AppendLine("    None = 0,");
            int index = 1;
            foreach (string value in kvp.Value)
            {
                if (!string.IsNullOrWhiteSpace(value) && value != "None")
                    enumCode.AppendLine($"    {value} = {index++},");
            }

            enumCode.AppendLine("}\n");
        }

        File.WriteAllText($"{basePath}/EnumTypes.cs", enumCode.ToString());
        AssetDatabase.ImportAsset($"{basePath}/EnumTypes.cs");

        // 시트별 클래스 파일 생성
        foreach (var jObject in jsonObject)
        {
            string className = jObject.Key;
            if (!IsExistAvailSheets(className)) continue;
            var items = (JArray)jObject.Value;
            if (items.Count < 2) continue;

            string dataCode = GenerateDataClassCode(className, items);
            string soCode = GenerateSoClassCode(className);

            string dataPath = $"{basePath}/{className}.cs";
            string soPath = $"{basePath}/{className}So.cs";

            File.WriteAllText(dataPath, dataCode);
            File.WriteAllText(soPath, soCode);

            AssetDatabase.ImportAsset(dataPath);
            AssetDatabase.ImportAsset(soPath);
        }
    }

    private string GenerateSoClassCode(string className)
    {
        return
            $"// <auto-generated> File: {className}So.cs\n" +
            "using System.Collections.Generic;\n" +
            "using UnityEngine;\n\n" +
            $"[CreateAssetMenu(fileName = \"{className}So\", menuName = \"GoogleSheet/{className}So\")]\n" +
            $"public class {className}So : ScriptableObject \n" +
            $"{{\n    public List<{className}> {className}List;\n}}\n";
    }

    private string GenerateDataClassCode(string className, JArray items)
    {
        var commentRow = (JObject)items[0];
        var sampleRow = (JObject)items[1];

        StringBuilder sb = new();
        sb.AppendLine("// <auto-generated>");
        sb.AppendLine("using System;");
        sb.AppendLine("using UnityEngine;");

        sb.AppendLine("[Serializable]");
        sb.AppendLine($"public class {className} \n{{");

        int count = sampleRow.Properties().Count();
        string[] types = new string[count];
        string[] names = new string[count];
        string[] tooltips = new string[count];

        foreach (JToken item in items.Skip(1))
        {
            int i = 0;
            foreach (var prop in ((JObject)item).Properties())
            {
                string rawName = prop.Name;
                string propType = GetCSharpType(prop.Value.Type);
                string fieldName, enumName;

                if (rawName.Contains(":") && rawName.EndsWith("_Enum"))
                {
                    string[] parts = rawName.Split(':');
                    fieldName = parts[0];
                    enumName = parts[1].Replace("_Enum", "");
                    types[i] = enumName;
                    names[i] = fieldName;
                }
                else if (rawName.EndsWith("_Enum"))
                {
                    fieldName = rawName.Replace("_Enum", "");
                    enumName = fieldName;
                    types[i] = enumName;
                    names[i] = fieldName;
                }
                else
                {
                    types[i] ??= propType;
                    names[i] ??= rawName;
                }

                tooltips[i] ??= commentRow.TryGetValue(rawName, out var tip) ? tip.ToString() : "";
                i++;
            }
        }

        for (int i = 0; i < count; i++)
        {
            if (!string.IsNullOrWhiteSpace(tooltips[i]))
            {
                sb.AppendLine($"    /// <summary>{tooltips[i]}</summary>");
                sb.AppendLine($"    [Tooltip(\"{tooltips[i]}\")]");
            }

            sb.AppendLine($"    public {types[i]} {names[i]};\n");
        }

        sb.AppendLine("}");
        return sb.ToString();
    }

    private string GetCSharpType(JTokenType jsonType)
    {
        switch (jsonType)
        {
            case JTokenType.Integer:
                return "int";
            case JTokenType.Float:
                return "float";
            case JTokenType.Boolean:
                return "bool";
            default:
                return "string";
        }
    }

    private bool CreateGoogleSheetSo()
    {
        JObject jsonObject = JObject.Parse(_json);
        bool allSuccess = true;

        foreach (var sheetPair in jsonObject)
        {
            string sheetName = sheetPair.Key;
            if (!IsExistAvailSheets(sheetName))
                continue;

            // 1. 데이터 클래스 및 SO 클래스 타입 찾기
            Type dataType = FindTypeByName(sheetName);
            Type soType = FindTypeByName($"{sheetName}So");

            if (dataType == null || soType == null)
            {
                Debug.LogError($"[GoogleSheetManager] 타입을 찾을 수 없습니다: {sheetName} 또는 {sheetName}So");
                allSuccess = false;
                continue;
            }

            // 2. SO 경로 설정 및 불러오기 / 생성
            string soDirectory = $"Assets{_generateFolderPath}/So";
            if (!Directory.Exists(soDirectory))
            {
                Directory.CreateDirectory(soDirectory);
                AssetDatabase.ImportAsset(soDirectory);
            }

            string soPath = $"{soDirectory}/{sheetName}So.asset";
            
            ScriptableObject soInstance = AssetDatabase.LoadAssetAtPath<ScriptableObject>(soPath);
            if (soInstance == null)
            {
                soInstance = ScriptableObject.CreateInstance(soType);
                AssetDatabase.CreateAsset(soInstance, soPath);
            }
            GoogleSheetAddressableAutoSetup.AutoRegisterSo(soPath);

            // 3. 데이터 파싱
            IList list = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(dataType));
            var dataArray = (JArray)sheetPair.Value;

            for (int i = 1; i < dataArray.Count; i++) // 0번은 주석이므로 제외
            {
                JObject item = (JObject)dataArray[i];
                object dataInstance = Activator.CreateInstance(dataType);

                foreach (var prop in item.Properties())
                {
                    string rawName = prop.Name;
                    string fieldName = rawName.Contains(":") ? rawName.Split(':')[0] : rawName;

                    FieldInfo field = dataType.GetField(fieldName,
                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

                    if (field == null)
                    {
                        Debug.LogWarning($"[GoogleSheetManager] 필드 누락: {dataType.Name}.{fieldName}");
                        continue;
                    }

                    try
                    {
                        object value;
                        if (field.FieldType.IsEnum)
                        {
                            string enumRaw = prop.Value.ToString();
                            string formatted = NormalizeEnumKey(enumRaw);
                            value = Enum.TryParse(field.FieldType, formatted, out var parsed)
                                ? parsed
                                : Activator.CreateInstance(field.FieldType);
                        }
                        else
                        {
                            value = Convert.ChangeType(prop.Value.ToString(), field.FieldType);
                        }

                        field.SetValue(dataInstance, value);
                    }
                    catch (Exception e)
                    {
                        Debug.LogWarning(
                            $"[GoogleSheetManager] 값 할당 실패: {fieldName} = {prop.Value} ({field.FieldType}) → {e.Message}");
                    }
                }

                list.Add(dataInstance);
            }

            // 4. SO의 필드에 리스트 할당
            FieldInfo listField = soType.GetField($"{sheetName}List",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            if (listField != null)
            {
                listField.SetValue(soInstance, list);
                EditorUtility.SetDirty(soInstance);
            }
            else
            {
                Debug.LogError($"[GoogleSheetManager] {soType.Name}에 {sheetName}List 필드가 없습니다.");
                allSuccess = false;
            }
        }

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
        Debug.Log("✅ 시트별 ScriptableObject 생성 및 데이터 반영 완료");

        return allSuccess;
    }

    private Type FindTypeByName(string name)
    {
        return AppDomain.CurrentDomain.GetAssemblies()
            .SelectMany(a => a.GetTypes())
            .FirstOrDefault(t => t.Name == name);
    }

    private string NormalizeEnumKey(string input)
    {
        string validName = System.Text.RegularExpressions.Regex.Replace(input, @"[^a-zA-Z0-9_]", "_");
        if (char.IsDigit(validName[0]))
            validName = "_" + validName;
        return char.ToUpper(validName[0]) + validName.Substring(1);
    }

    private void OnValidate()
    {
        if (_refreshTrigger && !_alreadyCreatedSo)
        {
            _refreshTrigger = false;
            _alreadyCreatedSo = true;
            DelayedSoCreation();
        }
    }

    private void DelayedSoCreation()
    {
        if (CreateGoogleSheetSo())
        {
            Debug.Log("Fetch done. SO 업데이트 완료");
        }
        else
        {
            Debug.LogWarning("[GoogleSheetManager] SO 생성 실패. 수동으로 Fetch를 다시 시도하세요.");
        }
    }

    [BoxGroup("데이터 변경")]
    [Button("런타임 중 데이터 재적용")]
    public void ReloadRuntimeData()
    {
        StartCoroutine(ReloadRoutine());
    }

    private IEnumerator ReloadRoutine()
    {
        _availSheetArray = _availSheets.Split('/');

        if (_isAccessGoogleSheet)
        {
            var task = LoadDataGoogleSheet(_googleSheetUrl);
            yield return new WaitUntil(() => task.IsCompleted);
            _json = task.Result;
        }
        else
        {
            _json = LoadDataLocalJson();
        }

        if (!string.IsNullOrEmpty(_json))
        {
            CreateGoogleSheetSo();
            Debug.Log("런타임 데이터 재적용 완료");
        }
    }
    
    public void CreateSoAfterScriptReload()
    {
        if (_json != null)
        {
            Debug.Log("[GoogleSheetManager] Script Reload 이후 SO 생성 실행");
            CreateGoogleSheetSo();
        }
    }
#endif
}