using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using AlicizaX.Editor;
using UnityEditor;
using UnityEditorInternal;
using UnityEngine;

namespace AlicizaX.Localization.Editor
{
    internal sealed class LocalizationSettingsProvider : EditorWindow
    {
        private const string WindowTitle = "Localization Settings";
        private const string MenuPath = "AlicizaX/Localization/Open Localization Settings";

        private SerializedObject _serializedObject;
        private SerializedProperty _languageTypes;
        private SerializedProperty _genLangaugeTypePath;
        private SerializedProperty _generateScriptCodeFirstConfig;
        private SerializedProperty _generateLanguageTypesNamespace;
        private SerializedProperty _generateLanguageTypesTemplate;
        private ReorderableList _languageList;
        private readonly List<string> _languagePopupOptions = new();
        private readonly List<string> _originalLanguages = new();
        private readonly List<GameLocaizationTable> _localizationTables = new();

        private Vector2 _scrollPosition;
        private bool _hasUnsavedChanges;

        [MenuItem(MenuPath)]
        private static void Open()
        {
            LocalizationSettingsProvider window = GetWindow<LocalizationSettingsProvider>();
            window.titleContent = new GUIContent(WindowTitle);
            window.minSize = new Vector2(760f, 520f);
            window.Show();
        }

        private void OnEnable()
        {
            InitGUI();
            RefreshLocalizationTables();
        }

        private void OnFocus()
        {
            RefreshLocalizationTables();
        }

        private void OnDisable()
        {
            _serializedObject?.Dispose();
            _serializedObject = null;
            LocalizationConfiguration.Save();
        }

        private void InitGUI()
        {
            LocalizationConfiguration setting = LocalizationConfiguration.Instance;
            _serializedObject?.Dispose();
            _serializedObject = new SerializedObject(setting);
            _languageTypes = _serializedObject.FindProperty("LanguageTypes");
            _genLangaugeTypePath = _serializedObject.FindProperty("_genLangaugeTypePath");
            _generateScriptCodeFirstConfig = _serializedObject.FindProperty("generateScriptCodeFirstConfig");
            _generateLanguageTypesNamespace = _serializedObject.FindProperty("generateLanguageTypesNamespace");
            _generateLanguageTypesTemplate = _serializedObject.FindProperty("generateLanguageTypesTemplate");

            CaptureOriginalLanguages();
            BuildLanguageList();
            RefreshLanguagePopupOptions();
        }

        private void CaptureOriginalLanguages()
        {
            _originalLanguages.Clear();
            if (_languageTypes == null)
            {
                return;
            }

            for (int i = 0; i < _languageTypes.arraySize; i++)
            {
                _originalLanguages.Add(_languageTypes.GetArrayElementAtIndex(i).stringValue);
            }
        }

        private void BuildLanguageList()
        {
            _languageList = new ReorderableList(_serializedObject, _languageTypes,
                draggable: false,
                displayHeader: true,
                displayAddButton: true,
                displayRemoveButton: true);

            _languageList.drawHeaderCallback = rect => { EditorGUI.LabelField(rect, "Language Types"); };

            _languageList.drawElementCallback = (rect, index, isActive, isFocused) =>
            {
                SerializedProperty element = _languageTypes.GetArrayElementAtIndex(index);
                rect.y += 2f;

                bool isBuiltInLanguage = index < 2;
                using (new EditorGUI.DisabledGroupScope(isBuiltInLanguage))
                {
                    EditorGUI.BeginChangeCheck();
                    string newValue = EditorGUI.TextField(
                        new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight),
                        element.stringValue);
                    if (EditorGUI.EndChangeCheck())
                    {
                        element.stringValue = newValue;
                        _hasUnsavedChanges = true;
                    }
                }
            };

            _languageList.onCanRemoveCallback = list => list.index >= 2;

            _languageList.onAddCallback = list =>
            {
                int newIndex = _languageTypes.arraySize;
                _languageTypes.InsertArrayElementAtIndex(newIndex);
                SerializedProperty newElement = _languageTypes.GetArrayElementAtIndex(newIndex);
                newElement.stringValue = "NewLanguage";
                _hasUnsavedChanges = true;
            };

            _languageList.onRemoveCallback = list =>
            {
                if (list.index < 2)
                {
                    EditorUtility.DisplayDialog("Cannot Remove", "The first two languages (ChineseSimplified and English) cannot be removed.", "OK");
                    return;
                }

                _languageTypes.DeleteArrayElementAtIndex(list.index);
                _hasUnsavedChanges = true;
            };
        }

