AutoTranslate_EditorWindow.cs

using EqualchanceGames.Tools.Helpers;
using EqualchanceGames.Tools.GUIPro;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using UnityEditor;
using UnityEngine;
using EqualchanceGames.Tools.AutoTranslate.Editor;
using UnityEngine.Localization;
using EqualchanceGames.Tools.FactoryTranslate;
using EqualchanceGames.Tools.InterfaceTranslate;
using System.Threading;

namespace EqualchanceGames.Tools.AutoTranslate.Windows
{
	public class AutoTranslate_EditorWindow : BaseLocalization_EditorWindow
    {
        // Window parameters
        protected const string k_WindowTitle = "Auto Translate for Unity Localization";

        // EditorPrefs key for saving language selection
        private const string PREF_KEY_SELECTED_LANGUAGES = "AutoTranslate_SelectedLanguages";

        // Arguments for execute
        private TranslateParameters _translateParameters = new TranslateParameters();

        // Error
        private bool _isErrorTooManyRequests = false;
        private DateTime _diedLineErrorTooManyRequests;
        private double _timeNeedForWaitErrorMinute = 10;
        private bool _isErrorConnection = false;
        private CheckListGUI _checkListStringTable;
        private CheckListGUI _checkListLanguages;
        private bool LS = false;
        private bool WLS = false;
        private ITranslateApi translator;
        private Vector2 _position = Vector2.zero;
        private float MinChar = 0;
        private float MaxChar = 1000;

        [MenuItem("Auto Localization/Auto Translate for String Tables", false, MyProjectSettings_AutoTranslate.BaseIndex + 1)]
        public static void ShowWindow()
        {
            Type gameview = typeof(UnityEditor.EditorWindow).Assembly.GetType("UnityEditor.GameView");
            AutoTranslate_EditorWindow window = GetWindow<AutoTranslate_EditorWindow>(k_WindowTitle, true, typeof(SceneView), gameview);
            window.titleContent = new GUIContent(k_WindowTitle, EditorIcons.AutoTranslate);
            window.Show();
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            _isErrorConnection = WebInformation.IsConnectedToInternet();

            // Load saved preferences
            _translateParameters.LoadPrefs();

            if (_sharedStringTables != null)
                _checkListStringTable = new CheckListGUI(_sharedStringTables.Select(w => w.TableCollectionName).ToList());
            else
                _checkListStringTable = new CheckListGUI(new List<string>());

            _checkListStringTable.Width = 100;
            _checkListStringTable.Height = 1000;

            if (_locales != null)
            {
                _checkListLanguages = new CheckListGUI(_locales.Select(w => w.name).ToList());
                _checkListLanguages.UpdateCheck(new List<string>() { _dropdownLanguages.Selected }, false, false);
            }
            else
                _checkListLanguages = new CheckListGUI(new List<string>());
            _checkListLanguages.Height = 600;
            _checkListLanguages.MinHeight = 500;

            // Load saved language selection
            LoadSelectedLanguages();

            _dropdownLanguages.UpdateSelected += DropdownLanguages_UpdateSelected;

            AutoTranslateSetting setting = AutoTranslateSetting.GetOrCreateSettings();
            translator = FactoryTranslateApi.GetTranslateApi(setting.CurrentServiceTranslate);
        }

        private void DropdownLanguages_UpdateSelected(string name)
        {
            _selectedLocale = _locales.First(w => w.LocaleName == _dropdownLanguages.Selected);
            _checkListLanguages.FillElements(_locales.Select(w => w.name).ToList());
            _checkListLanguages.UpdateCheck(new List<string>() { name }, false, false);
        }

        protected override void OnFocus()
        {
            base.OnFocus();
            _isErrorConnection = WebInformation.IsConnectedToInternet();

            if (_sharedStringTables != null)
            {
                if (_checkListStringTable != null) 
                {
                    _checkListStringTable.Update(_sharedStringTables.Select(w => w.TableCollectionName).ToList());
                }
                else
                {
                    _checkListStringTable = new CheckListGUI(_sharedStringTables.Select(w => w.TableCollectionName).ToList());
                }
            }
            if (_locales != null)
            {
                // Exclude Pseudo-Locale
                _checkListLanguages = new CheckListGUI(_locales.Where(w => !w.name.Contains("Pseudo-Locale")).Select(w => w.name).ToList());
                if (_dropdownLanguages != null) _checkListLanguages.UpdateCheck(new List<string>() { _dropdownLanguages.Selected }, false, false);
                
                // Load saved language selection
                LoadSelectedLanguages();
            }

            AutoTranslateSetting setting = AutoTranslateSetting.GetOrCreateSettings();
            translator = FactoryTranslateApi.GetTranslateApi(setting.CurrentServiceTranslate);
        }

