Localization.vb

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading
Imports System.Threading.Tasks

''' <summary>
''' Modulo helper per la gestione del supporto multilingua e l'interrogazione dell'API di traduzione Google Translate.
''' </summary>
Public Module AppLanguages
    Private ReadOnly SharedHttpClient As New HttpClient()

    Private ReadOnly RtlCodes As New HashSet(Of String)(StringComparer.OrdinalIgnoreCase) From {
        "ar", "fa", "he", "iw", "ur", "yi", "ps", "sd", "ug", "syc"
    }

    ''' <summary>
    ''' Restituisce true se il codice lingua specificato utilizza l'orientamento di scrittura da destra a sinistra (RTL).
    ''' </summary>
    Public Function IsRtl(code As String) As Boolean
        If String.IsNullOrEmpty(code) Then Return False
        Dim baseCode = code.Split("-"c)(0)
        Return RtlCodes.Contains(baseCode)
    End Function

    ''' <summary>
    ''' Recupera l'elenco delle lingue supportate interrogando l'API REST di Google Translate.
    ''' </summary>
    Public Async Function FetchSupportedLanguages() As Task(Of List(Of LanguageInfo))
        Dim langs As New List(Of LanguageInfo)()
        Try
            Dim url = "https://translate.googleapis.com/translate_a/l?client=gtx&hl=en"
            Dim response = Await SharedHttpClient.GetStringAsync(url)
            Using doc As JsonDocument = JsonDocument.Parse(response)
                Dim tlElement As JsonElement = Nothing
                If doc.RootElement.TryGetProperty("tl", tlElement) Then
                    For Each prop In tlElement.EnumerateObject()
                        langs.Add(New LanguageInfo With {
                            .Code = prop.Name,
                            .Name = prop.Value.ToString()
                        })
                    Next
                    langs.Sort(Function(a, b) a.Name.CompareTo(b.Name))
                End If
            End Using
        Catch ex As Exception
            Debug.WriteLine($"Failed to fetch supported languages: {ex.Message}")
        End Try
        Return langs
    End Function
End Module

''' <summary>
''' Servizio singleton per la gestione della cache delle traduzioni (UI e messaggi chat) persistente su file disco.
''' Ottimizzato per mantenere in RAM ESCLUSIVAMENTE i dizionari della lingua attualmente attiva/impostata.
''' </summary>
Public Class TranslationCacheService
    Private Shared ReadOnly _instance As New TranslationCacheService()
    Public Shared ReadOnly Property Instance As TranslationCacheService
        Get
            Return _instance
        End Get
    End Property

    Private ReadOnly _httpClient As New HttpClient()
    Private ReadOnly _cacheLock As New Object()
    
    Private _activeLanguage As String = "en"
    Private _activeUiTranslations As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase)
    Private _activeMessageTranslations As New Dictionary(Of String, String)(StringComparer.Ordinal)
    
    Private _dirty As Boolean = False
    Private _flushCts As CancellationTokenSource = Nothing

    ' Supporto multi-provider e privacy opt-in (TODO #69)
    Private _activeProvider As ITranslationProvider = GoogleTranslationProvider.Instance
    Private _privacyConsentAccepted As Boolean = False

    Private Sub New()
    End Sub

    ''' <summary>Percorso del file JSON per la persistenza delle traduzioni su disco.</summary>
    Public Shared ReadOnly Property CacheFilePath As String
        Get
            Dim dataDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data")
            Dim dataPath = Path.Combine(dataDir, "translations_cache.json")
            If File.Exists(dataPath) Then Return dataPath

            Dim rootPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "translations_cache.json")
            If File.Exists(rootPath) Then
                Try
                    If Not Directory.Exists(dataDir) Then Directory.CreateDirectory(dataDir)
                    File.Move(rootPath, dataPath)
                    Return dataPath
                Catch
                    Return rootPath
                End Try
            End If

            If Not Directory.Exists(dataDir) Then
                Try
                    Directory.CreateDirectory(dataDir)
                Catch
                End Try
            End If
            Return dataPath
        End Get
    End Property

    ''' <summary>Indica se l'utente ha esplicitamente acconsentito all'invio dei messaggi non in cache al fornitore di traduzione (TODO #69).</summary>
    Public Property PrivacyConsentAccepted As Boolean
        Get
            SyncLock _cacheLock
                Return _privacyConsentAccepted
            End SyncLock
        End Get
        Set(value As Boolean)
            SyncLock _cacheLock
                _privacyConsentAccepted = value
            End SyncLock
        End Set
    End Property

    ''' <summary>Provider di traduzione attualmente configurato ed attivo (Google, LibreTranslate, Ollama, OpenAI-compatible).</summary>
    Public Property ActiveProvider As ITranslationProvider
        Get
            SyncLock _cacheLock
                Return If(_activeProvider, GoogleTranslationProvider.Instance)
            End SyncLock
        End Get
        Set(value As ITranslationProvider)
            SyncLock _cacheLock
                _activeProvider = If(value, GoogleTranslationProvider.Instance)
            End SyncLock
        End Set
    End Property

    ''' <summary>
    ''' Configura il provider e lo stato di consenso privacy del servizio di traduzione (TODO #69).
    ''' </summary>
    Public Sub Configure(config As TranslationConfig)
        If config Is Nothing Then Return
        SyncLock _cacheLock
            _privacyConsentAccepted = config.PrivacyConsentAccepted
            _activeProvider = TranslationProviderRegistry.CreateProvider(config, _httpClient)
        End SyncLock
    End Sub

    ''' <summary>
    ''' Imposta la lingua attiva, scarica su disco eventuali modifiche della lingua precedente,
    ''' rilascia dalla memoria RAM i dizionari non utilizzati e carica solo quelli della nuova lingua.
    ''' </summary>
    Public Async Function SetActiveLanguageAsync(langCode As String) As Task
        If String.IsNullOrWhiteSpace(langCode) Then langCode = "en"

        ' Flush immediato se c'erano modifiche pendenti sulla vecchia lingua
        If _dirty Then
            Await FlushCacheImmediateAsync()
        End If

        SyncLock _cacheLock
            _activeLanguage = langCode.ToLowerInvariant()
            _activeUiTranslations.Clear()
            _activeMessageTranslations.Clear()
        End SyncLock

        ' Carica i dati per la lingua attiva dal file persistente
        Await LoadActiveLanguageFromDiskAsync(_activeLanguage)

        ' Integra i valori UI predefiniti
        SyncLock _cacheLock
            Dim sourceDict As Dictionary(Of String, String) = Nothing
            Select Case _activeLanguage
                Case "it"
                    sourceDict = AppLocalizations.ItStrings
                Case "fr"
                    sourceDict = AppLocalizations.FrStrings
                Case "es"
                    sourceDict = AppLocalizations.EsStrings
                Case "de"
                    sourceDict = AppLocalizations.DeStrings
                Case Else
                    sourceDict = AppLocalizations.EnStrings
            End Select

            If sourceDict IsNot Nothing Then
                For Each kvp In sourceDict
                    If Not _activeUiTranslations.ContainsKey(kvp.Key) Then
                        _activeUiTranslations(kvp.Key) = kvp.Value
                    End If
                Next
            End If
        End SyncLock
    End Function

    ''' <summary>
    ''' Restituisce un'istanza di AppLocalizations configurata con le traduzioni correnti in RAM.
    ''' </summary>
    Public Function GetActiveLocalizations() As AppLocalizations
        SyncLock _cacheLock
            Return New AppLocalizations(_activeUiTranslations)
        End SyncLock
    End Function

    Private Async Function LoadActiveLanguageFromDiskAsync(langCode As String) As Task
        Dim filePath = CacheFilePath
        If Not File.Exists(filePath) Then Return

        Try
            Dim jsonContent = Await File.ReadAllTextAsync(filePath)
            If String.IsNullOrWhiteSpace(jsonContent) Then Return

            Using doc As JsonDocument = JsonDocument.Parse(jsonContent)
                Dim root = doc.RootElement

                SyncLock _cacheLock
                    ' 1. Lettura traduzioni UI ("ui" -> langCode)
                    Dim uiElement As JsonElement = Nothing
                    If root.TryGetProperty("ui", uiElement) AndAlso uiElement.ValueKind = JsonValueKind.Object Then
                        Dim langUiElement As JsonElement = Nothing
                        If uiElement.TryGetProperty(langCode, langUiElement) AndAlso langUiElement.ValueKind = JsonValueKind.Object Then
                            For Each prop In langUiElement.EnumerateObject()
                                _activeUiTranslations(prop.Name) = prop.Value.GetString()
                            Next
                        End If
                    End If

                    ' 2. Retrocompatibilità: "cached_translations" -> langCode
                    Dim cachedElement As JsonElement = Nothing
                    If root.TryGetProperty("cached_translations", cachedElement) AndAlso cachedElement.ValueKind = JsonValueKind.Object Then
                        Dim langCachedElement As JsonElement = Nothing
                        If cachedElement.TryGetProperty(langCode, langCachedElement) AndAlso langCachedElement.ValueKind = JsonValueKind.Object Then
                            For Each prop In langCachedElement.EnumerateObject()
                                If Not _activeUiTranslations.ContainsKey(prop.Name) Then
                                    _activeUiTranslations(prop.Name) = prop.Value.GetString()
                                End If
                            Next
                        End If
                    End If

                    ' 3. Lettura messaggi chat/DOM tradotti ("messages" -> langCode)
                    Dim msgElement As JsonElement = Nothing
                    If root.TryGetProperty("messages", msgElement) AndAlso msgElement.ValueKind = JsonValueKind.Object Then
                        Dim langMsgElement As JsonElement = Nothing
                        If msgElement.TryGetProperty(langCode, langMsgElement) AndAlso langMsgElement.ValueKind = JsonValueKind.Object Then
                            For Each prop In langMsgElement.EnumerateObject()
                                _activeMessageTranslations(prop.Name) = prop.Value.GetString()
                            Next
                        End If
                    End If
                End SyncLock
            End Using
        Catch ex As Exception
            Debug.WriteLine($"[TranslationCacheService] Error reading cache from disk: {ex.Message}")
        End Try
    End Function

    ''' <summary>
    ''' Recupera una traduzione messaggio memorizzata in cache se presente.
    ''' </summary>
    Public Function TryGetCachedMessage(text As String, targetLang As String, ByRef translatedText As String) As Boolean
        If String.IsNullOrEmpty(text) Then
            translatedText = text
            Return True
        End If

        SyncLock _cacheLock
            If String.Equals(targetLang, _activeLanguage, StringComparison.OrdinalIgnoreCase) Then
                Return _activeMessageTranslations.TryGetValue(text, translatedText)
            End If
        End SyncLock

        translatedText = Nothing
        Return False
    End Function

    ''' <summary>
    ''' Salva una traduzione messaggio nella cache e pianifica la persistenza su disco con debounce.
    ''' </summary>
    Public Sub CacheMessage(text As String, translatedText As String, targetLang As String)
        If String.IsNullOrEmpty(text) OrElse String.IsNullOrEmpty(translatedText) Then Return

        SyncLock _cacheLock
            If String.Equals(targetLang, _activeLanguage, StringComparison.OrdinalIgnoreCase) Then
                _activeMessageTranslations(text) = translatedText
                _dirty = True
            End If
        End SyncLock

        If _dirty Then
            ScheduleFlushDebounced()
        End If
    End Sub

    ''' <summary>
    ''' Salva più traduzioni messaggi in batch nella cache in un'unica operazione.
    ''' </summary>
    Public Sub CacheMessagesBatch(items As IEnumerable(Of KeyValuePair(Of String, String)), targetLang As String)
        SyncLock _cacheLock
            If String.Equals(targetLang, _activeLanguage, StringComparison.OrdinalIgnoreCase) Then
                For Each item In items
                    If Not String.IsNullOrEmpty(item.Key) AndAlso Not String.IsNullOrEmpty(item.Value) Then
                        _activeMessageTranslations(item.Key) = item.Value
                        _dirty = True
                    End If
                Next
            End If
        End SyncLock

        If _dirty Then
            ScheduleFlushDebounced()
        End If
    End Sub

    Private Sub ScheduleFlushDebounced()
        If _flushCts IsNot Nothing Then
            Try
                _flushCts.Cancel()
                _flushCts.Dispose()
            Catch
            End Try
        End If

        _flushCts = New CancellationTokenSource()
        Dim token = _flushCts.Token

        Dim ignore = Task.Run(Async Function()
            Try
                Await Task.Delay(500, token)
                If token.IsCancellationRequested Then Return
                Await FlushCacheImmediateAsync()
            Catch ex As OperationCanceledException
                ' Operazione annullata per nuovo arrivo dati
            Catch ex As Exception
                Debug.WriteLine($"[TranslationCacheService] Debounced flush error: {ex.Message}")
            End Try
        End Function)
    End Sub

    ''' <summary>
    ''' Scrive immediatamente su file disco lo stato della cache unificandolo ai dati già esistenti.
    ''' </summary>
    Public Async Function FlushCacheImmediateAsync() As Task
        Dim currentLang As String
        Dim uiCopy As Dictionary(Of String, String)
        Dim msgCopy As Dictionary(Of String, String)

        SyncLock _cacheLock
            If Not _dirty Then Return
            _dirty = False
            currentLang = _activeLanguage
            uiCopy = New Dictionary(Of String, String)(_activeUiTranslations)
            msgCopy = New Dictionary(Of String, String)(_activeMessageTranslations)
        End SyncLock

        Dim filePath = CacheFilePath
        Try
            ' Carica l'intero file esistente per non sovrascrivere altre lingue memorizzate su disco
            Dim fullData As New Dictionary(Of String, Object)()
            Dim allUi As New Dictionary(Of String, Dictionary(Of String, String))(StringComparer.OrdinalIgnoreCase)
            Dim allMessages As New Dictionary(Of String, Dictionary(Of String, String))(StringComparer.OrdinalIgnoreCase)

            If File.Exists(filePath) Then
                Try
                    Dim existingJson = Await File.ReadAllTextAsync(filePath)
                    If Not String.IsNullOrWhiteSpace(existingJson) Then
                        Using doc As JsonDocument = JsonDocument.Parse(existingJson)
                            Dim root = doc.RootElement

                            Dim uiEl As JsonElement = Nothing
                            If root.TryGetProperty("ui", uiEl) AndAlso uiEl.ValueKind = JsonValueKind.Object Then
                                For Each langProp In uiEl.EnumerateObject()
                                    Dim dict As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase)
                                    For Each item In langProp.Value.EnumerateObject()
                                        dict(item.Name) = item.Value.GetString()
                                    Next
                                    allUi(langProp.Name) = dict
                                Next
                            End If

                            Dim msgEl As JsonElement = Nothing
                            If root.TryGetProperty("messages", msgEl) AndAlso msgEl.ValueKind = JsonValueKind.Object Then
                                For Each langProp In msgEl.EnumerateObject()
                                    Dim dict As New Dictionary(Of String, String)(StringComparer.Ordinal)
                                    For Each item In langProp.Value.EnumerateObject()
                                        dict(item.Name) = item.Value.GetString()
                                    Next
                                    allMessages(langProp.Name) = dict
                                Next
                            End If
                        End Using
                    End If
                Catch ex As Exception
                    Debug.WriteLine($"[TranslationCacheService] Read before write warning: {ex.Message}")
                End Try
            End If

            ' Aggiorna la sezione della lingua attiva
            allUi(currentLang) = uiCopy
            allMessages(currentLang) = msgCopy

            fullData("ui") = allUi
            fullData("messages") = allMessages
            ' Mantiene retrocompatibilità con cached_translations
            fullData("cached_translations") = allUi

            Dim dirName = Path.GetDirectoryName(filePath)
            If Not String.IsNullOrEmpty(dirName) AndAlso Not Directory.Exists(dirName) Then
                Directory.CreateDirectory(dirName)
            End If

            Dim options As New JsonSerializerOptions With {
                .WriteIndented = True
            }
            Dim serialized = JsonSerializer.Serialize(fullData, options)
            Await File.WriteAllTextAsync(filePath, serialized)
        Catch ex As Exception
            Debug.WriteLine($"[TranslationCacheService] Failed to save cache file: {ex.Message}")
        End Try
    End Function

    ''' <summary>
    ''' Traduce un singolo testo restituendo il risultato dettagliato (successo, testo tradotto, messaggio d'errore).
    ''' Rispetta rigorosamente il vincolo di Privacy Opt-In (TODO #69): se il consenso non è concesso, nessun dato lascia il computer.
    ''' </summary>
    Public Async Function TranslateSingleDetailedAsync(text As String, targetLang As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of TranslationResult)
        If String.IsNullOrEmpty(text) Then Return TranslationResult.Succeeded(text)

        Dim cached As String = Nothing
        If TryGetCachedMessage(text, targetLang, cached) AndAlso Not String.IsNullOrEmpty(cached) Then
            Return TranslationResult.Succeeded(cached)
        End If

        ' Verifica Privacy Opt-in: se non autorizzato, non invia richieste di rete
        If Not PrivacyConsentAccepted Then
            Return TranslationResult.Failed("PRIVACY_CONSENT_REQUIRED", text)
        End If

        Dim provider = ActiveProvider
        Try
            Dim res = Await provider.TranslateSingleAsync(text, targetLang, cancellationToken)
            If res.Success AndAlso Not String.IsNullOrEmpty(res.TranslatedText) AndAlso res.TranslatedText <> text Then
                CacheMessage(text, res.TranslatedText, targetLang)
            End If
            Return res
        Catch ex As Exception
            Debug.WriteLine($"[TranslationCacheService] Translation error via {provider.DisplayName}: {ex.Message}")
            Return TranslationResult.Failed($"Provider unreachable: {ex.Message}", text)
        End Try
    End Function

    ''' <summary>
    ''' Traduce un singolo testo interrogando preventivamente la cache su disco/RAM prima di effettuare chiamate al provider configurato.
    ''' </summary>
    Public Async Function TranslateSingleAsync(text As String, targetLang As String) As Task(Of String)
        Dim res = Await TranslateSingleDetailedAsync(text, targetLang)
        Return If(res.Success AndAlso Not String.IsNullOrEmpty(res.TranslatedText), res.TranslatedText, text)
    End Function

    ''' <summary>
    ''' Traduce un elenco di testi inviando al fornitore configurato solo le frasi non ancora in cache.
    ''' Rispetta il vincolo di Privacy Opt-In: in assenza di autorizzazione, nessun dato viene trasmesso (TODO #69).
    ''' </summary>
    Public Async Function TranslateBatchDetailedAsync(texts As List(Of String), targetLang As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of TranslationBatchResult)
        If texts Is Nothing OrElse texts.Count = 0 Then Return TranslationBatchResult.Succeeded(New List(Of String)())

        Dim results As New List(Of String)(New String(texts.Count - 1) {})
        Dim missingIndices As New List(Of Integer)()
        Dim missingTexts As New List(Of String)()

        For i As Integer = 0 To texts.Count - 1
            Dim t = texts(i)
            Dim cached As String = Nothing
            If TryGetCachedMessage(t, targetLang, cached) AndAlso Not String.IsNullOrEmpty(cached) Then
                results(i) = cached
            Else
                missingIndices.Add(i)
                missingTexts.Add(t)
            End If
        Next

        ' Se tutti i testi erano già memorizzati in cache, ritorna immediatamente senza accessi di rete!
        If missingTexts.Count = 0 Then
            Return TranslationBatchResult.Succeeded(results)
        End If

        ' Controllo Privacy Opt-in (TODO #69)
        If Not PrivacyConsentAccepted Then
            For j As Integer = 0 To missingIndices.Count - 1
                results(missingIndices(j)) = missingTexts(j)
            Next
            Return TranslationBatchResult.Failed("PRIVACY_CONSENT_REQUIRED", results)
        End If

        Dim provider = ActiveProvider
        Try
            Dim batchRes = Await provider.TranslateBatchAsync(missingTexts, targetLang, cancellationToken)
            If batchRes.Success Then
                Dim newCacheEntries As New List(Of KeyValuePair(Of String, String))()
                For j As Integer = 0 To missingIndices.Count - 1
                    Dim origIndex = missingIndices(j)
                    Dim translatedPart = If(j < batchRes.Translations.Count AndAlso Not String.IsNullOrEmpty(batchRes.Translations(j)), batchRes.Translations(j), missingTexts(j))
                    results(origIndex) = translatedPart
                    If translatedPart <> missingTexts(j) Then
                        newCacheEntries.Add(New KeyValuePair(Of String, String)(missingTexts(j), translatedPart))
                    End If
                Next

                If newCacheEntries.Count > 0 Then
                    CacheMessagesBatch(newCacheEntries, targetLang)
                End If
                Return TranslationBatchResult.Succeeded(results)
            Else
                For j As Integer = 0 To missingIndices.Count - 1
                    results(missingIndices(j)) = missingTexts(j)
                Next
                Return TranslationBatchResult.Failed(batchRes.ErrorMessage, results)
            End If
        Catch ex As Exception
            Debug.WriteLine($"[TranslationCacheService] Batch translation provider error ({provider.DisplayName}): {ex.Message}")
            For j As Integer = 0 To missingIndices.Count - 1
                results(missingIndices(j)) = missingTexts(j)
            Next
            Return TranslationBatchResult.Failed($"Provider error: {ex.Message}", results)
        End Try
    End Function

    ''' <summary>
    ''' Traduce un elenco di testi estraendo ed inviando al provider solo le frasi non ancora in cache.
    ''' </summary>
    Public Async Function TranslateBatchAsync(texts As List(Of String), targetLang As String) As Task(Of List(Of String))
        Dim res = Await TranslateBatchDetailedAsync(texts, targetLang)
        Return res.Translations
    End Function

    Private Async Function TranslateTextHttpAsync(text As String, targetLang As String) As Task(Of String)
        Dim res = Await GoogleTranslationProvider.Instance.TranslateSingleAsync(text, targetLang, CancellationToken.None)
        Return If(res.Success, res.TranslatedText, text)
    End Function
End Class

''' <summary>
''' Gestisce i dizionari di localizzazione dell'interfaccia utente (Inglese e Italiano) e il servizio di traduzione automatica.
''' </summary>
Public Class AppLocalizations
    Private ReadOnly _translations As Dictionary(Of String, String)

    Public Sub New(translations As Dictionary(Of String, String))
        _translations = If(translations, New Dictionary(Of String, String)())
    End Sub

    ''' <summary>Dizionario di localizzazione di fallback per l'interfaccia in lingua Inglese.</summary>
    Public Shared ReadOnly EnStrings As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From {
        {"settings", "Settings"},
        {"theme", "Theme"},
        {"system", "System"},
        {"light", "Light"},
        {"dark", "Dark"},
        {"match_cohesive", "Match this setting in your chat apps for a cohesive look."},
        {"manage_accounts", "Manage Accounts"},
        {"add_account", "Add account"},
        {"always_show_tab_bar", "Always show tab bar"},
        {"updates", "Updates"},
        {"check_updates_launch", "Check for updates on launch"},
        {"check_now", "Check Now"},
        {"devtools", "DevTools"},
        {"debug_active_tab", "Debug active tab"},
        {"delete_account_title", "Delete Account"},
        {"delete_account_confirm", "Delete ""{name}""? This will remove all data for this account."},
        {"delete_account_last", "You cannot delete the last active account."},
        {"cancel", "Cancel"},
        {"delete", "Delete"},
        {"rename", "Rename"},
        {"language", "Language"},
        {"translate_to_lang", "Translate to {lang}"},
        {"translate_all_messages", "Translate all messages"},
        {"toggle_window", "Toggle Window"},
        {"exit", "Exit"},
        {"translate_message_button", "Translate message button "},
        {"keep_app_in_english", "Keep app UI in English"},
        {"full_page_translation", "Translate entire page"},
        {"show_translate_all_messages_button", "Title bar translate all messages button"},
        {"reload_active_tab", "Reload active tab"},
        {"use_beta_channel", "Use beta update channel"},
        {"notifications", "Notifications"},
        {"show_message_popup", "Show message popup"},
        {"accounts_count_info", "Configured accounts: {count} of {max}"},
        {"max_accounts_reached", "Maximum limit of {max} accounts reached."},
        {"max_accounts_downgrade_notice", "Downgrade notice: you have {count} active accounts, exceeding the maximum limit of {max}. Existing accounts are preserved and fully functional, but adding new accounts is disabled until you are below the limit."},
        {"accounts_downgrade_blocked", "Cannot add account: you have {count} configured accounts, exceeding the current limit of {max}. Delete one or more accounts or increase the limit to add new accounts."},
        {"max_accounts", "Max accounts:"},
        {"add_whatsapp_account", "Add WhatsApp account"},
        {"add_telegram_account", "Add Telegram account"},
        {"add_openclaw_account", "Add OpenClaw account"},
        {"add_hermes_account", "Add Hermes Agent account"},
        {"openclaw_server_url", "Gateway / Tailscale URL:"},
        {"openclaw_auth_token", "Gateway Auth Token:"},
        {"test_connection", "Test Connection"},
        {"connection_testing", "Testing..."},
        {"connection_success", "✓ Online"},
        {"connection_failed", "✗ Unreachable"},
        {"select_platform", "Select platform"},
        {"about", "About"},
        {"about_title", "About HidaChat"},
        {"app_description", "Portable, lightweight, multi-account desktop client for Windows (WhatsApp, Telegram, OpenClaw, Hermes)."},
        {"author", "Author"},
        {"release_date", "Release Date"},
        {"license", "License"},
        {"runtime_environment", "Environment & Framework"},
        {"portable_directory", "Portable Data Path"},
        {"github_repository", "GitHub Repository"},
        {"report_issue", "Report Issue"},
        {"view_releases", "View Releases"},
        {"bulk_sender", "Excel / CSV Bulk Sender"},
        {"custom_css", "Custom CSS"},
        {"enable_custom_css", "Enable custom CSS rules"},
        {"custom_css_placeholder", "/* Write or paste your custom CSS for WhatsApp and Telegram Web here */"},
        {"apply_css", "Apply CSS"},
        {"css_applied", "CSS applied successfully!"},
        {"css_preset_oled", "OLED Pure Dark"},
        {"css_preset_compact", "Compact Layout"},
        {"css_preset_font", "Modern Font"},
        {"css_preset_reset", "Clear"},
        {"contact_online", "Online"},
        {"contact_typing", "typing..."},
        {"spellchecker", "Spellchecker"},
        {"enable_spellchecker", "Enable native spellchecker in chat inputs"},
        {"spellchecker_language", "Dictionary language"},
        {"spellchecker_lang_auto", "Automatic (follow app language)"},
        {"spellchecker_restart_hint", "Changes will apply when reloading tabs or restarting HidaChat."},
        {"dnd_mode", "Do Not Disturb (Focus Mode)"},
        {"dnd_enable", "Silence all notifications and sounds"},
        {"dnd_duration", "Duration"},
        {"dnd_30m", "For 30 minutes"},
        {"dnd_1h", "For 1 hour"},
        {"dnd_2h", "For 2 hours"},
        {"dnd_8h", "For 8 hours"},
        {"dnd_indefinite", "Until turned off"},
        {"dnd_active_until", "Do Not Disturb active until {time}"},
        {"dnd_active_indefinite", "Do Not Disturb active (indefinite)"},
        {"update_insufficient_permissions", "Cannot update automatically." & vbCrLf & "The application lacks write permissions in the installation directory." & vbCrLf & vbCrLf & "Please move the application to a writable location (e.g. Documents, Desktop, or USB drive)." & vbCrLf & "Avoid protected system directories like Program Files." & vbCrLf & vbCrLf & "Available version: v{version}"},
        {"update_insufficient_permissions_title", "Insufficient Permissions"},
        {"update_missing_checksum", "Cannot verify update integrity." & vbCrLf & vbCrLf & "No valid SHA-256 cryptographic checksum was provided with this version on GitHub." & vbCrLf & vbCrLf & "The update has been aborted for security reasons."},
        {"update_integrity_failed_title", "Update Integrity Error"},
        {"update_checksum_mismatch", "Update integrity check failed!" & vbCrLf & vbCrLf & "The SHA-256 cryptographic hash of the downloaded update file does not match the expected hash:" & vbCrLf & vbCrLf & "Computed: {computed}" & vbCrLf & "Expected: {expected}" & vbCrLf & vbCrLf & "The update has been aborted to ensure system safety."},
        {"update_download_error", "Update download failed or timed out:" & vbCrLf & vbCrLf & "{error}"},
        {"update_download_error_title", "Update Download Error"},
        {"update_signature_invalid", "Digital signature verification failed on the update executable." & vbCrLf & vbCrLf & "The update has been aborted for security reasons."},
        {"update_already_latest", "You already have the latest version (v{version})!"},
        {"update_already_latest_title", "Up to Date"},
        {"update_no_new_version", "The remote version (v{remote}) is older than or equal to current version (v{current})."},
        {"update_no_new_version_title", "Update"},
        {"update_available_prompt", "A new version of HidaChat (v{version}) is available!" & vbCrLf & vbCrLf & "Would you like to download and install the update now?"},
        {"update_available_title", "Update Available"},
        {"update_install_error", "An error occurred while installing the update:" & vbCrLf & vbCrLf & "{error}"},
        {"update_install_error_title", "Update Error"},
        {"update_check_failed", "Failed to check for updates:" & vbCrLf & vbCrLf & "{error}"},
        {"update_check_failed_network", "Unable to check for updates. Please check your internet connection or try again later."},
        {"update_check_failed_title", "Update Check"},
        {"update_no_asset", "No update package is attached to the remote release."},
        {"settings_corrupt_recovery_title", "Settings Recovery"},
        {"settings_corrupt_recovered_msg", "The 'settings.json' configuration file was corrupted and has been archived as '{file}'." & vbCrLf & vbCrLf & "Settings and accounts have been successfully restored from the last available backup (.bak)."},
        {"settings_corrupt_reset_title", "Configuration Error"},
        {"settings_corrupt_reset_msg", "The 'settings.json' configuration file was corrupted and has been archived as '{file}'." & vbCrLf & vbCrLf & "A valid backup could not be recovered: the application has started with default settings."},
        {"network_drive_warning_title", "Network Drive Warning"},
        {"network_drive_warning_msg", "HidaChat is running from a network drive ({path})." & vbCrLf & vbCrLf & "Warning: Microsoft WebView2 does not support storing browser profiles on network drives or SMB shares. This frequently causes WhatsApp Web to lose its session or disconnect on restart." & vbCrLf & vbCrLf & "It is strongly recommended to run HidaChat from a local drive (e.g. C:\HidaChat)."},
        {"network_drive_staging_info", "HidaChat is running from a network drive ({path})." & vbCrLf & vbCrLf & "Local Session Staging is ACTIVE: your chat sessions and login data are handled on local disk and synchronized to the network share on exit to prevent WebView2 session loss."},
        {"network_drive_section", "Network Drives"},
        {"enable_network_profile_staging", "Enable local staging for network drives"},
        {"enable_network_profile_staging_hint", "Improves session stability and prevents WhatsApp disconnection when running from network shares (SMB/UNC)."},
        {"network_drive_session_conflict", "Warning: Account '{name}' appears to be active on another computer ({machine}). Simultaneous usage may cause disconnects."},
        {"secret_decrypt_error_title", "Credential Decryption Warning"},
        {"secret_decrypt_error_msg", "Could not decrypt the stored Tailscale AuthKey: the application folder was opened on a different computer or Windows user profile (DPAPI protection is machine/user-bound)." & vbCrLf & vbCrLf & "To re-enable Tailscale integration, please re-enter the AuthKey in Settings."},
        {"folder_locked_title", "Application Folder in Use"},
        {"folder_locked_msg", "The HidaChat folder is currently locked and in use by another instance or computer:" & vbCrLf & vbCrLf & "• Machine: {machine}" & vbCrLf & "• User: {user}" & vbCrLf & "• PID: {pid}" & vbCrLf & "• Started at: {time}" & vbCrLf & vbCrLf & "To prevent WebView2 profile and session data corruption, running multiple concurrent instances from the same folder is not allowed."},
        {"close", "Close"},
        {"tab_hibernation_section", "Tab Hibernation"},
        {"enable_tab_hibernation", "Enable inactive tab hibernation"},
        {"enable_tab_hibernation_hint", "Reduces RAM usage by suspending background tabs when idle. They resume instantly when selected."},
        {"tab_hibernation_timeout", "Inactivity timeout:"},
        {"cache_section", "Cache & Storage"},
        {"disk_cache_limit", "Chromium disk cache limit:"},
        {"disk_cache_limit_hint", "Limits disk space used by Chromium HTTP cache per profile (applied upon tab reload)."},
        {"smart_clean_cache_btn", "Clean Cache (keep login)"},
        {"smart_clean_cache_hint", "Deletes temporary files, HTTP cache, shaders and GPU cache without logging out (cookies, sessions and IndexedDB remain intact)."},
        {"smart_clean_cache_confirm_title", "Clean Cache"},
        {"smart_clean_cache_confirm_msg", "Do you want to clean temporary files and browser caches for all accounts? Login sessions and credentials will be preserved."},
        {"smart_clean_cache_success_title", "Cache Cleaned"},
        {"smart_clean_cache_success_msg", "Cache cleanup completed successfully! Account sessions and logins were preserved."},
        {"account_clean_cache", "Clean account cache"},
        {"hibernated_badge_tooltip", "Tab hibernated (auto-resumes on click)"},
        {"account_repair_tab", "Repair tab (reset corrupted database)"},
        {"account_repair_confirm_title", "Repair Tab"},
        {"account_repair_confirm_msg", "This will repair the tab's local database and service worker cache, then reload the page to fix white screens and data corruption. Continue?"},
        {"account_repair_success_title", "Repair Completed"},
        {"account_repair_success_msg", "The tab's storage has been repaired and the page has been reloaded."},
        {"shutdown_dialog_title", "Closing HidaChat"},
        {"shutdown_dialog_header", "Saving data and closing..."},
        {"shutdown_stage_settings", "Saving settings and account preferences..."},
        {"shutdown_stage_webviews", "Gracefully terminating web browser processes..."},
        {"shutdown_stage_network_sync", "Synchronizing profiles and chat sessions to network share..."},
        {"shutdown_stage_tsnet", "Stopping network proxy and releasing lock leases..."},
        {"shutdown_stage_complete", "Finalizing and closing..."},
        {"tailscale_dialog_title", "Tailscale Connection Status"},
        {"tailscale_dialog_header", "Unable to load {platform}: {name}"},
        {"tailscale_error_tsnet_needs_login", "The embedded Tailscale node requires authentication. Please log in to connect to your Tailnet and access the service."},
        {"tailscale_error_tsnet_stopped", "The embedded Tailscale service (tsnet) is not running or failed to initialize."},
        {"tailscale_error_node_unreachable", "Tailscale connection is active, but the remote host '{host}' is unreachable or offline. Please check that the remote device is powered on and connected to your Tailnet."},
        {"tailscale_error_client_disconnected", "The Tailscale client is not running or disconnected on this computer. Please launch and connect Tailscale, then try again."},
        {"tailscale_error_generic_failure", "Unable to reach the server '{host}'. A network or connection timeout error occurred."},
        {"tailscale_btn_retry", "Retry"},
        {"tailscale_btn_login", "Log in to Tailscale"},
        {"tailscale_btn_settings", "Open Settings"},
        {"tailscale_btn_close", "Close"},
        {"storage_recovery_dialog_title", "Storage Integrity Recovery"},
        {"storage_recovery_dialog_header", "Repairing local storage and database..."},
        {"storage_recovery_stage_checking", "Checking IndexedDB and storage integrity for {account}..."},
        {"storage_recovery_stage_detected", "Storage corruption detected for {account}. Rebuilding database..."},
        {"storage_recovery_stage_repairing", "Purging corrupted IndexedDB/ServiceWorker caches (preserving logins)..."},
        {"storage_recovery_stage_reloading", "Reloading web view and mounting clean database..."},
        {"storage_recovery_stage_completed", "Storage recovery completed successfully!"},
        {"translation_privacy_title", "Translation & Privacy Notice"},
        {"translation_privacy_header", "Authorize Message Translation"},
        {"translation_privacy_body", "To translate chat messages not yet cached locally, their text will be sent to the configured translation provider ({provider})." & vbLf & vbLf & "Cloud providers (e.g. Google Translate) transmit message content to remote servers. You can also configure a local or self-hosted provider (LibreTranslate, Ollama, LM Studio) in Settings to keep all data on your machine." & vbLf & vbLf & "Do you want to authorize message translations?"},
        {"translation_privacy_allow", "Allow & Enable"},
        {"translation_privacy_settings", "Configure Provider..."},
        {"translation_consent_declined", "Translation cancelled: privacy consent required"},
        {"translation_provider", "Translation Provider"},
        {"translation_privacy_consent_checkbox", "I consent to sending message text to the selected translation provider"},
        {"translation_url", "Endpoint URL:"},
        {"translation_model", "Model Name:"},
        {"translation_api_key", "API Key (optional):"},
        {"translation_test_btn", "Test Connection"},
        {"translation_test_success", "✓ Connected successfully ({latency} ms)"},
        {"translation_test_failure", "✗ Connection failed: {error}"},
        {"translation_provider_unreachable", "Translation failed: Provider unreachable"}
    }


    ''' <summary>Dizionario di localizzazione nativa per l'interfaccia in lingua Italiana.</summary>
    Public Shared ReadOnly ItStrings As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From {
        {"settings", "Impostazioni"},
        {"theme", "Tema"},
        {"system", "Sistema"},
        {"light", "Chiaro"},
        {"dark", "Scuro"},
        {"match_cohesive", "Abbina questa impostazione nelle tue app per un aspetto coerente."},
        {"manage_accounts", "Gestione Account"},
        {"add_account", "Aggiungi account"},
        {"add_whatsapp_account", "Aggiungi account WhatsApp"},
        {"add_telegram_account", "Aggiungi account Telegram"},
        {"add_openclaw_account", "Aggiungi account OpenClaw"},
        {"add_hermes_account", "Aggiungi account Hermes Agent"},
        {"openclaw_server_url", "URL Gateway / Tailscale:"},
        {"openclaw_auth_token", "Token di Autenticazione Gateway:"},
        {"test_connection", "Verifica Connessione"},
        {"connection_testing", "Verifica in corso..."},
        {"connection_success", "✓ In linea"},
        {"connection_failed", "✗ Non raggiungibile"},
        {"select_platform", "Seleziona piattaforma"},
        {"always_show_tab_bar", "Mostra sempre la barra delle schede"},
        {"updates", "Aggiornamenti"},
        {"check_updates_launch", "Controlla aggiornamenti all'avvio"},
        {"check_now", "Controlla Ora"},
        {"devtools", "Strumenti di sviluppo"},
        {"debug_active_tab", "Debug scheda attiva"},
        {"delete_account_title", "Elimina Account"},
        {"delete_account_confirm", "Eliminare ""{name}""? Tutti i dati di questo account verranno rimossi."},
        {"delete_account_last", "Non è possibile eliminare l'unico account attivo."},
        {"cancel", "Annulla"},
        {"delete", "Elimina"},
        {"rename", "Rinomina"},
        {"language", "Lingua"},
        {"translate_to_lang", "Traduci in {lang}"},
        {"translate_all_messages", "Traduci tutti i messaggi"},
        {"toggle_window", "Mostra / Nascondi finestra"},
        {"exit", "Esci"},
        {"translate_message_button", "Pulsante traduci messaggio"},
        {"keep_app_in_english", "Mantieni interfaccia in inglese"},
        {"full_page_translation", "Traduci l'intera pagina"},
        {"show_translate_all_messages_button", "Pulsante traduci tutto nella barra del titolo"},
        {"reload_active_tab", "Ricarica scheda attiva"},
        {"use_beta_channel", "Usa canale di aggiornamento beta"},
        {"notifications", "Notifiche"},
        {"show_message_popup", "Mostra popup messaggio"},
        {"accounts_count_info", "Account configurati: {count} su {max}"},
        {"max_accounts_reached", "Raggiunto il limite massimo di {max} account."},
        {"max_accounts_downgrade_notice", "Avviso di downgrade: sono presenti {count} account attivi rispetto al limite massimo di {max}. Gli account esistenti restano attivi e funzionanti, ma non sarà possibile aggiungerne di nuovi finché non si rientra nel limite."},
        {"accounts_downgrade_blocked", "Impossibile aggiungere un account: sono presenti {count} account rispetto al limite massimo impostato di {max}. Rimuovi uno o più account o aumenta il limite per poterne aggiungere altri."},
        {"max_accounts", "Max account:"},
        {"about", "Informazioni"},
        {"about_title", "Informazioni su HidaChat"},
        {"app_description", "Client desktop Windows portatile, leggero e multi-account (WhatsApp, Telegram, OpenClaw, Hermes)."},
        {"author", "Autore"},
        {"release_date", "Data di rilascio"},
        {"license", "Licenza"},
        {"runtime_environment", "Ambiente e Framework"},
        {"portable_directory", "Percorso Dati Portatile"},
        {"github_repository", "Repository GitHub"},
        {"report_issue", "Segnala Problema"},
        {"view_releases", "Visualizza Release"},
        {"bulk_sender", "Invio Massivo Excel / CSV"},
        {"custom_css", "CSS Personalizzato"},
        {"enable_custom_css", "Abilita regole CSS personalizzate"},
        {"custom_css_placeholder", "/* Inserisci qui il tuo CSS personalizzato per WhatsApp e Telegram Web */"},
        {"apply_css", "Applica CSS"},
        {"css_applied", "CSS applicato con successo!"},
        {"css_preset_oled", "OLED Nero Puro"},
        {"css_preset_compact", "Layout Compatto"},
        {"css_preset_font", "Font Moderno"},
        {"css_preset_reset", "Ripristina"},
        {"contact_online", "Online"},
        {"contact_typing", "sta scrivendo..."},
        {"spellchecker", "Controllo Ortografico"},
        {"enable_spellchecker", "Abilita correttore ortografico nei campi di testo"},
        {"spellchecker_language", "Lingua del dizionario"},
        {"spellchecker_lang_auto", "Automatica (segue la lingua dell'app)"},
        {"spellchecker_restart_hint", "Le modifiche avranno effetto ricaricando le schede o riavviando HidaChat."},
        {"dnd_mode", "Non Disturbare (Focus Mode)"},
        {"dnd_enable", "Disattiva tutte le notifiche e i suoni"},
        {"dnd_duration", "Durata"},
        {"dnd_30m", "Per 30 minuti"},
        {"dnd_1h", "Per 1 ora"},
        {"dnd_2h", "Per 2 ore"},
        {"dnd_8h", "Per 8 ore"},
        {"dnd_indefinite", "Fino a disattivazione"},
        {"dnd_active_until", "Non Disturbare attivo fino alle {time}"},
        {"dnd_active_indefinite", "Non Disturbare attivo (indefinito)"},
        {"update_insufficient_permissions", "Impossibile aggiornare automaticamente." & vbCrLf & "L'applicazione non dispone dei permessi di scrittura nella cartella di installazione." & vbCrLf & vbCrLf & "Sposta l'applicazione in una cartella scrivibile dall'utente (es. Documenti, Desktop, o cartella su chiavetta USB)." & vbCrLf & "Evita directory di sistema protette come Programmi." & vbCrLf & vbCrLf & "Versione disponibile: v{version}"},
        {"update_insufficient_permissions_title", "Permessi Insufficienti"},
        {"update_missing_checksum", "Impossibile verificare l'integrità dell'aggiornamento." & vbCrLf & vbCrLf & "Nessun checksum crittografico SHA-256 valido è stato fornito con questa versione su GitHub." & vbCrLf & vbCrLf & "L'aggiornamento è stato interrotto per garantire la sicurezza del sistema."},
        {"update_integrity_failed_title", "Errore Integrità Aggiornamento"},
        {"update_checksum_mismatch", "Verifica di integrità fallita!" & vbCrLf & vbCrLf & "L'impronta crittografica SHA-256 del file di aggiornamento scaricato non corrisponde a quella attesa:" & vbCrLf & vbCrLf & "Hash calcolato: {computed}" & vbCrLf & "Hash atteso:    {expected}" & vbCrLf & vbCrLf & "L'aggiornamento è stato interrotto per garantire la sicurezza del sistema."},
        {"update_download_error", "Download dell'aggiornamento non riuscito o timeout superato:" & vbCrLf & vbCrLf & "{error}"},
        {"update_download_error_title", "Errore Download Aggiornamento"},
        {"update_signature_invalid", "Verifica della firma digitale fallita sull'eseguibile di aggiornamento." & vbCrLf & vbCrLf & "L'installazione è stata interrotta per garantire la sicurezza del sistema."},
        {"update_already_latest", "Hai già la versione più recente (v{version})!"},
        {"update_already_latest_title", "Aggiornato"},
        {"update_no_new_version", "La versione remota (v{remote}) è precedente o uguale a quella corrente (v{current})."},
        {"update_no_new_version_title", "Aggiornamento"},
        {"update_available_prompt", "È disponibile una nuova versione di HidaChat (v{version})!" & vbCrLf & vbCrLf & "Desideri scaricare ed installare l'aggiornamento ora?"},
        {"update_available_title", "Aggiornamento Disponibile"},
        {"update_install_error", "Errore durante l'installazione dell'aggiornamento:" & vbCrLf & vbCrLf & "{error}"},
        {"update_install_error_title", "Errore Aggiornamento"},
        {"update_check_failed", "Errore durante la verifica degli aggiornamenti:" & vbCrLf & vbCrLf & "{error}"},
        {"update_check_failed_network", "Impossibile verificare la presenza di aggiornamenti. Verifica la connessione Internet o riprova più tardi."},
        {"update_check_failed_title", "Verifica Aggiornamenti"},
        {"update_no_asset", "Nessun pacchetto di aggiornamento valido allegato alla versione remota."},
        {"settings_corrupt_recovery_title", "Ripristino Impostazioni"},
        {"settings_corrupt_recovered_msg", "Il file di configurazione 'settings.json' risultava danneggiato ed è stato archiviato come '{file}'." & vbCrLf & vbCrLf & "Le impostazioni e gli account sono stati ripristinati con successo dall'ultimo backup (.bak) disponibile."},
        {"settings_corrupt_reset_title", "Errore Configurazione"},
        {"settings_corrupt_reset_msg", "Il file di configurazione 'settings.json' risultava danneggiato ed è stato archiviato come '{file}'." & vbCrLf & vbCrLf & "Non è stato possibile recuperare un backup valido: l'applicazione è stata avviata con le impostazioni predefinite."},
        {"network_drive_warning_title", "Avviso Unità di Rete"},
        {"network_drive_warning_msg", "HidaChat è in esecuzione da un'unità di rete ({path})." & vbCrLf & vbCrLf & "Attenzione: Microsoft WebView2 non supporta l'archiviazione dei profili browser su unità di rete o condivisioni SMB. Questo causa frequentemente la disconnessione o la perdita della sessione di WhatsApp ad ogni riavvio." & vbCrLf & vbCrLf & "Si raccomanda di eseguire HidaChat da un disco locale (es. C:\HidaChat)."},
        {"network_drive_staging_info", "HidaChat è in esecuzione su un'unità di rete ({path})." & vbCrLf & vbCrLf & "Lo Staging Locale delle Sessioni è ATTIVO: le credenziali e i database vengono gestiti localmente e risincronizzati automaticamente sulla cartella di rete alla chiusura per prevenire disconnessioni di WebView2."},
        {"network_drive_section", "Unità di Rete"},
        {"enable_network_profile_staging", "Abilita staging locale per dischi di rete"},
        {"enable_network_profile_staging_hint", "Migliora la stabilità e previene la perdita della sessione WhatsApp quando l'app risiede su cartelle di rete (SMB/UNC)."},
        {"network_drive_session_conflict", "Attenzione: L'account '{name}' risulta già attivo su un altro computer ({machine}). L'uso simultaneo può causare disconnessioni."},
        {"secret_decrypt_error_title", "Avviso Decifratura Credenziali"},
        {"secret_decrypt_error_msg", "Impossibile decifrare la chiave Tailscale AuthKey memorizzata: la cartella dell'applicazione è stata aperta su un computer o profilo utente Windows differente rispetto a dove è stata salvata (la protezione DPAPI è vincolata alla macchina/utente locale)." & vbCrLf & vbCrLf & "Per riattivare l'integrazione con Tailscale, reinserisci l'AuthKey nelle Impostazioni."},
        {"folder_locked_title", "Cartella Applicazione in Uso"},
        {"folder_locked_msg", "La cartella di HidaChat è attualmente bloccata ed in uso da un'altra postazione o processo:" & vbCrLf & vbCrLf & "• Computer: {machine}" & vbCrLf & "• Utente: {user}" & vbCrLf & "• PID: {pid}" & vbCrLf & "• Avviato il: {time}" & vbCrLf & vbCrLf & "Per prevenire la corruzione dei profili WebView2 e dei dati di sessione, non è consentito avviare contemporaneamente più istanze dalla stessa cartella."},
        {"close", "Chiudi"},
        {"tab_hibernation_section", "Ibernazione Schede"},
        {"enable_tab_hibernation", "Abilita ibernazione schede inattive"},
        {"enable_tab_hibernation_hint", "Riduce il consumo di memoria RAM sospendendo le schede in background inattive. Si riattivano istantaneamente quando vengono selezionate."},
        {"tab_hibernation_timeout", "Tempo di inattività:"},
        {"cache_section", "Cache e Archiviazione"},
        {"disk_cache_limit", "Limite cache disco Chromium:"},
        {"disk_cache_limit_hint", "Limita lo spazio massimo su disco occupato dalla cache HTTP di Chromium per profilo (applicato alla ricarica della scheda)."},
        {"smart_clean_cache_btn", "Pulisci Cache (preserva login)"},
        {"smart_clean_cache_hint", "Elimina file temporanei, cache HTTP, shader e GPU senza disconnettere gli account (cookie, sessioni e IndexedDB rimangono intatti)."},
        {"smart_clean_cache_confirm_title", "Pulizia Cache"},
        {"smart_clean_cache_confirm_msg", "Vuoi eseguire la pulizia dei file temporanei e della cache browser per tutti gli account? Le sessioni di accesso e le credenziali verranno preservate."},
        {"smart_clean_cache_success_title", "Pulizia Completata"},
        {"smart_clean_cache_success_msg", "Pulizia cache completata con successo! Le sessioni degli account sono state preservate."},
        {"account_clean_cache", "Pulisci cache account"},
        {"hibernated_badge_tooltip", "Scheda ibernata (risveglio automatico al click)"},
        {"account_repair_tab", "Ripara scheda (ripristina database corrotto)"},
        {"account_repair_confirm_title", "Ripara Scheda"},
        {"account_repair_confirm_msg", "Questa operazione ripristinerà il database locale e la cache dei service worker della scheda, quindi ricaricherà la pagina per risolvere schermate bianche o corruzioni dei dati. Continuare?"},
        {"account_repair_success_title", "Riparazione Completata"},
        {"account_repair_success_msg", "Lo storage della scheda è stato riparato e la pagina è stata ricaricata."},
        {"shutdown_dialog_title", "Chiusura di HidaChat"},
        {"shutdown_dialog_header", "Salvataggio dati e chiusura in corso..."},
        {"shutdown_stage_settings", "Salvataggio impostazioni e preferenze account..."},
        {"shutdown_stage_webviews", "Chiusura controllata delle sessioni browser..."},
        {"shutdown_stage_network_sync", "Sincronizzazione profili e chat su cartella di rete..."},
        {"shutdown_stage_tsnet", "Arresto proxy di rete e rilascio risorse..."},
        {"shutdown_stage_complete", "Finalizzazione e chiusura..."},
        {"tailscale_dialog_title", "Stato Connessione Tailscale"},
        {"tailscale_dialog_header", "Impossibile caricare {platform}: {name}"},
        {"tailscale_error_tsnet_needs_login", "Il nodo Tailscale integrato richiede l'autenticazione. Effettua il login per connetterti alla tua Tailnet e accedere al servizio."},
        {"tailscale_error_tsnet_stopped", "Il servizio Tailscale integrato (tsnet) non è in esecuzione o non è riuscito ad avviarsi."},
        {"tailscale_error_node_unreachable", "La connessione Tailscale è attiva, ma l'host remoto '{host}' non è raggiungibile o è spento. Verifica che il dispositivo remoto sia acceso e connesso alla tua Tailnet."},
        {"tailscale_error_client_disconnected", "Il client Tailscale non risulta attivo o connesso su questo computer. Avvia e connetti Tailscale, quindi riprova."},
        {"tailscale_error_generic_failure", "Impossibile raggiungere il server '{host}'. Si è verificato un errore di rete o timeout di connessione."},
        {"tailscale_btn_retry", "Riprova"},
        {"tailscale_btn_login", "Accedi a Tailscale"},
        {"tailscale_btn_settings", "Apri Impostazioni"},
        {"tailscale_btn_close", "Chiudi"},
        {"storage_recovery_dialog_title", "Ripristino Integrità Storage"},
        {"storage_recovery_dialog_header", "Ripristino storage locale e database in corso..."},
        {"storage_recovery_stage_checking", "Verifica integrità IndexedDB e storage per {account}..."},
        {"storage_recovery_stage_detected", "Rilevata corruzione dello storage per {account}. Rigenerazione database..."},
        {"storage_recovery_stage_repairing", "Pulizia cache IndexedDB/ServiceWorker corrotte (sessioni salvaguardate)..."},
        {"storage_recovery_stage_reloading", "Ricaricamento vista web e inizializzazione database pulito..."},
        {"storage_recovery_stage_completed", "Ripristino storage completato con successo!"},
        {"translation_privacy_title", "Informativa sulla Privacy e Traduzioni"},
        {"translation_privacy_header", "Autorizzazione Traduzione Messaggi"},
        {"translation_privacy_body", "Per tradurre i messaggi di chat non ancora presenti nella cache locale, il relativo testo verrà inviato al fornitore di traduzione configurato ({provider})." & vbLf & vbLf & "I provider in cloud (come Google Translate) trasmettono il contenuto dei messaggi a server remoti. Puoi anche configurare un provider locale o self-hosted (LibreTranslate, Ollama, LM Studio) nelle Impostazioni per mantenere tutti i dati sul tuo computer." & vbLf & vbLf & "Vuoi autorizzare la traduzione dei messaggi?"},
        {"translation_privacy_allow", "Consenti e Attiva"},
        {"translation_privacy_settings", "Configura Provider..."},
        {"translation_consent_declined", "Traduzione annullata: consenso privacy non concesso"},
        {"translation_provider", "Fornitore di Traduzione"},
        {"translation_privacy_consent_checkbox", "Acconsento all'invio del testo dei messaggi al provider di traduzione selezionato"},
        {"translation_url", "URL Endpoint:"},
        {"translation_model", "Nome Modello:"},
        {"translation_api_key", "Chiave API (opzionale):"},
        {"translation_test_btn", "Testa Connessione"},
        {"translation_test_success", "✓ Connesso con successo ({latency} ms)"},
        {"translation_test_failure", "✗ Connessione non riuscita: {error}"},
        {"translation_provider_unreachable", "Traduzione non riuscita: Provider non raggiungibile"}
    }


    ''' <summary>Dizionario di localizzazione nativa per l'interfaccia in lingua Francese.</summary>
    Public Shared ReadOnly FrStrings As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From {
        {"settings", "Paramètres"},
        {"theme", "Thème"},
        {"system", "Système"},
        {"light", "Clair"},
        {"dark", "Sombre"},
        {"match_cohesive", "Harmonisez ce paramètre dans vos applications pour un aspect cohérent."},
        {"manage_accounts", "Gestion des comptes"},
        {"add_account", "Ajouter un compte"},
        {"add_whatsapp_account", "Ajouter un compte WhatsApp"},
        {"add_telegram_account", "Ajouter un compte Telegram"},
        {"add_openclaw_account", "Ajouter un compte OpenClaw"},
        {"add_hermes_account", "Ajouter un compte Hermes Agent"},
        {"openclaw_server_url", "URL Passerelle / Tailscale :"},
        {"openclaw_auth_token", "Jeton d'authentification Passerelle :"},
        {"test_connection", "Tester la connexion"},
        {"connection_testing", "Vérification..."},
        {"connection_success", "✓ En ligne"},
        {"connection_failed", "✗ Inaccessible"},
        {"select_platform", "Sélectionner la plateforme"},
        {"always_show_tab_bar", "Toujours afficher la barre des onglets"},
        {"updates", "Mises à jour"},
        {"check_updates_launch", "Rechercher les mises à jour au démarrage"},
        {"check_now", "Vérifier maintenant"},
        {"devtools", "Outils de développement"},
        {"debug_active_tab", "Déboguer l'onglet actif"},
        {"delete_account_title", "Supprimer le compte"},
        {"delete_account_confirm", "Supprimer ""{name}"" ? Toutes les données de ce compte seront supprimées."},
        {"delete_account_last", "Vous ne pouvez pas supprimer le seul compte actif."},
        {"cancel", "Annuler"},
        {"delete", "Supprimer"},
        {"rename", "Renommer"},
        {"language", "Langue"},
        {"translate_to_lang", "Traduire en {lang}"},
        {"translate_all_messages", "Traduire tous les messages"},
        {"toggle_window", "Afficher / Masquer la fenêtre"},
        {"exit", "Quitter"},
        {"translate_message_button", "Bouton de traduction du message"},
        {"keep_app_in_english", "Conserver l'interface en anglais"},
        {"full_page_translation", "Traduire toute la page"},
        {"show_translate_all_messages_button", "Bouton de traduction de tous les messages dans la barre"},
        {"reload_active_tab", "Recharger l'onglet actif"},
        {"use_beta_channel", "Utiliser le canal de mise à jour bêta"},
        {"notifications", "Notifications"},
        {"show_message_popup", "Afficher la notification popup"},
        {"accounts_count_info", "Comptes configurés : {count} sur {max}"},
        {"max_accounts_reached", "Limite maximale de {max} comptes atteinte."},
        {"max_accounts_downgrade_notice", "Avis de déclassement : vous avez {count} comptes actifs dépassant la limite maximale de {max}. Les comptes existants sont conservés et opérationnels, mais l'ajout de nouveaux comptes est désactivé jusqu'à ce que vous soyez sous la limite."},
        {"accounts_downgrade_blocked", "Impossible d'ajouter un compte : vous avez {count} comptes configurés pour une limite de {max}. Supprimez un ou plusieurs comptes ou augmentez la limite pour en ajouter de nouveaux."},
        {"max_accounts", "Comptes maximum :"},
        {"about", "À propos"},
        {"about_title", "À propos de HidaChat"},
        {"app_description", "Client de bureau multi-comptes léger et portable pour Windows (WhatsApp, Telegram, OpenClaw, Hermes)."},
        {"author", "Auteur"},
        {"release_date", "Date de version"},
        {"license", "Licence"},
        {"runtime_environment", "Environnement et Framework"},
        {"portable_directory", "Répertoire de données portable"},
        {"github_repository", "Dépôt GitHub"},
        {"report_issue", "Signaler un problème"},
        {"view_releases", "Voir les versions"},
        {"bulk_sender", "Envoi en masse Excel / CSV"},
        {"custom_css", "CSS Personnalisé"},
        {"enable_custom_css", "Activer les règles CSS personnalisées"},
        {"custom_css_placeholder", "/* Écrivez ou collez ici votre CSS personnalisé pour WhatsApp et Telegram Web */"},
        {"apply_css", "Appliquer le CSS"},
        {"css_applied", "CSS appliqué avec succès !"},
        {"css_preset_oled", "OLED Noir Pur"},
        {"css_preset_compact", "Disposition compacte"},
        {"css_preset_font", "Police moderne"},
        {"css_preset_reset", "Effacer"},
        {"contact_online", "En ligne"},
        {"contact_typing", "écrit..."},
        {"spellchecker", "Correcteur orthographique"},
        {"enable_spellchecker", "Activer le correcteur orthographique dans les champs de saisie"},
        {"spellchecker_language", "Langue du dictionnaire"},
        {"spellchecker_lang_auto", "Automatique (suivre la langue de l'app)"},
        {"spellchecker_restart_hint", "Les modifications s'appliqueront après le rechargement des onglets ou le redémarrage de HidaChat."},
        {"dnd_mode", "Mode Ne pas déranger"},
        {"dnd_enable", "Désactiver toutes les notifications et les sons"},
        {"dnd_duration", "Durée"},
        {"dnd_30m", "Pendant 30 minutes"},
        {"dnd_1h", "Pendant 1 heure"},
        {"dnd_2h", "Pendant 2 heures"},
        {"dnd_8h", "Pendant 8 heures"},
        {"dnd_indefinite", "Jusqu'à désactivation"},
        {"dnd_active_until", "Ne pas déranger actif jusqu'à {time}"},
        {"dnd_active_indefinite", "Ne pas déranger actif (indéfini)"},
        {"update_insufficient_permissions", "Impossible de mettre à jour automatiquement." & vbCrLf & "L'application n'a pas les droits d'écriture dans le dossier d'installation." & vbCrLf & vbCrLf & "Veuillez déplacer l'application vers un dossier accessible en écriture (ex. Documents, Bureau ou clé USB)." & vbCrLf & "Évitez les dossiers système protégés comme Program Files." & vbCrLf & vbCrLf & "Version disponible : v{version}"},
        {"update_insufficient_permissions_title", "Autorisations insuffisantes"},
        {"update_missing_checksum", "Impossible de vérifier l'intégrité de la mise à jour." & vbCrLf & vbCrLf & "Aucune somme de contrôle cryptographique SHA-256 valide n'a été fournie avec cette version sur GitHub." & vbCrLf & vbCrLf & "La mise à jour a été annulée pour des raisons de sécurité."},
        {"update_integrity_failed_title", "Erreur d'Intégrité de Mise à Jour"},
        {"update_checksum_mismatch", "Échec de la vérification d'intégrité !" & vbCrLf & vbCrLf & "L'empreinte cryptographique SHA-256 du fichier de mise à jour téléchargé ne correspond pas à celle attendue :" & vbCrLf & vbCrLf & "Calculé : {computed}" & vbCrLf & "Attendu :  {expected}" & vbCrLf & vbCrLf & "La mise à jour a été interrompue pour garantir la sécurité du système."},
        {"update_download_error", "Le téléchargement de la mise à jour a échoué ou le délai a expiré :" & vbCrLf & vbCrLf & "{error}"},
        {"update_download_error_title", "Erreur de Téléchargement"},
        {"update_signature_invalid", "La vérification de la signature numérique a échoué sur l'exécutable de mise à jour." & vbCrLf & vbCrLf & "L'installation a été interrompue pour des raisons de sécurité."},
        {"update_already_latest", "Vous disposez déjà de la version la plus récente (v{version}) !"},
        {"update_already_latest_title", "À jour"},
        {"update_no_new_version", "La version distante (v{remote}) est antérieure ou égale à la version actuelle (v{current})."},
        {"update_no_new_version_title", "Mise à jour"},
        {"update_available_prompt", "Une nouvelle version de HidaChat (v{version}) est disponible !" & vbCrLf & vbCrLf & "Souhaitez-vous télécharger et installer la mise à jour maintenant ?"},
        {"update_available_title", "Mise à jour disponible"},
        {"update_install_error", "Une erreur est survenue lors de l'installation de la mise à jour :" & vbCrLf & vbCrLf & "{error}"},
        {"update_install_error_title", "Erreur de mise à jour"},
        {"update_check_failed", "Échec de la recherche de mises à jour :" & vbCrLf & vbCrLf & "{error}"},
        {"update_check_failed_network", "Impossible de vérifier les mises à jour. Veuillez vérifier votre connexion Internet ou réessayer plus tard."},
        {"update_check_failed_title", "Vérification des mises à jour"},
        {"update_no_asset", "Aucun package de mise à jour n'est associé à la version distante."},
        {"settings_corrupt_recovery_title", "Récupération des Paramètres"},
        {"settings_corrupt_recovered_msg", "Le fichier de configuration 'settings.json' était corrompu et a été archivé sous '{file}'." & vbCrLf & vbCrLf & "Les paramètres et les comptes ont été restaurés avec succès à partir de la dernière sauvegarde (.bak) disponible."},
        {"settings_corrupt_reset_title", "Erreur de Configuration"},
        {"settings_corrupt_reset_msg", "Le fichier de configuration 'settings.json' était corrompu et a été archivé sous '{file}'." & vbCrLf & vbCrLf & "Une sauvegarde valide n'a pas pu être récupérée : l'application a démarré avec les paramètres par défaut."},
        {"network_drive_warning_title", "Avertissement Lecteur Réseau"},
        {"network_drive_warning_msg", "HidaChat s'exécute à partir d'un lecteur réseau ({path})." & vbCrLf & vbCrLf & "Attention : Microsoft WebView2 ne prend pas en charge le stockage des profils de navigation sur des partages réseau ou SMB. Cela entraîne fréquemment la perte de session ou la déconnexion de WhatsApp Web au redémarrage." & vbCrLf & vbCrLf & "Il est fortement recommandé d'exécuter HidaChat depuis un disque local (ex. C:\HidaChat)."},
        {"network_drive_staging_info", "HidaChat s'exécute depuis un lecteur réseau ({path})." & vbCrLf & vbCrLf & "Le relais local des sessions est ACTIF : les données de session sont traitées localement et synchronisées sur le partage réseau à la fermeture pour éviter la perte de session WebView2."},
        {"network_drive_section", "Lecteurs Réseau"},
        {"enable_network_profile_staging", "Activer le relais local pour les lecteurs réseau"},
        {"enable_network_profile_staging_hint", "Améliore la stabilité et évite la déconnexion de WhatsApp lors de l'exécution sur un partage réseau (SMB/UNC)."},
        {"network_drive_session_conflict", "Attention : Le compte '{name}' semble actif sur un autre ordinateur ({machine}). L'utilisation simultanée peut entraîner des déconnexions."},
        {"secret_decrypt_error_title", "Avertissement de Déchiffrement des Identifiants"},
        {"secret_decrypt_error_msg", "Impossible de déchiffrer la clé Tailscale AuthKey enregistrée : le dossier de l'application a été ouvert sur un ordinateur ou un profil utilisateur Windows différent (la protection DPAPI est liée à la machine locale)." & vbCrLf & vbCrLf & "Pour réactiver l'intégration Tailscale, veuillez saisir à nouveau l'AuthKey dans les Paramètres."},
        {"folder_locked_title", "Dossier d'Application en Cours d'Utilisation"},
        {"folder_locked_msg", "Le dossier HidaChat est actuellement verrouillé et utilisé par un autre poste ou processus :" & vbCrLf & vbCrLf & "• Ordinateur : {machine}" & vbCrLf & "• Utilisateur : {user}" & vbCrLf & "• PID : {pid}" & vbCrLf & "• Démarré le : {time}" & vbCrLf & vbCrLf & "Pour éviter toute corruption des profils WebView2 et des sessions, l'exécution simultanée depuis le même dossier n'est pas autorisée."},
        {"close", "Fermer"},
        {"tab_hibernation_section", "Mise en Veille des Onglets"},
        {"enable_tab_hibernation", "Activer la mise en veille des onglets inactifs"},
        {"enable_tab_hibernation_hint", "Réduit l'utilisation de la RAM en suspendant les onglets d'arrière-plan inactifs. Ils reprennent instantanément lors de la sélection."},
        {"tab_hibernation_timeout", "Délai d'inactivité :"},
        {"cache_section", "Cache et Stockage"},
        {"disk_cache_limit", "Limite du cache disque Chromium :"},
        {"disk_cache_limit_hint", "Limite l'espace disque utilisé par le cache HTTP Chromium par profil (appliqué au rechargement de l'onglet)."},
        {"smart_clean_cache_btn", "Nettoyer le cache (garder session)"},
        {"smart_clean_cache_hint", "Supprime les fichiers temporaires, le cache HTTP, shaders et GPU sans déconnecter les comptes (cookies, sessions et IndexedDB restent intacts)."},
        {"smart_clean_cache_confirm_title", "Nettoyage du Cache"},
        {"smart_clean_cache_confirm_msg", "Voulez-vous nettoyer les fichiers temporaires et les caches de navigation pour tous les comptes ? Les sessions et identifiants seront préservés."},
        {"smart_clean_cache_success_title", "Cache Nettoyé"},
        {"smart_clean_cache_success_msg", "Nettoyage du cache terminé avec succès ! Les sessions de compte ont été préservées."},
        {"account_clean_cache", "Nettoyer le cache du compte"},
        {"hibernated_badge_tooltip", "Onglet en veille (reprise automatique au clic)"},
        {"account_repair_tab", "Réparer l'onglet (réinitialiser base de données)"},
        {"account_repair_confirm_title", "Réparer l'onglet"},
        {"account_repair_confirm_msg", "Cette opération réinitialisera la base de données locale et le cache des service workers de l'onglet, puis rechargera la page pour corriger les écrans blancs. Continuer ?"},
        {"account_repair_success_title", "Réparation terminée"},
        {"account_repair_success_msg", "Le stockage de l'onglet a été réparé et la page a été rechargée."},
        {"shutdown_dialog_title", "Fermeture de HidaChat"},
        {"shutdown_dialog_header", "Enregistrement des données et fermeture..."},
        {"shutdown_stage_settings", "Enregistrement des paramètres et préférences..."},
        {"shutdown_stage_webviews", "Arrêt contrôlé des processus de navigation..."},
        {"shutdown_stage_network_sync", "Synchronisation des profils et discussions sur le réseau..."},
        {"shutdown_stage_tsnet", "Arrêt du proxy réseau et libération des verrous..."},
        {"shutdown_stage_complete", "Finalisation et fermeture..."},
        {"tailscale_dialog_title", "État de la connexion Tailscale"},
        {"tailscale_dialog_header", "Impossible de charger {platform} : {name}"},
        {"tailscale_error_tsnet_needs_login", "Le nœud Tailscale intégré nécessite une authentification. Veuillez vous connecter à votre Tailnet pour accéder au service."},
        {"tailscale_error_tsnet_stopped", "Le service Tailscale intégré (tsnet) n'est pas en cours d'exécution ou n'a pas pu démarrer."},
        {"tailscale_error_node_unreachable", "La connexion Tailscale est active, mais l'hôte distant '{host}' est inaccessible ou éteint. Veuillez vérifier que l'appareil distant est allumé et connecté à votre Tailnet."},
        {"tailscale_error_client_disconnected", "Le client Tailscale n'est pas actif ou déconnecté sur cet ordinateur. Veuillez démarrer et connecter Tailscale, puis réessayez."},
        {"tailscale_error_generic_failure", "Impossible d'atteindre le serveur '{host}'. Une erreur réseau ou un délai d'attente s'est produit."},
        {"tailscale_btn_retry", "Réessayer"},
        {"tailscale_btn_login", "Se connecter à Tailscale"},
        {"tailscale_btn_settings", "Ouvrir les Paramètres"},
        {"tailscale_btn_close", "Fermer"},
        {"storage_recovery_dialog_title", "Récupération de l'intégrité du stockage"},
        {"storage_recovery_dialog_header", "Réparation du stockage local et de la base de données..."},
        {"storage_recovery_stage_checking", "Vérification de l'intégrité d'IndexedDB et du stockage pour {account}..."},
        {"storage_recovery_stage_detected", "Corruption du stockage détectée pour {account}. Reconstruction de la base de données..."},
        {"storage_recovery_stage_repairing", "Nettoyage des caches IndexedDB/ServiceWorker corrompus (sessions préservées)..."},
        {"storage_recovery_stage_reloading", "Rechargement de la vue web et initialisation d'une base saine..."},
        {"storage_recovery_stage_completed", "Récupération du stockage terminée avec succès !"},
        {"translation_privacy_title", "Avis de Confidentialité et Traduction"},
        {"translation_privacy_header", "Autorisation de Traduction des Messages"},
        {"translation_privacy_body", "Pour traduire les messages de chat non encore en cache local, leur texte sera envoyé au fournisseur configuré ({provider})." & vbLf & vbLf & "Les services cloud (ex. Google Translate) transmettent le contenu à des serveurs distants. Vous pouvez aussi configurer un fournisseur local ou auto-hébergé (LibreTranslate, Ollama, LM Studio) dans les Paramètres pour préserver votre confidentialité." & vbLf & vbLf & "Souhaitez-vous autoriser la traduction des messages ?"},
        {"translation_privacy_allow", "Autoriser et Activer"},
        {"translation_privacy_settings", "Configurer Fournisseur..."},
        {"translation_consent_declined", "Traduction annulée : consentement requis"},
        {"translation_provider", "Fournisseur de Traduction"},
        {"translation_privacy_consent_checkbox", "J'accepte d'envoyer le texte des messages au fournisseur de traduction sélectionné"},
        {"translation_url", "URL du Point de Terminaison :"},
        {"translation_model", "Nom du Modèle :"},
        {"translation_api_key", "Clé API (optionnel) :"},
        {"translation_test_btn", "Tester la Connexion"},
        {"translation_test_success", "✓ Connexion réussie ({latency} ms)"},
        {"translation_test_failure", "✗ Échec de la connexion : {error}"},
        {"translation_provider_unreachable", "Traduction échouée : Fournisseur inaccessible"}
    }


    ''' <summary>Dizionario di localizzazione nativa per l'interfaccia in lingua Spagnola.</summary>
    Public Shared ReadOnly EsStrings As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From {
        {"settings", "Ajustes"},
        {"theme", "Tema"},
        {"system", "Sistema"},
        {"light", "Claro"},
        {"dark", "Oscuro"},
        {"match_cohesive", "Haga coincidir este ajuste en sus aplicaciones para una apariencia coherente."},
        {"manage_accounts", "Administrar Cuentas"},
        {"add_account", "Añadir cuenta"},
        {"add_whatsapp_account", "Añadir cuenta de WhatsApp"},
        {"add_telegram_account", "Añadir cuenta de Telegram"},
        {"add_openclaw_account", "Añadir cuenta de OpenClaw"},
        {"add_hermes_account", "Añadir cuenta de Hermes Agent"},
        {"openclaw_server_url", "URL Gateway / Tailscale:"},
        {"openclaw_auth_token", "Token de Autenticación Gateway:"},
        {"test_connection", "Probar Conexión"},
        {"connection_testing", "Comprobando..."},
        {"connection_success", "✓ En línea"},
        {"connection_failed", "✗ No accesible"},
        {"select_platform", "Seleccionar plataforma"},
        {"always_show_tab_bar", "Mostrar siempre la barra de pestañas"},
        {"updates", "Actualizaciones"},
        {"check_updates_launch", "Buscar actualizaciones al iniciar"},
        {"check_now", "Comprobar ahora"},
        {"devtools", "Herramientas de desarrollo"},
        {"debug_active_tab", "Depurar pestaña activa"},
        {"delete_account_title", "Eliminar Cuenta"},
        {"delete_account_confirm", "¿Eliminar ""{name}""? Todos los datos de esta cuenta se eliminarán."},
        {"delete_account_last", "No puede eliminar la única cuenta activa."},
        {"cancel", "Cancelar"},
        {"delete", "Eliminar"},
        {"rename", "Renombrar"},
        {"language", "Idioma"},
        {"translate_to_lang", "Traducir a {lang}"},
        {"translate_all_messages", "Traducir todos los mensajes"},
        {"toggle_window", "Mostrar/Ocultar ventana"},
        {"exit", "Salir"},
        {"translate_message_button", "Botón de traducción de mensaje"},
        {"keep_app_in_english", "Mantener la interfaz en inglés"},
        {"full_page_translation", "Traducir toda la página"},
        {"show_translate_all_messages_button", "Botón de traducir todos los mensajes en la barra"},
        {"reload_active_tab", "Recargar pestaña activa"},
        {"use_beta_channel", "Usar canal de actualizaciones beta"},
        {"notifications", "Notificaciones"},
        {"show_message_popup", "Mostrar ventana emergente de mensaje"},
        {"accounts_count_info", "Cuentas configuradas: {count} de {max}"},
        {"max_accounts_reached", "Límite máximo de {max} cuentas alcanzado."},
        {"max_accounts_downgrade_notice", "Aviso de reducción: tiene {count} cuentas activas, superando el límite máximo de {max}. Las cuentas existentes se mantienen operativas, pero no se pueden añadir nuevas cuentas hasta que esté por debajo del límite."},
        {"accounts_downgrade_blocked", "No se puede añadir una cuenta: tiene {count} cuentas configuradas para un límite de {max}. Elimine una o más cuentas o aumente el límite para añadir más."},
        {"max_accounts", "Cuentas máximas:"},
        {"about", "Acerca de"},
        {"about_title", "Acerca de HidaChat"},
        {"app_description", "Cliente de escritorio multicuenta ligero y portátil para Windows (WhatsApp, Telegram, OpenClaw, Hermes)."},
        {"author", "Autor"},
        {"release_date", "Fecha de lanzamiento"},
        {"license", "Licencia"},
        {"runtime_environment", "Entorno y Framework"},
        {"portable_directory", "Ruta de datos portátil"},
        {"github_repository", "Repositorio de GitHub"},
        {"report_issue", "Informar de un problema"},
        {"view_releases", "Ver versiones"},
        {"bulk_sender", "Envío Masivo desde Excel / CSV"},
        {"custom_css", "CSS Personalizado"},
        {"enable_custom_css", "Habilitar reglas CSS personalizadas"},
        {"custom_css_placeholder", "/* Escriba o pegue aquí su CSS personalizado para WhatsApp y Telegram Web */"},
        {"apply_css", "Aplicar CSS"},
        {"css_applied", "¡CSS aplicado con éxito!"},
        {"css_preset_oled", "OLED Negro Puro"},
        {"css_preset_compact", "Diseño Compacto"},
        {"css_preset_font", "Fuente Moderna"},
        {"css_preset_reset", "Borrar"},
        {"contact_online", "En línea"},
        {"contact_typing", "escribiendo..."},
        {"spellchecker", "Corrector ortográfico"},
        {"enable_spellchecker", "Activar corrector ortográfico en los campos de entrada"},
        {"spellchecker_language", "Idioma del diccionario"},
        {"spellchecker_lang_auto", "Automática (seguir idioma de la app)"},
        {"spellchecker_restart_hint", "Los cambios se aplicarán al recargar las pestañas o reiniciar HidaChat."},
        {"dnd_mode", "Modo No Molestar"},
        {"dnd_enable", "Silenciar todas las notificaciones y sonidos"},
        {"dnd_duration", "Duración"},
        {"dnd_30m", "Durante 30 minutos"},
        {"dnd_1h", "Durante 1 hora"},
        {"dnd_2h", "Durante 2 horas"},
        {"dnd_8h", "Durante 8 horas"},
        {"dnd_indefinite", "Hasta que se desactive"},
        {"dnd_active_until", "No Molestar activo hasta las {time}"},
        {"dnd_active_indefinite", "No Molestar activo (indefinido)"},
        {"update_insufficient_permissions", "No se puede actualizar automáticamente." & vbCrLf & "La aplicación no tiene permisos de escritura en la carpeta de instalación." & vbCrLf & vbCrLf & "Mueva la aplicación a una carpeta con permisos de escritura (ej. Documentos, Escritorio o memoria USB)." & vbCrLf & "Evite carpetas protegidas del sistema como Archivos de programa." & vbCrLf & vbCrLf & "Versión disponible: v{version}"},
        {"update_insufficient_permissions_title", "Permisos insuficientes"},
        {"update_missing_checksum", "No se puede verificar la integridad de la actualización." & vbCrLf & vbCrLf & "No se proporcionó una suma de comprobación criptográfica SHA-256 válida con esta versión en GitHub." & vbCrLf & vbCrLf & "La actualización se canceló por motivos de seguridad."},
        {"update_integrity_failed_title", "Error de Integridad de Actualización"},
        {"update_checksum_mismatch", "¡Error en la verificación de integridad!" & vbCrLf & vbCrLf & "La huella criptográfica SHA-256 del archivo de actualización descargado no coincide con la esperada:" & vbCrLf & vbCrLf & "Calculado: {computed}" & vbCrLf & "Esperado:  {expected}" & vbCrLf & vbCrLf & "La actualización se detuvo para garantizar la seguridad del sistema."},
        {"update_download_error", "Error al descargar la actualización o tiempo de espera agotado:" & vbCrLf & vbCrLf & "{error}"},
        {"update_download_error_title", "Error de Descarga de Actualización"},
        {"update_signature_invalid", "Falló la verificación de la firma digital en el ejecutable de actualización." & vbCrLf & vbCrLf & "La instalación se canceló por motivos de seguridad."},
        {"update_already_latest", "¡Ya tiene la versión más reciente (v{version})!"},
        {"update_already_latest_title", "Actualizado"},
        {"update_no_new_version", "La versión remota (v{remote}) es anterior o igual a la actual (v{current})."},
        {"update_no_new_version_title", "Actualización"},
        {"update_available_prompt", "¡Hay una nueva versión de HidaChat (v{version}) disponible!" & vbCrLf & vbCrLf & "¿Desea descargar e instalar la actualización ahora?"},
        {"update_available_title", "Actualización disponible"},
        {"update_install_error", "Ocurrió un error al instalar la actualización:" & vbCrLf & vbCrLf & "{error}"},
        {"update_install_error_title", "Error de actualización"},
        {"update_check_failed", "Error al comprobar actualizaciones:" & vbCrLf & vbCrLf & "{error}"},
        {"update_check_failed_network", "No se pudieron comprobar las actualizaciones. Compruebe su conexión a Internet o inténtelo de nuevo más tarde."},
        {"update_check_failed_title", "Comprobación de actualizaciones"},
        {"update_no_asset", "No hay ningún paquete de actualización adjunto a la versión remota."},
        {"settings_corrupt_recovery_title", "Recuperación de Configuración"},
        {"settings_corrupt_recovered_msg", "El archivo de configuración 'settings.json' estaba dañado y se ha archivado como '{file}'." & vbCrLf & vbCrLf & "La configuración y las cuentas se han restaurado con éxito desde la última copia de seguridad (.bak) disponible."},
        {"settings_corrupt_reset_title", "Error de Configuración"},
        {"settings_corrupt_reset_msg", "El archivo de configuración 'settings.json' estaba dañado y se ha archivado como '{file}'." & vbCrLf & vbCrLf & "No se pudo recuperar una copia de seguridad válida: la aplicación se ha iniciado con los ajustes predeterminados."},
        {"network_drive_warning_title", "Aviso de Unidad de Red"},
        {"network_drive_warning_msg", "HidaChat se está ejecutando desde una unidad de red ({path})." & vbCrLf & vbCrLf & "Advertencia: Microsoft WebView2 no admite el almacenamiento de perfiles de navegación en unidades de red o recursos compartidos SMB. Esto provoca con frecuencia que WhatsApp Web pierda la sesión o se desconecte al reiniciar." & vbCrLf & vbCrLf & "Se recomienda encarecidamente ejecutar HidaChat desde un disco local (ej. C:\HidaChat)."},
        {"network_drive_staging_info", "HidaChat se está ejecutando desde una unidad de red ({path})." & vbCrLf & vbCrLf & "El almacenamiento local de sesiones está ACTIVO: los datos de sesión se gestionan localmente y se sincronizan en la red al salir para evitar la pérdida de sesión de WebView2."},
        {"network_drive_section", "Unidades de Red"},
        {"enable_network_profile_staging", "Habilitar almacenamiento local para unidades de red"},
        {"enable_network_profile_staging_hint", "Mejora la estabilidad y evita que WhatsApp cierre la sesión al ejecutarse desde recursos de red (SMB/UNC)."},
        {"network_drive_session_conflict", "Advertencia: La cuenta '{name}' parece estar activa en otro equipo ({machine}). El uso simultáneo puede provocar desconexiones."},
        {"secret_decrypt_error_title", "Aviso de Descifrado de Credenciales"},
        {"secret_decrypt_error_msg", "No se pudo descifrar la clave Tailscale AuthKey almacenada: la carpeta de la aplicación se abrió en un equipo o perfil de usuario de Windows diferente (la protección DPAPI está vinculada al equipo/usuario local)." & vbCrLf & vbCrLf & "Para reactivar la integración con Tailscale, vuelva a introducir la AuthKey en Configuración."},
        {"folder_locked_title", "Carpeta de la Aplicación en Uso"},
        {"folder_locked_msg", "La carpeta de HidaChat está actualmente bloqueada y en uso por otra estación o proceso:" & vbCrLf & vbCrLf & "• Equipo: {machine}" & vbCrLf & "• Usuario: {user}" & vbCrLf & "• PID: {pid}" & vbCrLf & "• Iniciado: {time}" & vbCrLf & vbCrLf & "Para prevenir la corrupción de los perfiles WebView2 y las sesiones, no se permite ejecutar simultáneamente múltiples instancias desde la misma carpeta."},
        {"close", "Cerrar"},
        {"tab_hibernation_section", "Hibernación de Pestañas"},
        {"enable_tab_hibernation", "Habilitar hibernación de pestañas inactivas"},
        {"enable_tab_hibernation_hint", "Reduce el uso de memoria RAM suspendiendo las pestañas inactivas en segundo plano. Se reactivan al instante al seleccionarlas."},
        {"tab_hibernation_timeout", "Tiempo de inactividad:"},
        {"cache_section", "Caché y Almacenamiento"},
        {"disk_cache_limit", "Límite de caché en disco de Chromium:"},
        {"disk_cache_limit_hint", "Limita el espacio en disco utilizado por la caché HTTP de Chromium por perfil (se aplica al recargar la pestaña)."},
        {"smart_clean_cache_btn", "Limpiar caché (mantener sesión)"},
        {"smart_clean_cache_hint", "Elimina archivos temporales, caché HTTP, shaders y GPU sin cerrar sesión (cookies, sesiones e IndexedDB permanecen intactos)."},
        {"smart_clean_cache_confirm_title", "Limpieza de Caché"},
        {"smart_clean_cache_confirm_msg", "¿Desea limpiar los archivos temporales y las cachés del navegador para todas las cuentas? Las sesiones y credenciales se conservarán."},
        {"smart_clean_cache_success_title", "Caché Limpiada"},
        {"smart_clean_cache_success_msg", "¡Limpieza de caché completada con éxito! Las sesiones de cuenta se han conservado."},
        {"account_clean_cache", "Limpiar caché de la cuenta"},
        {"hibernated_badge_tooltip", "Pestaña hibernada (se reactiva automáticamente al hacer clic)"},
        {"account_repair_tab", "Reparar pestaña (restablecer base de datos)"},
        {"account_repair_confirm_title", "Reparar Pestaña"},
        {"account_repair_confirm_msg", "Esta operación restablecerá la base de datos local y la caché de los service workers de la pestaña, y luego recargará la página para solucionar pantallas blancas. ¿Continuar?"},
        {"account_repair_success_title", "Reparación Completada"},
        {"account_repair_success_msg", "El almacenamiento de la pestaña se ha reparado y la página se ha recargado."},
        {"shutdown_dialog_title", "Cerrando HidaChat"},
        {"shutdown_dialog_header", "Guardando datos y cerrando..."},
        {"shutdown_stage_settings", "Guardando ajustes y preferencias de cuentas..."},
        {"shutdown_stage_webviews", "Cierre controlado de los procesos de navegación..."},
        {"shutdown_stage_network_sync", "Sincronizando perfiles y chats en la red..."},
        {"shutdown_stage_tsnet", "Deteniendo proxy de red y liberando bloqueos..."},
        {"shutdown_stage_complete", "Finalizando y cerrando..."},
        {"tailscale_dialog_title", "Estado de la conexión Tailscale"},
        {"tailscale_dialog_header", "No se puede cargar {platform}: {name}"},
        {"tailscale_error_tsnet_needs_login", "El nodo Tailscale integrado requiere autenticación. Inicie sesión para conectarse a su Tailnet y acceder al servicio."},
        {"tailscale_error_tsnet_stopped", "El servicio Tailscale integrado (tsnet) no se está ejecutando o no pudo iniciarse."},
        {"tailscale_error_node_unreachable", "La conexión Tailscale está activa, pero el host remoto '{host}' no es accesible o está apagado. Compruebe que el dispositivo remoto esté encendido y conectado a su Tailnet."},
        {"tailscale_error_client_disconnected", "El cliente Tailscale no está activo o desconectado en este equipo. Inicie y conecte Tailscale, y luego vuelva a intentarlo."},
        {"tailscale_error_generic_failure", "No se puede acceder al servidor '{host}'. Se produjo un error de red o de tiempo de espera."},
        {"tailscale_btn_retry", "Reintentar"},
        {"tailscale_btn_login", "Iniciar sesión en Tailscale"},
        {"tailscale_btn_settings", "Abrir Ajustes"},
        {"tailscale_btn_close", "Cerrar"},
        {"storage_recovery_dialog_title", "Recuperación de integridad de almacenamiento"},
        {"storage_recovery_dialog_header", "Reparando almacenamiento local y base de datos..."},
        {"storage_recovery_stage_checking", "Comprobando la integridad de IndexedDB y almacenamiento para {account}..."},
        {"storage_recovery_stage_detected", "Corrupción de almacenamiento detectada para {account}. Reconstruyendo base de datos..."},
        {"storage_recovery_stage_repairing", "Limpiando cachés corruptas de IndexedDB/ServiceWorker (sesiones preservadas)..."},
        {"storage_recovery_stage_reloading", "Recargando vista web e inicializando base de datos limpia..."},
        {"storage_recovery_stage_completed", "¡Recuperación de almacenamiento completada con éxito!"},
        {"translation_privacy_title", "Aviso de Privacidad y Traducción"},
        {"translation_privacy_header", "Autorizar Traducción de Mensajes"},
        {"translation_privacy_body", "Para traducir los mensajes del chat que aún no están en la caché local, su texto se enviará al proveedor configurado ({provider})." & vbLf & vbLf & "Los proveedores en la nube (como Google Translate) transmiten el contenido a servidores remotos. También puedes configurar un proveedor local o autoalojado (LibreTranslate, Ollama, LM Studio) en Ajustes para mantener los datos en tu equipo." & vbLf & vbLf & "¿Deseas autorizar la traducción de mensajes?"},
        {"translation_privacy_allow", "Permitir y Activar"},
        {"translation_privacy_settings", "Configurar Proveedor..."},
        {"translation_consent_declined", "Traducción cancelada: se requiere consentimiento"},
        {"translation_provider", "Proveedor de Traducción"},
        {"translation_privacy_consent_checkbox", "Doy mi consentimiento para enviar el texto de los mensajes al proveedor seleccionado"},
        {"translation_url", "URL del Endpoint:"},
        {"translation_model", "Nombre del Modelo:"},
        {"translation_api_key", "Clave API (opcional):"},
        {"translation_test_btn", "Probar Conexión"},
        {"translation_test_success", "✓ Conectado con éxito ({latency} ms)"},
        {"translation_test_failure", "✗ Error de conexión: {error}"},
        {"translation_provider_unreachable", "Traducción fallida: Proveedor no disponible"}
    }


    ''' <summary>Dizionario di localizzazione nativa per l'interfaccia in lingua Tedesca.</summary>
    Public Shared ReadOnly DeStrings As New Dictionary(Of String, String)(StringComparer.OrdinalIgnoreCase) From {
        {"settings", "Einstellungen"},
        {"theme", "Design"},
        {"system", "System"},
        {"light", "Hell"},
        {"dark", "Dunkel"},
        {"match_cohesive", "Passen Sie diese Einstellung in Ihren Chat-Apps für ein einheitliches Erscheinungsbild an."},
        {"manage_accounts", "Konten verwalten"},
        {"add_account", "Konto hinzufügen"},
        {"add_whatsapp_account", "WhatsApp-Konto hinzufügen"},
        {"add_telegram_account", "Telegram-Konto hinzufügen"},
        {"add_openclaw_account", "OpenClaw-Konto hinzufügen"},
        {"add_hermes_account", "Hermes Agent-Konto hinzufügen"},
        {"openclaw_server_url", "Gateway- / Tailscale-URL:"},
        {"openclaw_auth_token", "Gateway-Authentifizierungstoken:"},
        {"test_connection", "Verbindung testen"},
        {"connection_testing", "Prüfung läuft..."},
        {"connection_success", "✓ Online"},
        {"connection_failed", "✗ Nicht erreichbar"},
        {"select_platform", "Plattform auswählen"},
        {"always_show_tab_bar", "Registerkartenleiste immer anzeigen"},
        {"updates", "Aktualisierungen"},
        {"check_updates_launch", "Beim Start nach Aktualisierungen suchen"},
        {"check_now", "Jetzt prüfen"},
        {"devtools", "Entwicklertools"},
        {"debug_active_tab", "Aktiven Tab debuggen"},
        {"delete_account_title", "Konto löschen"},
        {"delete_account_confirm", """{name}"" löschen? Alle Daten dieses Kontos werden entfernt."},
        {"delete_account_last", "Sie können das einzige aktive Konto nicht löschen."},
        {"cancel", "Abbrechen"},
        {"delete", "Löschen"},
        {"rename", "Umbenennen"},
        {"language", "Sprache"},
        {"translate_to_lang", "Auf {lang} übersetzen"},
        {"translate_all_messages", "Alle Nachrichten übersetzen"},
        {"toggle_window", "Fenster ein-/ausblenden"},
        {"exit", "Beenden"},
        {"translate_message_button", "Schaltfläche zur Nachrichtenübersetzung"},
        {"keep_app_in_english", "App-Oberfläche auf Englisch behalten"},
        {"full_page_translation", "Ganze Seite übersetzen"},
        {"show_translate_all_messages_button", "Schaltfläche 'Alle Nachrichten übersetzen' in Titelleiste"},
        {"reload_active_tab", "Aktiven Tab neu laden"},
        {"use_beta_channel", "Beta-Update-Kanal verwenden"},
        {"notifications", "Benachrichtigungen"},
        {"show_message_popup", "Nachrichten-Popup anzeigen"},
        {"accounts_count_info", "Konfigurierte Konten: {count} von {max}"},
        {"max_accounts_reached", "Maximallimit von {max} Konten erreicht."},
        {"max_accounts_downgrade_notice", "Downgrade-Hinweis: Sie haben {count} aktive Konten und überschreiten das Limit von {max}. Vorhandene Konten bleiben erhalten und funktionsfähig, das Hinzufügen neuer Konten ist jedoch gesperrt, bis das Limit unterschritten wird."},
        {"accounts_downgrade_blocked", "Konto kann nicht hinzugefügt werden: Sie haben {count} konfigurierte Konten bei einem Limit von {max}. Entfernen Sie Konten oder erhöhen Sie das Limit, um weitere hinzuzufügen."},
        {"max_accounts", "Maximale Konten:"},
        {"about", "Über"},
        {"about_title", "Über HidaChat"},
        {"app_description", "Portabler, schlanker Multi-Account-Desktop-Client für Windows (WhatsApp, Telegram, OpenClaw, Hermes)."},
        {"author", "Autor"},
        {"release_date", "Veröffentlichungsdatum"},
        {"license", "Lizenz"},
        {"runtime_environment", "Umgebung und Framework"},
        {"portable_directory", "Portabler Datenpfad"},
        {"github_repository", "GitHub-Repository"},
        {"report_issue", "Problem melden"},
        {"view_releases", "Releases anzeigen"},
        {"bulk_sender", "Massenversand via Excel / CSV"},
        {"custom_css", "Benutzerdefiniertes CSS"},
        {"enable_custom_css", "Benutzerdefinierte CSS-Regeln aktivieren"},
        {"custom_css_placeholder", "/* Schreiben oder fügen Sie hier Ihr benutzerdefiniertes CSS für WhatsApp und Telegram Web ein */"},
        {"apply_css", "CSS anwenden"},
        {"css_applied", "CSS erfolgreich angewendet!"},
        {"css_preset_oled", "OLED Tiefschwarz"},
        {"css_preset_compact", "Kompaktes Layout"},
        {"css_preset_font", "Moderne Schriftart"},
        {"css_preset_reset", "Leeren"},
        {"contact_online", "Online"},
        {"contact_typing", "schreibt..."},
        {"spellchecker", "Rechtschreibprüfung"},
        {"enable_spellchecker", "Rechtschreibprüfung in Texteingabefeldern aktivieren"},
        {"spellchecker_language", "Wörterbuchsprache"},
        {"spellchecker_lang_auto", "Automatisch (App-Sprache folgen)"},
        {"spellchecker_restart_hint", "Änderungen werden beim Neuladen der Registerkarten oder beim Neustart von HidaChat wirksam."},
        {"dnd_mode", "Nicht stören (Fokusmodus)"},
        {"dnd_enable", "Alle Benachrichtigungen und Töne stummschalten"},
        {"dnd_duration", "Dauer"},
        {"dnd_30m", "Für 30 Minuten"},
        {"dnd_1h", "Für 1 Stunde"},
        {"dnd_2h", "Für 2 Stunden"},
        {"dnd_8h", "Für 8 Stunden"},
        {"dnd_indefinite", "Bis zur Deaktivierung"},
        {"dnd_active_until", "Nicht stören aktiv bis {time}"},
        {"dnd_active_indefinite", "Nicht stören aktiv (unbegrenzt)"},
        {"update_insufficient_permissions", "Automatisches Update nicht möglich." & vbCrLf & "Die Anwendung hat keine Schreibrechte im Installationsordner." & vbCrLf & vbCrLf & "Bitte verschieben Sie die Anwendung in einen beschreibbaren Ordner (z. B. Dokumente, Desktop oder USB-Stick)." & vbCrLf & "Vermeiden Sie geschützte Systemordner wie Programme." & vbCrLf & vbCrLf & "Verfügbare Version: v{version}"},
        {"update_insufficient_permissions_title", "Unzureichende Berechtigungen"},
        {"update_missing_checksum", "Integrität des Updates kann nicht überprüft werden." & vbCrLf & vbCrLf & "Für diese Version auf GitHub wurde keine gültige kryptografische SHA-256-Prüfsumme bereitgestellt." & vbCrLf & vbCrLf & "Das Update wurde aus Sicherheitsgründen abgebrochen."},
        {"update_integrity_failed_title", "Update-Integritätsfehler"},
        {"update_checksum_mismatch", "Überprüfung der Integrität fehlgeschlagen!" & vbCrLf & vbCrLf & "Die kryptografische SHA-256-Prüfsumme der heruntergeladenen Update-Datei stimmt nicht mit dem erwarteten Wert überein:" & vbCrLf & vbCrLf & "Berechnet: {computed}" & vbCrLf & "Erwartet:   {expected}" & vbCrLf & vbCrLf & "Das Update wurde abgebrochen, um die Systemsicherheit zu gewährleisten."},
        {"update_download_error", "Update-Download fehlgeschlagen oder Zeitüberschreitung:" & vbCrLf & vbCrLf & "{error}"},
        {"update_download_error_title", "Fehler beim Herunterladen des Updates"},
        {"update_signature_invalid", "Überprüfung der digitalen Signatur der Update-Ausführungsdatei fehlgeschlagen." & vbCrLf & vbCrLf & "Die Installation wurde aus Sicherheitsgründen abgebrochen."},
        {"update_already_latest", "Sie haben bereits die neueste Version (v{version})!"},
        {"update_already_latest_title", "Auf dem neuesten Stand"},
        {"update_no_new_version", "Die Remote-Version (v{remote}) ist älter oder gleich der aktuellen Version (v{current})."},
        {"update_no_new_version_title", "Aktualisierung"},
        {"update_available_prompt", "Eine neue Version von HidaChat (v{version}) ist verfügbar!" & vbCrLf & vbCrLf & "Möchten Sie das Update jetzt herunterladen und installieren?"},
        {"update_available_title", "Update verfügbar"},
        {"update_install_error", "Beim Installieren des Updates ist ein Fehler aufgetreten:" & vbCrLf & vbCrLf & "{error}"},
        {"update_install_error_title", "Update-Fehler"},
        {"update_check_failed", "Fehler beim Prüfen auf Updates:" & vbCrLf & vbCrLf & "{error}"},
        {"update_check_failed_network", "Updates konnten nicht geprüft werden. Bitte überprüfen Sie Ihre Internetverbindung oder versuchen Sie es später erneut."},
        {"update_check_failed_title", "Update-Prüfung"},
        {"update_no_asset", "Dem Remote-Release ist kein Update-Paket beigefügt."},
        {"settings_corrupt_recovery_title", "Wiederherstellung der Einstellungen"},
        {"settings_corrupt_recovered_msg", "Die Konfigurationsdatei 'settings.json' war beschädigt und wurde als '{file}' archiviert." & vbCrLf & vbCrLf & "Einstellungen und Konten wurden erfolgreich aus der letzten verfügbaren Sicherung (.bak) wiederhergestellt."},
        {"settings_corrupt_reset_title", "Konfigurationsfehler"},
        {"settings_corrupt_reset_msg", "Die Konfigurationsdatei 'settings.json' war beschädigt und wurde als '{file}' archiviert." & vbCrLf & vbCrLf & "Eine gültige Sicherung konnte nicht wiederhergestellt werden: Die Anwendung wurde mit Standardeinstellungen gestartet."},
        {"network_drive_warning_title", "Netzlaufwerk-Warnung"},
        {"network_drive_warning_msg", "HidaChat wird von einem Netzlaufwerk ausgeführt ({path})." & vbCrLf & vbCrLf & "Warnung: Microsoft WebView2 unterstützt das Speichern von Browserprofilen auf Netzlaufwerken oder SMB-Freigaben nicht. Dies führt häufig dazu, dass WhatsApp Web beim Neustart die Sitzung verliert oder getrennt wird." & vbCrLf & vbCrLf & "Es wird dringend empfohlen, HidaChat von einem lokalen Laufwerk auszuführen (z. B. C:\HidaChat)."},
        {"network_drive_staging_info", "HidaChat wird von einem Netzlaufwerk ausgeführt ({path})." & vbCrLf & vbCrLf & "Lokales Sitzungs-Staging ist AKTIV: Sitzungsdaten werden lokal verarbeitet und beim Beenden mit der Netzwerkfreigabe synchronisiert, um WebView2-Sitzungsverluste zu verhindern."},
        {"network_drive_section", "Netzlaufwerke"},
        {"enable_network_profile_staging", "Lokales Staging für Netzlaufwerke aktivieren"},
        {"enable_network_profile_staging_hint", "Verbessert die Sitzungsstabilität und verhindert das Abmelden von WhatsApp bei Ausführung über Netzwerkfreigaben (SMB/UNC)."},
        {"network_drive_session_conflict", "Warnung: Konto '{name}' scheint auf einem anderen Computer ({machine}) aktiv zu sein. Die gleichzeitige Nutzung kann zu Abmeldungen führen."},
        {"secret_decrypt_error_title", "Warnung zur Entschlüsselung der Anmeldedaten"},
        {"secret_decrypt_error_msg", "Der gespeicherte Tailscale AuthKey konnte nicht entschlüsselt werden: Der Anwendungsordner wurde auf einem anderen Computer oder Windows-Benutzerprofil geöffnet (der DPAPI-Schutz ist an das lokale System/Benutzer gebunden)." & vbCrLf & vbCrLf & "Um die Tailscale-Integration erneut zu aktivieren, geben Sie den AuthKey bitte in den Einstellungen erneut ein."},
        {"folder_locked_title", "Anwendungsordner wird Bereits Verwendet"},
        {"folder_locked_msg", "Der HidaChat-Ordner ist derzeit gesperrt und wird von einem anderen Computer oder Prozess verwendet:" & vbCrLf & vbCrLf & "• Computer: {machine}" & vbCrLf & "• Benutzer: {user}" & vbCrLf & "• PID: {pid}" & vbCrLf & "• Gestartet am: {time}" & vbCrLf & vbCrLf & "Um eine Beschädigung der WebView2-Profile und Sitzungen zu verhindern, können nicht mehrere Instanzen gleichzeitig aus demselben Ordner ausgeführt werden."},
        {"close", "Schließen"},
        {"tab_hibernation_section", "Tab-Ruhezustand"},
        {"enable_tab_hibernation", "Ruhezustand für inaktive Tabs aktivieren"},
        {"enable_tab_hibernation_hint", "Reduziert den RAM-Verbrauch, indem inaktive Hintergrund-Tabs angehalten werden. Sie werden bei Auswahl sofort fortgesetzt."},
        {"tab_hibernation_timeout", "Inaktivitätszeit:"},
        {"cache_section", "Cache & Speicher"},
        {"disk_cache_limit", "Chromium-Festplatten-Cache-Limit:"},
        {"disk_cache_limit_hint", "Begrenzt den Festplattenspeicher des Chromium-HTTP-Cache pro Profil (wird beim Neuladen angewendet)."},
        {"smart_clean_cache_btn", "Cache leeren (Login behalten)"},
        {"smart_clean_cache_hint", "Löscht temporäre Dateien, HTTP-Cache, Shader und GPU-Cache, ohne Konten abzumelden (Cookies, Sitzungen und IndexedDB bleiben intakt)."},
        {"smart_clean_cache_confirm_title", "Cache-Bereinigung"},
        {"smart_clean_cache_confirm_msg", "Möchten Sie temporäre Dateien und Browser-Caches für alle Konten bereinigen? Anmeldesitzungen und Anmeldedaten bleiben erhalten."},
        {"smart_clean_cache_success_title", "Cache Bereinigt"},
        {"smart_clean_cache_success_msg", "Cache-Bereinigung erfolgreich abgeschlossen! Kontositzungen wurden beibehalten."},
        {"account_clean_cache", "Kontocache leeren"},
        {"hibernated_badge_tooltip", "Tab im Ruhezustand (wird beim Klicken automatisch fortgesetzt)"},
        {"account_repair_tab", "Tab reparieren (beschädigte Datenbank zurücksetzen)"},
        {"account_repair_confirm_title", "Tab Reparieren"},
        {"account_repair_confirm_msg", "Dadurch werden die lokale Datenbank und der Service-Worker-Cache des Tabs zurückgesetzt und die Seite neu geladen, um weiße Seiten zu beheben. Fortfahren?"},
        {"account_repair_success_title", "Reparatur Abgeschlossen"},
        {"account_repair_success_msg", "Der Tab-Speicher wurde repariert und die Seite wurde neu geladen."},
        {"shutdown_dialog_title", "HidaChat wird beendet"},
        {"shutdown_dialog_header", "Daten werden gespeichert und beendet..."},
        {"shutdown_stage_settings", "Einstellungen und Kontokonfigurationen werden gespeichert..."},
        {"shutdown_stage_webviews", "Browser-Prozesse werden geordnet beendet..."},
        {"shutdown_stage_network_sync", "Profile und Chats werden mit Netzwerkfreigabe synchronisiert..."},
        {"shutdown_stage_tsnet", "Netzwerk-Proxy wird gestoppt und Sperren freigegeben..."},
        {"shutdown_stage_complete", "Abschluss und Beendigung..."},
        {"tailscale_dialog_title", "Tailscale-Verbindungsstatus"},
        {"tailscale_dialog_header", "{platform} kann nicht geladen werden: {name}"},
        {"tailscale_error_tsnet_needs_login", "Der integrierte Tailscale-Knoten erfordert eine Authentifizierung. Bitte melden Sie sich bei Ihrem Tailnet an, um auf den Dienst zuzugreifen."},
        {"tailscale_error_tsnet_stopped", "Der integrierte Tailscale-Dienst (tsnet) wird nicht ausgeführt oder konnte nicht gestartet werden."},
        {"tailscale_error_node_unreachable", "Die Tailscale-Verbindung ist aktiv, aber der Remote-Host '{host}' ist nicht erreichbar oder ausgeschaltet. Bitte überprüfen Sie, ob das Remote-Gerät eingeschaltet und mit Ihrem Tailnet verbunden ist."},
        {"tailscale_error_client_disconnected", "Der Tailscale-Client ist auf diesem Computer nicht aktiv oder getrennt. Bitte starten und verbinden Sie Tailscale und versuchen Sie es erneut."},
        {"tailscale_error_generic_failure", "Der Server '{host}' konnte nicht erreicht werden. Ein Netzwerk- oder Verbindungs-Timeout ist aufgetreten."},
        {"tailscale_btn_retry", "Wiederholen"},
        {"tailscale_btn_login", "Bei Tailscale anmelden"},
        {"tailscale_btn_settings", "Einstellungen öffnen"},
        {"tailscale_btn_close", "Schließen"},
        {"storage_recovery_dialog_title", "Wiederherstellung der Speicherintegrität"},
        {"storage_recovery_dialog_header", "Lokaler Speicher und Datenbank werden repariert..."},
        {"storage_recovery_stage_checking", "Überprüfung der IndexedDB- und Speicherintegrität für {account}..."},
        {"storage_recovery_stage_detected", "Speicherbeschädigung für {account} erkannt. Datenbank wird neu aufgebaut..."},
        {"storage_recovery_stage_repairing", "Bereinigung beschädigter IndexedDB/ServiceWorker-Caches (Sitzungen beibehalten)..."},
        {"storage_recovery_stage_reloading", "Webansicht wird neu geladen und saubere Datenbank initialisiert..."},
        {"storage_recovery_stage_completed", "Speicherwiederherstellung erfolgreich abgeschlossen!"},
        {"translation_privacy_title", "Datenschutz- und Übersetzungshinweis"},
        {"translation_privacy_header", "Nachrichtenübersetzung autorisieren"},
        {"translation_privacy_body", "Um noch nicht lokal zwischengespeicherte Chatnachrichten zu übersetzen, wird der Text an den konfigurierten Übersetzungsdienst ({provider}) übertragen." & vbLf & vbLf & "Cloud-Dienste (wie Google Translate) übertragen Nachrichteninhalte an Remoteserver. Sie können in den Einstellungen auch einen lokalen oder selbstgehosteten Dienst (LibreTranslate, Ollama, LM Studio) einrichten, um Daten vollständig auf Ihrem PC zu behalten." & vbLf & vbLf & "Möchten Sie die Übersetzung autorisieren?"},
        {"translation_privacy_allow", "Zulassen und Aktivieren"},
        {"translation_privacy_settings", "Anbieter konfigurieren..."},
        {"translation_consent_declined", "Übersetzung abgebrochen: Einwilligung erforderlich"},
        {"translation_provider", "Übersetzungsanbieter"},
        {"translation_privacy_consent_checkbox", "Ich stimme der Übermittlung von Nachrichtentexten an den Übersetzungsanbieter zu"},
        {"translation_url", "Endpunkt-URL:"},
        {"translation_model", "Modellname:"},
        {"translation_api_key", "API-Schlüssel (optional):"},
        {"translation_test_btn", "Verbindung testen"},
        {"translation_test_success", "✓ Verbindung erfolgreich ({latency} ms)"},
        {"translation_test_failure", "✗ Verbindungsfehler: {error}"},
        {"translation_provider_unreachable", "Übersetzung fehlgeschlagen: Anbieter nicht erreichbar"}
    }


    ''' <summary>
    ''' Restituisce la stringa localizzata per la chiave fornita, applicando eventuali argomenti di formattazione.
    ''' </summary>
    Public Function [Get](key As String, Optional args As Dictionary(Of String, String) = Nothing) As String
        Dim value As String = Nothing
        If Not _translations.TryGetValue(key, value) Then
            If Not EnStrings.TryGetValue(key, value) Then
                value = key
            End If
        End If

        If args IsNot Nothing Then
            For Each kvp In args
                value = value.Replace("{" & kvp.Key & "}", kvp.Value)
            Next
        End If
        Return value
    End Function

    ''' <summary>
    ''' Traduce una singola stringa di testo nella lingua di destinazione specificata con cache persistente su file.
    ''' </summary>
    Public Shared Async Function TranslateSingle(text As String, targetLang As String) As Task(Of String)
        Return Await TranslationCacheService.Instance.TranslateSingleAsync(text, targetLang)
    End Function

    ''' <summary>
    ''' Traduce un singolo testo restituendo il risultato dettagliato con eventuale messaggio d'errore (TODO #69).
    ''' </summary>
    Public Shared Async Function TranslateSingleDetailed(text As String, targetLang As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of TranslationResult)
        Return Await TranslationCacheService.Instance.TranslateSingleDetailedAsync(text, targetLang, cancellationToken)
    End Function

    ''' <summary>
    ''' Traduce una lista di testi in batch con cache persistente su file (inviando solo le stringhe non ancora in cache).
    ''' </summary>
    Public Shared Async Function TranslateBatch(texts As List(Of String), targetLang As String) As Task(Of List(Of String))
        Return Await TranslationCacheService.Instance.TranslateBatchAsync(texts, targetLang)
    End Function

    ''' <summary>
    ''' Traduce una lista di testi in batch restituendo il risultato strutturato dettagliato (TODO #69).
    ''' </summary>
    Public Shared Async Function TranslateBatchDetailed(texts As List(Of String), targetLang As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of TranslationBatchResult)
        Return Await TranslationCacheService.Instance.TranslateBatchDetailedAsync(texts, targetLang, cancellationToken)
    End Function
End Class

''' <summary>
''' Rappresenta le informazioni di una lingua supportata nell'interfaccia (Nome visualizzato e Codice ISO).
''' </summary>
Public Class LanguageInfo
    Public Property Name As String
    Public Property Code As String
End Class