        private void RefreshLanguagePopupOptions()
        {
            _languagePopupOptions.Clear();
            IReadOnlyList<string> languageNames = LocalizationConfiguration.Instance.LanguageTypeNames;
            for (int i = 0; i < languageNames.Count; i++)
            {
                string name = languageNames[i].Or("Unknown");
                _languagePopupOptions.Add(name);
            }
        }

        private void RefreshLocalizationTables()
        {
            _localizationTables.Clear();
            string[] guids = AssetDatabase.FindAssets("t:GameLocaizationTable");
            for (int i = 0; i < guids.Length; i++)
            {
                string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
                GameLocaizationTable table = AssetDatabase.LoadAssetAtPath<GameLocaizationTable>(assetPath);
                if (table != null)
                {
                    _localizationTables.Add(table);
                }
            }
        }

        private void OnGUI()
        {
            if (_serializedObject == null || !_serializedObject.targetObject)
            {
                InitGUI();
            }

            _serializedObject.Update();
            RefreshLanguagePopupOptions();

            EditorGUILayout.Space();
            _scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition);

            DrawLanguageTypesSection();
            EditorGUILayout.Space(8f);
            DrawLanguageTypesGenerateSection();
            EditorGUILayout.Space(8f);
            DrawLocalizationTablesSection();

            EditorGUILayout.EndScrollView();