        void OnGUI()
        {
            ShowNameWindow(k_WindowTitle);
            //EditorGUIUtility.labelWidth = k_SeparationWidth;

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.BeginVertical(GUILayout.MaxWidth(350), GUILayout.ExpandHeight(true));
            EditorGUILayout.LabelField("Selected collection tables for translation:");
            _checkListStringTable.DrawButtons();
            EditorGUILayout.EndVertical();
            EditorGUILayout.BeginVertical(GUILayout.ExpandHeight(true));
            _dropdownLanguages.Draw();
            if ( _selectedLocale != null && translator.ValidateLocale(_selectedLocale.Identifier.Code) == false)
            {
                EditorGUILayout.HelpBox(translator.GetNameService() + " service does not support some dialects of languages, the choice of language will be changed to the generally accepted.", MessageType.Warning);
            }

            bool newCanOverrideWords = LinesGUI.DrawLineToggle("Override words that have a translation", _translateParameters.canOverrideWords, k_SeparationWidth);
            bool newCanTranslateEmptyWords = LinesGUI.DrawLineToggle("Translate words that don't have a translation", _translateParameters.canTranslateEmptyWords, k_SeparationWidth);
            bool newCanTranslateSmartWords = LinesGUI.DrawLineToggle("Translate smart words", _translateParameters.canTranslateSmartWords, k_SeparationWidth);

            // Save preferences when values change
            if (newCanOverrideWords != _translateParameters.canOverrideWords ||
                newCanTranslateEmptyWords != _translateParameters.canTranslateEmptyWords ||
                newCanTranslateSmartWords != _translateParameters.canTranslateSmartWords)
            {
                _translateParameters.canOverrideWords = newCanOverrideWords;
                _translateParameters.canTranslateEmptyWords = newCanTranslateEmptyWords;
                _translateParameters.canTranslateSmartWords = newCanTranslateSmartWords;
                _translateParameters.SavePrefs();
            }
            //EditorGUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
            //EditorGUILayout.LabelField("Translate words that contain chars", GUILayout.Width(k_SeparationWidth));
            //int minchar = (int)MinChar;
            //int maxchar = (int)MaxChar;
            //EditorGUILayout.LabelField(minchar.ToString("G"), GUILayout.Width(30));
            //EditorGUILayout.MinMaxSlider(ref MinChar, ref MaxChar, 0, 1000);
            //EditorGUILayout.LabelField(maxchar.ToString("G"), GUILayout.Width(30));
            //EditorGUILayout.EndHorizontal();
            

            GUILayout.Space(10);

            // Exclude Pseudo-Locale
            int countLocales = _locales?.Count(w => !w.name.Contains("Pseudo-Locale")) ?? 0;
            EditorGUILayout.HelpBox("  Found " + countLocales + " languages" +
                "\n  Found " + _sharedStringTables?.Count + " table collection" + 
                "\n  Found " + _stringTables?.Count + " string tables" + 
                "\n  Found " + _assetTables?.Count + " asset tables", MessageType.Info);

            if ( _isErrorConnection ) EditorGUILayout.HelpBox("No internet connection", MessageType.Error);

            if ( _isErrorTooManyRequests )
            {
                TimeSpan leftTime = _diedLineErrorTooManyRequests.Subtract(DateTime.Now);
                EditorGUILayout.HelpBox("The remote server returned an error: (429) Too Many Requests. Need to wait " + _timeNeedForWaitErrorMinute + " minutes. " + leftTime.Minutes + " minutes " + leftTime.Seconds + " left", MessageType.Error);
                if (_diedLineErrorTooManyRequests < DateTime.Now) _isErrorTooManyRequests = false;
            }

            LS = EditorGUILayout.BeginFoldoutHeaderGroup(LS, "Target languages");
            if (LS)
            {
                // Store previous state to detect changes
                var previousState = _checkListLanguages.RowCheckLists
                    .Select(r => new { r.Name, r.IsActive })
                    .ToList();

                _checkListLanguages.DrawButtons();

                // Check if any language selection changed
                bool stateChanged = false;
                for (int i = 0; i < _checkListLanguages.RowCheckLists.Count; i++)
                {
                    var current = _checkListLanguages.RowCheckLists[i];
                    var previous = previousState.FirstOrDefault(p => p.Name == current.Name);
                    if (previous != null && previous.IsActive != current.IsActive)
                    {
                        stateChanged = true;
                        break;
                    }
                }

                // Save if changed
                if (stateChanged)
                {
                    SaveSelectedLanguages();
                }
            }
            EditorGUILayout.EndFoldoutHeaderGroup();

            var names = GetNames();

            if (names.Count != 0)
            {
                WLS = EditorGUILayout.BeginFoldoutHeaderGroup(WLS, "Warning " + names.Count.ToString() + " languages");
                if (WLS)
                {
                    _position = EditorGUILayout.BeginScrollView(_position);
                    foreach (var name in names)
                    {
                        EditorGUILayout.HelpBox(name + " " + translator.GetNameService() + " service does not support some dialects of languages, the choice of language will be changed to the generally accepted.", MessageType.Warning);
                    }
                    EditorGUILayout.EndScrollView();
                }
                EditorGUILayout.EndFoldoutHeaderGroup();
            }

            ValidateLocalizationSettings();
            ValidateLocales();
            ValidateStringTables();

            GUILayout.Space(10);

            if (GUILayout.Button("Translate")) ButtonTranslate_Click();
            EditorGUILayout.EndVertical();
            EditorGUILayout.EndHorizontal();
        }

        private List<string> GetNames()
        {
            List<string> strings = new List<string>();
            foreach (RowCheckList rowCheckList in _checkListLanguages.RowCheckLists)
            {
                foreach (Locale locale in _locales)
                {
                    if ( locale != null && locale.name == rowCheckList.Name)
                    {
                        if (rowCheckList.IsActive == true && translator.ValidateLocale(locale.Identifier.Code) == false)
                        {
                            strings.Add(rowCheckList.Name);
                        }
                    }
                }
            }
            return strings;
        }

        private void ButtonTranslate_Click()
        {
            _isErrorConnection = WebInformation.IsConnectedToInternet();
            if (_isErrorConnection ) return;

            EditorUtility.DisplayCancelableProgressBar("Translating", "Load Tables...", 0);
            Thread.Sleep(50);
            
            UpdateLocalization();
            
            EditorUtility.DisplayCancelableProgressBar("Translating", "Preparation translate...", 0.05f);
            Thread.Sleep(50);

            _selectedLocale = _locales.First(w => w.LocaleName == _dropdownLanguages.Selected);

            TranslateData translateData = new TranslateData();
            translateData.selectedLocale = _selectedLocale;
            translateData.sharedtables = _sharedStringTables.ToList();
            translateData.stringTables = _stringTables.ToList();
            translateData.locales = new List<Locale>();

            foreach (RowCheckList rowCheckList in _checkListLanguages.RowCheckLists)
            {
                if (rowCheckList.IsActive == false ) continue;
                foreach (Locale locale in _locales)
                {
                    if (locale.LocaleName == rowCheckList.Name)
                    {
                        translateData.locales.Add(locale);
                    }
                }
            }

            EditorUtility.DisplayCancelableProgressBar("Translating", "Initializing translator...", 0.08f);
            Thread.Sleep(50);

            TranslateLocalization translateLocalization = new TranslateLocalization();

            _translateParameters.FillDictinary(_checkListStringTable.RowCheckLists);

            // Calculate total count
            int selectedTablesCount = _checkListStringTable.RowCheckLists.Count(r => r.IsActive);
            int targetLanguagesCount = translateData.locales.Count;
            int totalCount = selectedTablesCount * targetLanguagesCount;
            int currentIndex = 0;

            // Debug info
            // UnityEngine.Debug.Log($"[AutoTranslate] Selected Tables: {selectedTablesCount}, Target Languages: {targetLanguagesCount}, Total: {totalCount}");
            // UnityEngine.Debug.Log($"[AutoTranslate] translateData.sharedtables count: {translateData.sharedtables.Count}");
            // UnityEngine.Debug.Log($"[AutoTranslate] translateData.locales count: {translateData.locales.Count}");

            EditorUtility.DisplayCancelableProgressBar("Translating", $"Ready to translate {totalCount} items... (Tables: {selectedTablesCount}, Languages: {targetLanguagesCount})", 0.1f);
            Thread.Sleep(100); // Increase delay to see the message

            try
            {
                foreach (var translateStatus in translateLocalization.Make(_translateParameters, translateData))
                {
                    //UnityEngine.Debug.Log($"[AutoTranslate] Status: sharedTable='{translateStatus.sharedTable}', targetLanguage='{translateStatus.targetLanguageTable}', progress={translateStatus.progress}");
                    
                    if (!string.IsNullOrEmpty(translateStatus.sharedTable))
                    {
                        // Increment first, then display (so first table shows as 1/total)
                        currentIndex++;
                        
                        string progressMessage = $"Translate... ({currentIndex}/{totalCount}) Table: {translateStatus.sharedTable} | Language: {translateStatus.targetLanguageTable}";
                        
                        // Display progress bar
                        if (EditorUtility.DisplayCancelableProgressBar("Translating", progressMessage, translateStatus.progress))
                        {
                            return;
                        }

                        EditorUtility.DisplayCancelableProgressBar("Translating", progressMessage, translateStatus.progress);
                        Thread.Sleep(50); // Longer delay to ensure visibility
                    }
                }
            }
            catch (WebException webException)
            {
                if ( webException.Status == WebExceptionStatus.NameResolutionFailure)
                {
                    _isErrorConnection = true;
                }
                else
                {
                    _diedLineErrorTooManyRequests = DateTime.Now;
                    _diedLineErrorTooManyRequests = _diedLineErrorTooManyRequests.AddMinutes(_timeNeedForWaitErrorMinute);
                    _isErrorTooManyRequests = true;
                }
                EditorUtility.ClearProgressBar();
                return;
            }
            finally
            {
                EditorUtility.ClearProgressBar();
            }

            // Save all modified string tables
            EditorUtility.DisplayProgressBar("Translating", "Saving string tables...", 0.95f);
            SaveStringTables();
            Thread.Sleep(200); // Show saving message for half a second
            
            // Show completion briefly
            EditorUtility.DisplayProgressBar("Translating", "Translation completed!", 1f);
            Thread.Sleep(500); // Show completion message for half a second
            
            EditorUtility.ClearProgressBar();
        }