            if (_serializedObject.ApplyModifiedProperties())
            {
                LocalizationConfiguration.Save();
            }
        }

        private void DrawLanguageTypesSection()
        {
            using (new EditorDrawing.BorderBoxScope(new GUIContent("Language Types"), roundedBox: false))
            {
                _languageList.DoLayoutList();

                EditorGUILayout.Space(10f);
                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();

                using (new EditorGUI.DisabledGroupScope(!_hasUnsavedChanges))
                {
                    if (GUILayout.Button("Save Language Changes", GUILayout.Width(200f), GUILayout.Height(30f)))
                    {
                        ApplyLanguageChanges();
                    }
                }

                GUILayout.FlexibleSpace();
                EditorGUILayout.EndHorizontal();

                if (_hasUnsavedChanges)
                {
                    EditorGUILayout.HelpBox("You have unsaved language changes. Click 'Save Language Changes' to apply them to all GameLocalizationTable assets.", MessageType.Warning);
                }
            }
        }

        private void DrawLanguageTypesGenerateSection()
        {
            using (new EditorDrawing.BorderBoxScope(new GUIContent("Generate LanguageTypes"), roundedBox: false))
            {
                EditorGUILayout.PropertyField(_genLangaugeTypePath, new GUIContent("File Path"));
                EditorGUILayout.PropertyField(_generateLanguageTypesNamespace, new GUIContent("Namespace"));

                EditorDrawing.DrawStringSelectPopup(
                    new GUIContent("生成多语言Key索引文件时的注释首选语言"),
                    new GUIContent("None"),
                    _languagePopupOptions.ToArray(),
                    _generateScriptCodeFirstConfig.stringValue,
                    selected =>
                    {
                        _generateScriptCodeFirstConfig.stringValue = selected;
                        _serializedObject.ApplyModifiedProperties();
                        LocalizationConfiguration.Save();
                    });

                EditorGUILayout.LabelField("Template", EditorStyles.boldLabel);
                EditorGUILayout.HelpBox("Use placeholders: {NAMESPACE_START}, {NAMESPACE_END}, {LANGUAGE_CONSTANTS}, {LANGUAGE_LIST}", MessageType.None);

                EditorGUI.BeginChangeCheck();
                string template = EditorGUILayout.TextArea(_generateLanguageTypesTemplate.stringValue, GUILayout.MinHeight(240f));
                if (EditorGUI.EndChangeCheck())
                {
                    _generateLanguageTypesTemplate.stringValue = template;
                }

                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();

                if (GUILayout.Button("Reset Template", GUILayout.Width(140f)))
                {
                    _generateLanguageTypesTemplate.stringValue = LocalizationConfiguration.DefaultTemplate;
                }

                if (GUILayout.Button("Generate Language Types", GUILayout.Width(180f)))
                {
                    RegenerateLanguageTypes();
                }

                EditorGUILayout.EndHorizontal();
            }
        }

        private void DrawLocalizationTablesSection()
        {
            using (new EditorDrawing.BorderBoxScope(new GUIContent("LocalizationTable"), roundedBox: false))
            {
                if (GUILayout.Button("Refresh LocalizationTable List", GUILayout.Width(220f)))
                {
                    RefreshLocalizationTables();
                }

                EditorGUILayout.Space(4f);

                if (_localizationTables.Count == 0)
                {
                    EditorGUILayout.HelpBox("No LocalizationTable assets found in the project.", MessageType.Info);
                    return;
                }

                for (int i = 0; i < _localizationTables.Count; i++)
                {
                    DrawLocalizationTableEntry(_localizationTables[i], i);
                    if (i < _localizationTables.Count - 1)
                    {
                        EditorGUILayout.Space(6f);
                    }
                }
            }
        }

        private void DrawLocalizationTableEntry(GameLocaizationTable table, int index)
        {
            SerializedObject tableSerializedObject = new SerializedObject(table);
            SerializedProperty pathProperty = tableSerializedObject.FindProperty("GenerateScriptCodePath");
            SerializedProperty namespaceProperty = tableSerializedObject.FindProperty("GenerateScriptCodeNamespace");

            using (new EditorDrawing.BorderBoxScope(new GUIContent($"LocalizationTable {index + 1}"), roundedBox: false))
            {
                using (new EditorGUI.DisabledGroupScope(true))
                {
                    EditorGUILayout.ObjectField("Table", table, typeof(GameLocaizationTable), false);
                }

                tableSerializedObject.Update();
                EditorGUILayout.PropertyField(pathProperty, new GUIContent("Gen Code Path"));
                EditorGUILayout.PropertyField(namespaceProperty, new GUIContent("Namespace"));

                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button("Gen Code", GUILayout.Width(120f)))
                {
                    tableSerializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(table);
                    LocalizationWindowUtility.GenerateCode(table);
                }
                EditorGUILayout.EndHorizontal();

                if (tableSerializedObject.ApplyModifiedProperties())
                {
                    EditorUtility.SetDirty(table);
                    AssetDatabase.SaveAssets();
                }
            }
        }

        private void RegenerateLanguageTypes()
        {
            string filePath = _genLangaugeTypePath.stringValue;
            if (string.IsNullOrWhiteSpace(filePath))
            {
                EditorUtility.DisplayDialog("Invalid Path", "LanguageTypes output path cannot be empty.", "OK");
                return;
            }

            string directory = Path.GetDirectoryName(filePath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            string template = string.IsNullOrEmpty(_generateLanguageTypesTemplate.stringValue)
                ? LocalizationConfiguration.DefaultTemplate
                : _generateLanguageTypesTemplate.stringValue;

            string generatedCode = BuildLanguageTypesCode(template, _generateLanguageTypesNamespace.stringValue, LocalizationConfiguration.Instance.LanguageTypeNames);
            File.WriteAllText(filePath, generatedCode, Encoding.UTF8);
            AssetDatabase.Refresh();
        }

        private static string BuildLanguageTypesCode(string template, string namespaceName, IReadOnlyList<string> languages)
        {
            StringBuilder constantsBuilder = new StringBuilder();
            StringBuilder listBuilder = new StringBuilder();

            for (int i = 0; i < languages.Count; i++)
            {
                string languageName = languages[i];
                constantsBuilder.AppendLine($"    public const string {languageName} = \"{languageName}\";");
                listBuilder.AppendLine($"        \"{languageName}\",");
            }

            string namespaceStart = string.IsNullOrWhiteSpace(namespaceName)
                ? string.Empty
                : $"namespace {namespaceName}{Environment.NewLine}{{{Environment.NewLine}";
            string namespaceEnd = string.IsNullOrWhiteSpace(namespaceName)
                ? string.Empty
                : $"{Environment.NewLine}}}";

            return template
                .Replace("{NAMESPACE_START}", namespaceStart)
                .Replace("{NAMESPACE_END}", namespaceEnd)
                .Replace("{LANGUAGE_CONSTANTS}", constantsBuilder.ToString().TrimEnd())
                .Replace("{LANGUAGE_LIST}", listBuilder.ToString().TrimEnd());
        }

        private void ApplyLanguageChanges()
        {
            List<string> currentLanguages = new List<string>();
            for (int i = 0; i < _languageTypes.arraySize; i++)
            {
                currentLanguages.Add(_languageTypes.GetArrayElementAtIndex(i).stringValue);
            }

            List<string> addedLanguages = new List<string>();
            List<string> removedLanguages = new List<string>();
            Dictionary<string, string> renamedLanguages = new Dictionary<string, string>();

            foreach (string lang in currentLanguages)
            {
                if (!_originalLanguages.Contains(lang))
                {
                    addedLanguages.Add(lang);
                }
            }

            foreach (string lang in _originalLanguages)
            {
                if (!currentLanguages.Contains(lang))
                {
                    removedLanguages.Add(lang);
                }
            }

            for (int i = 0; i < Mathf.Min(_originalLanguages.Count, currentLanguages.Count); i++)
            {
                if (_originalLanguages[i] != currentLanguages[i])
                {
                    if (!addedLanguages.Contains(currentLanguages[i]) && !removedLanguages.Contains(_originalLanguages[i]))
                    {
                        renamedLanguages[_originalLanguages[i]] = currentLanguages[i];
                    }
                }
            }

            string[] guids = AssetDatabase.FindAssets("t:GameLocaizationTable");
            int tablesUpdated = 0;

            foreach (string guid in guids)
            {
                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                GameLocaizationTable table = AssetDatabase.LoadAssetAtPath<GameLocaizationTable>(assetPath);

                if (table == null)
                {
                    continue;
                }

                bool tableModified = false;

                foreach (KeyValuePair<string, string> rename in renamedLanguages)
                {
                    LocalizationLanguage language = table.Languages.Find(lang => lang.LanguageName == rename.Key);
                    if (language != null)
                    {
                        language.LanguageName = rename.Value;
                        language.name = rename.Value;
                        tableModified = true;
                    }
                }

                foreach (string newLang in addedLanguages)
                {
                    if (table.Languages.Exists(lang => lang.LanguageName == newLang))
                    {
                        continue;
                    }

                    LocalizationLanguage newLanguage = ScriptableObject.CreateInstance<LocalizationLanguage>();
                    newLanguage.name = newLang;
                    newLanguage.LanguageName = newLang;
                    newLanguage.Strings = new List<LocalizationLanguage.LocalizationString>();

                    foreach (GameLocaizationTable.TableData section in table.TableSheet)
                    {
                        foreach (GameLocaizationTable.SheetItem item in section.SectionSheet)
                        {
                            string sectionKey = section.SectionName.Replace(" ", string.Empty);
                            string itemKey = item.Key.Replace(" ", string.Empty);
                            string fullKey = sectionKey + "." + itemKey;

                            newLanguage.Strings.Add(new LocalizationLanguage.LocalizationString
                            {
                                SectionId = section.Id,
                                EntryId = item.Id,
                                Key = fullKey,
                                Value = string.Empty
                            });
                        }
                    }

                    AssetDatabase.AddObjectToAsset(newLanguage, table);
                    table.Languages.Add(newLanguage);
                    tableModified = true;
                }

                foreach (string removedLang in removedLanguages)
                {
                    LocalizationLanguage languageToDelete = table.Languages.Find(lang => lang.LanguageName == removedLang);
                    if (languageToDelete != null)
                    {
                        table.Languages.Remove(languageToDelete);
                        UnityEngine.Object.DestroyImmediate(languageToDelete, true);
                        tableModified = true;
                    }
                }

                if (tableModified)
                {
                    EditorUtility.SetDirty(table);
                    tablesUpdated++;
                }
            }

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

            _originalLanguages.Clear();
            _originalLanguages.AddRange(currentLanguages);
            _hasUnsavedChanges = false;
            RefreshLocalizationTables();

            if (addedLanguages.Count > 0)
            {
                Debug.Log($"Added {addedLanguages.Count} language(s) to {tablesUpdated} table(s): {string.Join(", ", addedLanguages)}");
            }

            if (removedLanguages.Count > 0)
            {
                Debug.Log($"Removed {removedLanguages.Count} language(s) from {tablesUpdated} table(s): {string.Join(", ", removedLanguages)}");
            }

            if (renamedLanguages.Count > 0)
            {
                Debug.Log($"Renamed {renamedLanguages.Count} language(s) in {tablesUpdated} table(s)");
            }

            EditorUtility.DisplayDialog("Success", $"Language changes applied to {tablesUpdated} GameLocalizationTable(s).", "OK");
        }
    }
}