        private void SaveStringTables()
        {
            foreach (var stringTable in _stringTables)
            {
                EditorUtility.SetDirty(stringTable);
            }
        }

        /// <summary>
        /// Save selected languages to EditorPrefs
        /// </summary>
        private void SaveSelectedLanguages()
        {
            if (_checkListLanguages == null || _checkListLanguages.RowCheckLists == null)
                return;

            var selectedLanguages = _checkListLanguages.RowCheckLists
                .Where(r => r.IsActive)
                .Select(r => r.Name)
                .ToList();

            string serialized = string.Join("|", selectedLanguages);
            EditorPrefs.SetString(PREF_KEY_SELECTED_LANGUAGES, serialized);
        }

        /// <summary>
        /// Load selected languages from EditorPrefs
        /// </summary>
        private void LoadSelectedLanguages()
        {
            if (_checkListLanguages == null || _checkListLanguages.RowCheckLists == null)
                return;

            string serialized = EditorPrefs.GetString(PREF_KEY_SELECTED_LANGUAGES, "");
            if (string.IsNullOrEmpty(serialized))
                return;

            var selectedLanguages = serialized.Split('|').ToList();
            foreach (RowCheckList rowCheckList in _checkListLanguages.RowCheckLists)
            {
                if(!rowCheckList.IsAvailable)
                {
                    continue;
                }
                if(selectedLanguages.Contains(rowCheckList.Name))
                {
                    rowCheckList.IsActive = true;
                }
                else
                {
                    rowCheckList.IsActive = false;
                }
            }
        }
    }
}