use crate::config::Language;

pub struct Messages {
    language: Language,
}

impl Messages {
    pub fn new(language: Language) -> Self {
        Self { language }
    }

    pub fn initializing(&self) -> &str {
        match self.language {
            Language::English => "Initializing QuiCommit...",
            Language::Chinese => "正在初始化 QuiCommit...",
            Language::Japanese => "QuiCommitを初期化中...",
            Language::Korean => "QuiCommit 초기화 중...",
            Language::Spanish => "Inicializando QuiCommit...",
            Language::French => "Initialisation de QuiCommit...",
            Language::German => "QuiCommit wird initialisiert...",
        }
    }

    pub fn init_success(&self) -> &str {
        match self.language {
            Language::English => "QuiCommit initialized successfully!",
            Language::Chinese => "QuiCommit 初始化成功！",
            Language::Japanese => "QuiCommitの初期化が完了しました！",
            Language::Korean => "QuiCommit 초기화 성공!",
            Language::Spanish => "¡QuiCommit inicializado exitosamente!",
            Language::French => "QuiCommit initialisé avec succès !",
            Language::German => "QuiCommit erfolgreich initialisiert!",
        }
    }

    pub fn next_steps(&self) -> &str {
        match self.language {
            Language::English => "Next steps:",
            Language::Chinese => "下一步：",
            Language::Japanese => "次のステップ：",
            Language::Korean => "다음 단계:",
            Language::Spanish => "Próximos pasos:",
            Language::French => "Prochaines étapes :",
            Language::German => "Nächste Schritte:",
        }
    }

    pub fn config_file(&self) -> &str {
        match self.language {
            Language::English => "Config file:",
            Language::Chinese => "配置文件：",
            Language::Japanese => "設定ファイル：",
            Language::Korean => "구성 파일:",
            Language::Spanish => "Archivo de configuración:",
            Language::French => "Fichier de configuration :",
            Language::German => "Konfigurationsdatei:",
        }
    }

    pub fn setup_profile(&self) -> &str {
        match self.language {
            Language::English => "Let's set up your first profile:",
            Language::Chinese => "让我们设置你的第一个配置文件：",
            Language::Japanese => "最初のプロファイルを設定しましょう：",
            Language::Korean => "첫 번째 프로필을 설정해 보겠습니다:",
            Language::Spanish => "Configuremos tu primer perfil:",
            Language::French => "Configurons votre premier profil :",
            Language::German => "Lassen Sie uns Ihr erstes Profil einrichten:",
        }
    }

    pub fn profile_name(&self) -> &str {
        match self.language {
            Language::English => "Profile name",
            Language::Chinese => "配置文件名称",
            Language::Japanese => "プロファイル名",
            Language::Korean => "프로필 이름",
            Language::Spanish => "Nombre del perfil",
            Language::French => "Nom du profil",
            Language::German => "Profilname",
        }
    }

    pub fn git_user_name(&self) -> &str {
        match self.language {
            Language::English => "Git user name",
            Language::Chinese => "Git 用户名",
            Language::Japanese => "Gitユーザー名",
            Language::Korean => "Git 사용자 이름",
            Language::Spanish => "Nombre de usuario de Git",
            Language::French => "Nom d'utilisateur Git",
            Language::German => "Git-Benutzername",
        }
    }

    pub fn git_user_email(&self) -> &str {
        match self.language {
            Language::English => "Git user email",
            Language::Chinese => "Git 用户邮箱",
            Language::Japanese => "Gitユーザーメール",
            Language::Korean => "Git 사용자 이메일",
            Language::Spanish => "Correo de usuario de Git",
            Language::French => "E-mail utilisateur Git",
            Language::German => "Git-Benutzer-E-Mail",
        }
    }

    pub fn select_llm_provider(&self) -> &str {
        match self.language {
            Language::English => "Select your preferred LLM provider:",
            Language::Chinese => "选择你偏好的 LLM 提供商：",
            Language::Japanese => "好みのLLMプロバイダーを選択：",
            Language::Korean => "선호하는 LLM 공급자를 선택하세요:",
            Language::Spanish => "Selecciona tu proveedor LLM preferido:",
            Language::French => "Sélectionnez votre fournisseur LLM préféré :",
            Language::German => "Wählen Sie Ihren bevorzugten LLM-Anbieter:",
        }
    }

    pub fn commit_preview(&self) -> &str {
        match self.language {
            Language::English => "Commit preview:",
            Language::Chinese => "提交预览：",
            Language::Japanese => "コミットプレビュー：",
            Language::Korean => "커밋 미리보기:",
            Language::Spanish => "Vista previa del commit:",
            Language::French => "Aperçu du commit :",
            Language::German => "Commit-Vorschau:",
        }
    }

    pub fn proceed_commit(&self) -> &str {
        match self.language {
            Language::English => "Do you want to proceed with this commit?",
            Language::Chinese => "是否继续此提交？",
            Language::Japanese => "このコミットを続行しますか？",
            Language::Korean => "이 커밋을 계속하시겠습니까?",
            Language::Spanish => "¿Quieres proceder con este commit?",
            Language::French => "Voulez-vous procéder à ce commit ?",
            Language::German => "Möchten Sie mit diesem Commit fortfahren?",
        }
    }

    pub fn commit_created(&self) -> &str {
        match self.language {
            Language::English => "Created commit",
            Language::Chinese => "已创建提交",
            Language::Japanese => "コミットを作成しました",
            Language::Korean => "커밋 생성됨",
            Language::Spanish => "Commit creado",
            Language::French => "Commit créé",
            Language::German => "Commit erstellt",
        }
    }

    pub fn commit_amended_successfully(&self) -> &str {
        match self.language {
            Language::English => "Amended commit successfully",
            Language::Chinese => "已成功修改提交",
            Language::Japanese => "コミットを正常に修正しました",
            Language::Korean => "커밋을 성공적으로 수정함",
            Language::Spanish => "Commit enmendado exitosamente",
            Language::French => "Commit modifié avec succès",
            Language::German => "Commit erfolgreich geändert",
        }
    }

    pub fn commit_cancelled(&self) -> &str {
        match self.language {
            Language::English => "Commit cancelled.",
            Language::Chinese => "提交已取消。",
            Language::Japanese => "コミットがキャンセルされました。",
            Language::Korean => "커밋이 취소되었습니다.",
            Language::Spanish => "Commit cancelado.",
            Language::French => "Commit annulé.",
            Language::German => "Commit abgebrochen.",
        }
    }

    pub fn tag_preview(&self) -> &str {
        match self.language {
            Language::English => "Tag preview:",
            Language::Chinese => "标签预览：",
            Language::Japanese => "タグプレビュー：",
            Language::Korean => "태그 미리보기:",
            Language::Spanish => "Vista previa de la etiqueta:",
            Language::French => "Aperçu de l'étiquette :",
            Language::German => "Tag-Vorschau:",
        }
    }

    pub fn create_tag(&self) -> &str {
        match self.language {
            Language::English => "Create this tag?",
            Language::Chinese => "创建此标签？",
            Language::Japanese => "このタグを作成しますか？",
            Language::Korean => "이 태그를 생성하시겠습니까?",
            Language::Spanish => "¿Crear esta etiqueta?",
            Language::French => "Créer cette étiquette ?",
            Language::German => "Diesen Tag erstellen?",
        }
    }

    pub fn tag_created(&self) -> &str {
        match self.language {
            Language::English => "Created tag",
            Language::Chinese => "已创建标签",
            Language::Japanese => "タグを作成しました",
            Language::Korean => "태그 생성됨",
            Language::Spanish => "Etiqueta creada",
            Language::French => "Étiquette créée",
            Language::German => "Tag erstellt",
        }
    }

    pub fn tag_cancelled(&self) -> &str {
        match self.language {
            Language::English => "Tag creation cancelled.",
            Language::Chinese => "标签创建已取消。",
            Language::Japanese => "タグ作成がキャンセルされました。",
            Language::Korean => "태그 생성이 취소되었습니다.",
            Language::Spanish => "Creación de etiqueta cancelada.",
            Language::French => "Création d'étiquette annulée.",
            Language::German => "Tag-Erstellung abgebrochen.",
        }
    }

    pub fn warning(&self) -> &str {
        match self.language {
            Language::English => "Warning",
            Language::Chinese => "警告",
            Language::Japanese => "警告",
            Language::Korean => "경고",
            Language::Spanish => "Advertencia",
            Language::French => "Avertissement",
            Language::German => "Warnung",
        }
    }

    pub fn proceed_invalid_tag_name(&self) -> &str {
        match self.language {
            Language::English => "Proceed with this tag name anyway?",
            Language::Chinese => "仍然使用此标签名称？",
            Language::Japanese => "それでもこのタグ名を使用しますか？",
            Language::Korean => "그래도 이 태그 이름을 사용하시겠습니까?",
            Language::Spanish => "¿Continuar con este nombre de etiqueta de todos modos?",
            Language::French => "Continuer avec ce nom d'étiquette quand même ?",
            Language::German => "Diesen Tag-Namen trotzdem verwenden?",
        }
    }

    pub fn changelog_preview(&self) -> &str {
        match self.language {
            Language::English => "Changelog preview:",
            Language::Chinese => "变更日志预览：",
            Language::Japanese => "変更ログプレビュー：",
            Language::Korean => "변경 로그 미리보기:",
            Language::Spanish => "Vista previa del changelog:",
            Language::French => "Aperçu du changelog :",
            Language::German => "Changelog-Vorschau:",
        }
    }

    pub fn changelog_written(&self) -> &str {
        match self.language {
            Language::English => "Changelog written to",
            Language::Chinese => "变更日志已写入",
            Language::Japanese => "変更ログを書き込みました",
            Language::Korean => "변경 로그가 작성됨",
            Language::Spanish => "Changelog escrito en",
            Language::French => "Changelog écrit dans",
            Language::German => "Changelog geschrieben nach",
        }
    }

    pub fn dry_run_commit_not_created(&self) -> &str {
        match self.language {
            Language::English => "Dry run - commit not created.",
            Language::Chinese => "试运行 - 未创建提交。",
            Language::Japanese => "ドライラン - コミットは作成されませんでした。",
            Language::Korean => "드라이 런 - 커밋이 생성되지 않음.",
            Language::Spanish => "Ejecución en seco - commit no creado.",
            Language::French => "Exécution à blanc - commit non créé.",
            Language::German => "Testlauf - Commit nicht erstellt.",
        }
    }

    pub fn dry_run_commit_not_amended(&self) -> &str {
        match self.language {
            Language::English => "Dry run - commit not amended.",
            Language::Chinese => "试运行 - 未修改提交。",
            Language::Japanese => "ドライラン - コミットは修正されませんでした。",
            Language::Korean => "드라이 런 - 커밋이 수정되지 않음.",
            Language::Spanish => "Ejecución en seco - commit no enmendado.",
            Language::French => "Exécution à blanc - commit non modifié.",
            Language::German => "Testlauf - Commit nicht geändert.",
        }
    }

    pub fn dry_run_tag_not_created(&self) -> &str {
        match self.language {
            Language::English => "Dry run - tag not created.",
            Language::Chinese => "试运行 - 未创建标签。",
            Language::Japanese => "ドライラン - タグは作成されませんでした。",
            Language::Korean => "드라이 런 - 태그가 생성되지 않음.",
            Language::Spanish => "Ejecución en seco - etiqueta no creada.",
            Language::French => "Exécution à blanc - étiquette non créée.",
            Language::German => "Testlauf - Tag nicht erstellt.",
        }
    }

    pub fn no_changes(&self) -> &str {
        match self.language {
            Language::English => "No changes to commit. Working tree is clean.",
            Language::Chinese => "没有可提交的更改。工作树是干净的。",
            Language::Japanese => "コミットする変更がありません。作業ツリーはクリーンです。",
            Language::Korean => "커밋할 변경 사항이 없습니다. 작업 트리가 깨끗합니다.",
            Language::Spanish => {
                "No hay cambios para hacer commit. El árbol de trabajo está limpio."
            }
            Language::French => "Aucun changement à commiter. L'arbre de travail est propre.",
            Language::German => "Keine Änderungen zum Committen. Arbeitsbaum ist sauber.",
        }
    }

    pub fn staged_all(&self) -> &str {
        match self.language {
            Language::English => "Staged all changes",
            Language::Chinese => "已暂存所有更改",
            Language::Japanese => "すべての変更をステージしました",
            Language::Korean => "모든 변경 사항을 스테이징함",
            Language::Spanish => "Todos los cambios preparados",
            Language::French => "Tous les changements indexés",
            Language::German => "Alle Änderungen bereitgestellt",
        }
    }

    pub fn auto_stage_changes(&self) -> &str {
        match self.language {
            Language::English => "No files staged. Auto-staging all changes...",
            Language::Chinese => "没有暂存文件。自动暂存所有更改...",
            Language::Japanese => {
                "ステージされたファイルがありません。すべての変更を自動ステージ中..."
            }
            Language::Korean => "스테이징된 파일이 없습니다. 모든 변경 사항을 자동 스테이징 중...",
            Language::Spanish => {
                "No hay archivos preparados. Preparando automáticamente todos los cambios..."
            }
            Language::French => {
                "Aucun fichier indexé. Indexation automatique de tous les changements..."
            }
            Language::German => {
                "Keine Dateien bereitgestellt. Alle Änderungen werden automatisch bereitgestellt..."
            }
        }
    }

    pub fn push_after_commit(&self, branch: &str) -> String {
        match self.language {
            Language::English => format!("Push changes on branch '{}' to remote?", branch),
            Language::Chinese => format!("是否将分支 '{}' 的更改推送到远程仓库？", branch),
            Language::Japanese => {
                format!("ブランチ '{}' の変更をリモートにプッシュしますか？", branch)
            }
            Language::Korean => format!(
                "'{}' 브랜치의 변경 사항을 원격으로 푸시하시겠습니까?",
                branch
            ),
            Language::Spanish => format!("¿Enviar los cambios de la rama '{}' al remoto?", branch),
            Language::French => {
                format!(
                    "Envoyer les modifications de la branche '{}' au distant ?",
                    branch
                )
            }
            Language::German => format!("Änderungen auf Branch '{}' an Remote pushen?", branch),
        }
    }

    pub fn push_after_tag(&self) -> &str {
        match self.language {
            Language::English => "Push tag to remote?",
            Language::Chinese => "推送标签到远程仓库？",
            Language::Japanese => "リモートにタグをプッシュしますか？",
            Language::Korean => "원격으로 태그를 푸시하시겠습니까?",
            Language::Spanish => "¿Enviar etiqueta al remoto?",
            Language::French => "Envoyer l'étiquette au distant ?",
            Language::German => "Tag an Remote pushen?",
        }
    }

    pub fn pushing_commit(&self, remote: &str, branch: &str) -> String {
        match self.language {
            Language::English => format!("Pushing branch '{}' to {}...", branch, remote),
            Language::Chinese => format!("正在推送分支 '{}' 到 {}...", branch, remote),
            Language::Japanese => format!("ブランチ '{}' を{}にプッシュ中...", branch, remote),
            Language::Korean => format!("'{}' 브랜치를 {}로 푸시 중...", branch, remote),
            Language::Spanish => format!("Enviando rama '{}' a {}...", branch, remote),
            Language::French => format!("Envoi de la branche '{}' vers {}...", branch, remote),
            Language::German => format!("Branch '{}' wird an {} gepusht...", branch, remote),
        }
    }

    pub fn pushed_commit(&self, remote: &str, branch: &str) -> String {
        match self.language {
            Language::English => format!("Pushed branch '{}' to {}", branch, remote),
            Language::Chinese => format!("已推送分支 '{}' 到 {}", branch, remote),
            Language::Japanese => format!("ブランチ '{}' を{}にプッシュしました", branch, remote),
            Language::Korean => format!("'{}' 브랜치를 {}로 푸시함", branch, remote),
            Language::Spanish => format!("Rama '{}' enviada a {}", branch, remote),
            Language::French => format!("Branche '{}' envoyée à {}", branch, remote),
            Language::German => format!("Branch '{}' an {} gepusht", branch, remote),
        }
    }

    pub fn ai_analyzing(&self) -> &str {
        match self.language {
            Language::English => "AI is analyzing your changes...",
            Language::Chinese => "AI 正在分析你的更改...",
            Language::Japanese => "AIが変更を分析しています...",
            Language::Korean => "AI가 변경 사항을 분석 중...",
            Language::Spanish => "La IA está analizando tus cambios...",
            Language::French => "L'IA analyse vos modifications...",
            Language::German => "KI analysiert Ihre Änderungen...",
        }
    }

    pub fn ai_generating_tag(&self, count: usize) -> String {
        match self.language {
            Language::English => {
                format!("AI is generating tag message from {} commits...", count)
            }
            Language::Chinese => format!("AI 正在从 {} 个提交生成标签消息...", count),
            Language::Japanese => format!(
                "AIが{}個のコミットからタグメッセージを生成しています...",
                count
            ),
            Language::Korean => format!("AI가 {}개의 커밋에서 태그 메시지를 생성 중...", count),
            Language::Spanish => format!(
                "La IA está generando mensaje de etiqueta desde {} commits...",
                count
            ),
            Language::French => format!(
                "L'IA génère le message d'étiquette à partir de {} commits...",
                count
            ),
            Language::German => format!("KI generiert Tag-Nachricht aus {} Commits...", count),
        }
    }

    pub fn ai_generating_changelog(&self) -> &str {
        match self.language {
            Language::English => "AI is generating changelog...",
            Language::Chinese => "AI 正在生成变更日志...",
            Language::Japanese => "AIが変更ログを生成しています...",
            Language::Korean => "AI가 변경 로그를 생성 중...",
            Language::Spanish => "La IA está generando el changelog...",
            Language::French => "L'IA génère le changelog...",
            Language::German => "KI generiert Changelog...",
        }
    }

    pub fn fetching_commits(&self) -> &str {
        match self.language {
            Language::English => "Fetching commits...",
            Language::Chinese => "正在获取提交...",
            Language::Japanese => "コミットを取得中...",
            Language::Korean => "커밋 가져오는 중...",
            Language::Spanish => "Obteniendo commits...",
            Language::French => "Récupération des commits...",
            Language::German => "Commits werden abgerufen...",
        }
    }

    pub fn found_commits(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("Found {} commits", count),
            Language::Chinese => format!("找到 {} 个提交", count),
            Language::Japanese => format!("{}個のコミットが見つかりました", count),
            Language::Korean => format!("{}개의 커밋을 찾음", count),
            Language::Spanish => format!("Se encontraron {} commits", count),
            Language::French => format!("{} commits trouvés", count),
            Language::German => format!("{} Commits gefunden", count),
        }
    }

    pub fn version_selection(&self) -> &str {
        match self.language {
            Language::English => "Version selection:",
            Language::Chinese => "版本选择：",
            Language::Japanese => "バージョン選択：",
            Language::Korean => "버전 선택:",
            Language::Spanish => "Selección de versión:",
            Language::French => "Sélection de version :",
            Language::German => "Versionsauswahl:",
        }
    }

    pub fn latest_version(&self) -> &str {
        match self.language {
            Language::English => "Latest version:",
            Language::Chinese => "最新版本：",
            Language::Japanese => "最新バージョン：",
            Language::Korean => "최신 버전:",
            Language::Spanish => "Última versión:",
            Language::French => "Dernière version :",
            Language::German => "Neueste Version:",
        }
    }

    pub fn no_existing_version_tags(&self) -> &str {
        match self.language {
            Language::English => "No existing version tags found",
            Language::Chinese => "未找到现有的版本标签",
            Language::Japanese => "既存のバージョンタグが見つかりません",
            Language::Korean => "기존 버전 태그를 찾을 수 없음",
            Language::Spanish => "No se encontraron etiquetas de versión existentes",
            Language::French => "Aucune étiquette de version existante trouvée",
            Language::German => "Keine vorhandenen Versionstags gefunden",
        }
    }

    pub fn suggested_bump(&self) -> &str {
        match self.language {
            Language::English => "Suggested bump:",
            Language::Chinese => "建议的版本升级：",
            Language::Japanese => "提案されたバンプ：",
            Language::Korean => "제안된 버전 증가:",
            Language::Spanish => "Incremento sugerido:",
            Language::French => "Bump suggéré :",
            Language::German => "Vorgeschlagener Bump:",
        }
    }

    pub fn use_this_version(&self) -> &str {
        match self.language {
            Language::English => "Use this version?",
            Language::Chinese => "使用此版本？",
            Language::Japanese => "このバージョンを使用しますか？",
            Language::Korean => "이 버전을 사용하시겠습니까?",
            Language::Spanish => "¿Usar esta versión?",
            Language::French => "Utiliser cette version ?",
            Language::German => "Diese Version verwenden?",
        }
    }

    pub fn pushing_tag(&self, remote: &str) -> String {
        match self.language {
            Language::English => format!("Pushing tag to {}...", remote),
            Language::Chinese => format!("正在推送标签到 {}...", remote),
            Language::Japanese => format!("タグを{}にプッシュ中...", remote),
            Language::Korean => format!("태그를 {}로 푸시 중...", remote),
            Language::Spanish => format!("Enviando etiqueta a {}...", remote),
            Language::French => format!("Envoi de l'étiquette vers {}...", remote),
            Language::German => format!("Tag wird an {} gepusht...", remote),
        }
    }

    pub fn pushed_tag(&self, remote: &str) -> String {
        match self.language {
            Language::English => format!("Pushed tag to {}", remote),
            Language::Chinese => format!("已推送标签到 {}", remote),
            Language::Japanese => format!("タグを{}にプッシュしました", remote),
            Language::Korean => format!("태그를 {}로 푸시함", remote),
            Language::Spanish => format!("Etiqueta enviada a {}", remote),
            Language::French => format!("Étiquette envoyée à {}", remote),
            Language::German => format!("Tag an {} gepusht", remote),
        }
    }

    pub fn cancelled(&self) -> &str {
        match self.language {
            Language::English => "Cancelled.",
            Language::Chinese => "已取消。",
            Language::Japanese => "キャンセルされました。",
            Language::Korean => "취소됨.",
            Language::Spanish => "Cancelado.",
            Language::French => "Annulé.",
            Language::German => "Abgebrochen.",
        }
    }

    pub fn select_commit_type(&self) -> &str {
        match self.language {
            Language::English => "Select commit type",
            Language::Chinese => "选择提交类型",
            Language::Japanese => "コミットタイプを選択",
            Language::Korean => "커밋 유형 선택",
            Language::Spanish => "Seleccionar tipo de commit",
            Language::French => "Sélectionner le type de commit",
            Language::German => "Commit-Typ auswählen",
        }
    }

    pub fn scope_optional(&self) -> &str {
        match self.language {
            Language::English => "Scope (optional, press Enter to skip)",
            Language::Chinese => "范围（可选，按 Enter 跳过）",
            Language::Japanese => "スコープ（オプション、Enterでスキップ）",
            Language::Korean => "범위(선택 사항, Enter로 건너뜀)",
            Language::Spanish => "Ámbito (opcional, presiona Enter para omitir)",
            Language::French => "Portée (optionnel, appuyez sur Entrée pour ignorer)",
            Language::German => "Bereich (optional, Enter zum Überspringen)",
        }
    }

    pub fn description(&self) -> &str {
        match self.language {
            Language::English => "Description",
            Language::Chinese => "描述",
            Language::Japanese => "説明",
            Language::Korean => "설명",
            Language::Spanish => "Descripción",
            Language::French => "Description",
            Language::German => "Beschreibung",
        }
    }

    pub fn breaking_change(&self) -> &str {
        match self.language {
            Language::English => "Is this a breaking change?",
            Language::Chinese => "这是破坏性更改吗？",
            Language::Japanese => "これは破壊的変更ですか？",
            Language::Korean => "이것은 주요 변경 사항입니까?",
            Language::Spanish => "¿Es este un cambio rupturista?",
            Language::French => "Est-ce un changement cassant ?",
            Language::German => "Ist dies ein Breaking Change?",
        }
    }

    pub fn add_body(&self) -> &str {
        match self.language {
            Language::English => "Add body to commit?",
            Language::Chinese => "添加提交正文？",
            Language::Japanese => "コミットに本文を追加しますか？",
            Language::Korean => "커밋에 본문을 추가하시겠습니까?",
            Language::Spanish => "¿Añadir cuerpo al commit?",
            Language::French => "Ajouter un corps au commit ?",
            Language::German => "Body zum Commit hinzufügen?",
        }
    }

    pub fn enter_commit_body(&self) -> &str {
        match self.language {
            Language::English => "Enter commit body...",
            Language::Chinese => "输入提交正文...",
            Language::Japanese => "コミット本文を入力...",
            Language::Korean => "커밋 본문 입력...",
            Language::Spanish => "Introduce el cuerpo del commit...",
            Language::French => "Saisissez le corps du commit...",
            Language::German => "Commit-Body eingeben...",
        }
    }

    pub fn open_editor(&self) -> &str {
        match self.language {
            Language::English => "Open editor for tag message?",
            Language::Chinese => "打开编辑器编辑标签消息？",
            Language::Japanese => "タグメッセージ用にエディタを開きますか？",
            Language::Korean => "태그 메시지를 위해 편집기를 여시겠습니까?",
            Language::Spanish => "¿Abrir editor para mensaje de etiqueta?",
            Language::French => "Ouvrir l'éditeur pour le message d'étiquette ?",
            Language::German => "Editor für Tag-Nachricht öffnen?",
        }
    }

    pub fn tag_message(&self) -> &str {
        match self.language {
            Language::English => "Tag message",
            Language::Chinese => "标签消息",
            Language::Japanese => "タグメッセージ",
            Language::Korean => "태그 메시지",
            Language::Spanish => "Mensaje de etiqueta",
            Language::French => "Message d'étiquette",
            Language::German => "Tag-Nachricht",
        }
    }

    pub fn version(&self) -> &str {
        match self.language {
            Language::English => "Version",
            Language::Chinese => "版本",
            Language::Japanese => "バージョン",
            Language::Korean => "버전",
            Language::Spanish => "Versión",
            Language::French => "Version",
            Language::German => "Version",
        }
    }

    pub fn release_default(&self, version: &str) -> String {
        match self.language {
            Language::English => format!("Release {}", version),
            Language::Chinese => format!("发布 {}", version),
            Language::Japanese => format!("リリース {}", version),
            Language::Korean => format!("릴리스 {}", version),
            Language::Spanish => format!("Lanzamiento {}", version),
            Language::French => format!("Version {}", version),
            Language::German => format!("Release {}", version),
        }
    }

    pub fn unreleased(&self) -> &str {
        match self.language {
            Language::English => "Unreleased",
            Language::Chinese => "未发布",
            Language::Japanese => "未リリース",
            Language::Korean => "릴리스되지 않음",
            Language::Spanish => "Sin lanzar",
            Language::French => "Non publié",
            Language::German => "Unveröffentlicht",
        }
    }

    pub fn no_commits_found(&self) -> &str {
        match self.language {
            Language::English => "No commits found in the specified range",
            Language::Chinese => "在指定范围内未找到提交",
            Language::Japanese => "指定された範囲でコミットが見つかりませんでした",
            Language::Korean => "지정된 범위에서 커밋을 찾을 수 없음",
            Language::Spanish => "No se encontraron commits en el rango especificado",
            Language::French => "Aucun commit trouvé dans la plage spécifiée",
            Language::German => "Keine Commits im angegebenen Bereich gefunden",
        }
    }

    pub fn write_to_file(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Write to {}?", path),
            Language::Chinese => format!("写入 {}？", path),
            Language::Japanese => format!("{} に書き込みますか？", path),
            Language::Korean => format!("{}에 쓰시겠습니까?", path),
            Language::Spanish => format!("¿Escribir en {}?", path),
            Language::French => format!("Écrire dans {} ?", path),
            Language::German => format!("In {} schreiben?", path),
        }
    }

    pub fn initialized_changelog(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Initialized changelog at {}", path),
            Language::Chinese => format!("已在 {} 初始化变更日志", path),
            Language::Japanese => format!("{}で変更ログを初期化しました", path),
            Language::Korean => format!("{}에서 변경 로그 초기화됨", path),
            Language::Spanish => format!("Changelog inicializado en {}", path),
            Language::French => format!("Changelog initialisé à {}", path),
            Language::German => format!("Changelog bei {} initialisiert", path),
        }
    }

    pub fn staged_files(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("Staged files ({}):", count),
            Language::Chinese => format!("已暂存文件（{}）：", count),
            Language::Japanese => format!("ステージされたファイル（{}）：", count),
            Language::Korean => format!("스테이징된 파일({}):", count),
            Language::Spanish => format!("Archivos preparados ({}):", count),
            Language::French => format!("Fichiers indexés ({}):", count),
            Language::German => format!("Bereitgestellte Dateien ({}):", count),
        }
    }

    pub fn generating_commit_message(&self) -> &str {
        match self.language {
            Language::English => "Generating commit message...",
            Language::Chinese => "正在生成提交消息...",
            Language::Japanese => "コミットメッセージを生成中...",
            Language::Korean => "커밋 메시지 생성 중...",
            Language::Spanish => "Generando mensaje de commit...",
            Language::French => "Génération du message de commit...",
            Language::German => "Commit-Nachricht wird generiert...",
        }
    }

    pub fn generated_commit_message(&self) -> &str {
        match self.language {
            Language::English => "Generated commit message:",
            Language::Chinese => "生成的提交消息：",
            Language::Japanese => "生成されたコミットメッセージ：",
            Language::Korean => "생성된 커밋 메시지:",
            Language::Spanish => "Mensaje de commit generado:",
            Language::French => "Message de commit généré :",
            Language::German => "Generierte Commit-Nachricht:",
        }
    }

    pub fn what_would_you_like_to_do(&self) -> &str {
        match self.language {
            Language::English => "What would you like to do?",
            Language::Chinese => "你想做什么？",
            Language::Japanese => "何をしますか？",
            Language::Korean => "무엇을 하시겠습니까?",
            Language::Spanish => "¿Qué te gustaría hacer?",
            Language::French => "Que souhaitez-vous faire ?",
            Language::German => "Was möchten Sie tun?",
        }
    }

    pub fn accept_and_commit(&self) -> &str {
        match self.language {
            Language::English => "Accept and commit",
            Language::Chinese => "接受并提交",
            Language::Japanese => "受け入れてコミット",
            Language::Korean => "수락하고 커밋",
            Language::Spanish => "Aceptar y hacer commit",
            Language::French => "Accepter et commiter",
            Language::German => "Akzeptieren und committen",
        }
    }

    pub fn regenerate(&self) -> &str {
        match self.language {
            Language::English => "Regenerate",
            Language::Chinese => "重新生成",
            Language::Japanese => "再生成",
            Language::Korean => "재생성",
            Language::Spanish => "Regenerar",
            Language::French => "Régénérer",
            Language::German => "Neu generieren",
        }
    }

    pub fn edit(&self) -> &str {
        match self.language {
            Language::English => "Edit",
            Language::Chinese => "编辑",
            Language::Japanese => "編集",
            Language::Korean => "편집",
            Language::Spanish => "Editar",
            Language::French => "Modifier",
            Language::German => "Bearbeiten",
        }
    }

    pub fn copy_to_clipboard(&self) -> &str {
        match self.language {
            Language::English => "Copy to clipboard",
            Language::Chinese => "复制到剪贴板",
            Language::Japanese => "クリップボードにコピー",
            Language::Korean => "클립보드에 복사",
            Language::Spanish => "Copiar al portapapeles",
            Language::French => "Copier dans le presse-papiers",
            Language::German => "In die Zwischenablage kopieren",
        }
    }

    pub fn cancel(&self) -> &str {
        match self.language {
            Language::English => "Cancel",
            Language::Chinese => "取消",
            Language::Japanese => "キャンセル",
            Language::Korean => "취소",
            Language::Spanish => "Cancelar",
            Language::French => "Annuler",
            Language::German => "Abbrechen",
        }
    }

    pub fn regenerating(&self) -> &str {
        match self.language {
            Language::English => "Regenerating...",
            Language::Chinese => "正在重新生成...",
            Language::Japanese => "再生成中...",
            Language::Korean => "재생성 중...",
            Language::Spanish => "Regenerando...",
            Language::French => "Régénération...",
            Language::German => "Neu generieren...",
        }
    }

    pub fn copied_to_clipboard(&self) -> &str {
        match self.language {
            Language::English => "Copied to clipboard!",
            Language::Chinese => "已复制到剪贴板！",
            Language::Japanese => "クリップボードにコピーしました！",
            Language::Korean => "클립보드에 복사됨!",
            Language::Spanish => "¡Copiado al portapapeles!",
            Language::French => "Copié dans le presse-papiers !",
            Language::German => "In die Zwischenablage kopiert!",
        }
    }

    pub fn cancelled_by_user(&self) -> &str {
        match self.language {
            Language::English => "Cancelled by user",
            Language::Chinese => "用户已取消",
            Language::Japanese => "ユーザーによってキャンセルされました",
            Language::Korean => "사용자가 취소함",
            Language::Spanish => "Cancelado por el usuario",
            Language::French => "Annulé par l'utilisateur",
            Language::German => "Vom Benutzer abgebrochen",
        }
    }

    pub fn select_option(&self) -> &str {
        match self.language {
            Language::English => "Select option",
            Language::Chinese => "选择选项",
            Language::Japanese => "オプションを選択",
            Language::Korean => "옵션 선택",
            Language::Spanish => "Seleccionar opción",
            Language::French => "Sélectionner une option",
            Language::German => "Option auswählen",
        }
    }

    pub fn auto_detect_bump(&self) -> &str {
        match self.language {
            Language::English => "Auto-detect bump from commits",
            Language::Chinese => "从提交自动检测版本升级",
            Language::Japanese => "コミットからバンプを自動検出",
            Language::Korean => "커밋에서 버전 증가 자동 감지",
            Language::Spanish => "Detectar incremento automáticamente desde commits",
            Language::French => "Détecter automatiquement le bump depuis les commits",
            Language::German => "Bump automatisch aus Commits erkennen",
        }
    }

    pub fn bump_major_version(&self) -> &str {
        match self.language {
            Language::English => "Bump major version",
            Language::Chinese => "升级主版本",
            Language::Japanese => "メジャーバージョンを上げる",
            Language::Korean => "메이저 버전 증가",
            Language::Spanish => "Incrementar versión mayor",
            Language::French => "Incrémenter version majeure",
            Language::German => "Major-Version erhöhen",
        }
    }

    pub fn bump_minor_version(&self) -> &str {
        match self.language {
            Language::English => "Bump minor version",
            Language::Chinese => "升级次版本",
            Language::Japanese => "マイナーバージョンを上げる",
            Language::Korean => "마이너 버전 증가",
            Language::Spanish => "Incrementar versión menor",
            Language::French => "Incrémenter version mineure",
            Language::German => "Minor-Version erhöhen",
        }
    }

    pub fn bump_patch_version(&self) -> &str {
        match self.language {
            Language::English => "Bump patch version",
            Language::Chinese => "升级补丁版本",
            Language::Japanese => "パッチバージョンを上げる",
            Language::Korean => "패치 버전 증가",
            Language::Spanish => "Incrementar versión de parche",
            Language::French => "Incrémenter version de correctif",
            Language::German => "Patch-Version erhöhen",
        }
    }

    pub fn enter_custom_version(&self) -> &str {
        match self.language {
            Language::English => "Enter custom version",
            Language::Chinese => "输入自定义版本",
            Language::Japanese => "カスタムバージョンを入力",
            Language::Korean => "사용자 지정 버전 입력",
            Language::Spanish => "Ingresar versión personalizada",
            Language::French => "Saisir une version personnalisée",
            Language::German => "Benutzerdefinierte Version eingeben",
        }
    }

    pub fn enter_custom_tag_name(&self) -> &str {
        match self.language {
            Language::English => "Enter custom tag name",
            Language::Chinese => "输入自定义标签名称",
            Language::Japanese => "カスタムタグ名を入力",
            Language::Korean => "사용자 지정 태그 이름 입력",
            Language::Spanish => "Ingresar nombre de etiqueta personalizado",
            Language::French => "Saisir un nom d'étiquette personnalisé",
            Language::German => "Benutzerdefinierten Tag-Namen eingeben",
        }
    }

    pub fn enter_version(&self) -> &str {
        match self.language {
            Language::English => "Enter version (e.g., 1.2.3)",
            Language::Chinese => "输入版本（例如：1.2.3）",
            Language::Japanese => "バージョンを入力（例：1.2.3）",
            Language::Korean => "버전 입력(예: 1.2.3)",
            Language::Spanish => "Ingresar versión (ej: 1.2.3)",
            Language::French => "Saisir la version (ex: 1.2.3)",
            Language::German => "Version eingeben (z.B. 1.2.3)",
        }
    }

    pub fn enter_tag_name(&self) -> &str {
        match self.language {
            Language::English => "Enter tag name",
            Language::Chinese => "输入标签名称",
            Language::Japanese => "タグ名を入力",
            Language::Korean => "태그 이름 입력",
            Language::Spanish => "Ingresar nombre de etiqueta",
            Language::French => "Saisir le nom de l'étiquette",
            Language::German => "Tag-Namen eingeben",
        }
    }

    pub fn found_version_in(&self) -> &str {
        match self.language {
            Language::English => "Found version in",
            Language::Chinese => "在配置文件中找到版本",
            Language::Japanese => "設定ファイルでバージョンが見つかりました",
            Language::Korean => "구성 파일에서 버전을 찾음",
            Language::Spanish => "Versión encontrada en",
            Language::French => "Version trouvée dans",
            Language::German => "Version gefunden in",
        }
    }

    pub fn found_multiple_versions(&self) -> &str {
        match self.language {
            Language::English => "Found versions in multiple config files:",
            Language::Chinese => "在多个配置文件中找到版本：",
            Language::Japanese => "複数の設定ファイルでバージョンが見つかりました：",
            Language::Korean => "여러 구성 파일에서 버전을 찾음:",
            Language::Spanish => "Versiones encontradas en múltiples archivos:",
            Language::French => "Versions trouvées dans plusieurs fichiers :",
            Language::German => "Versionen in mehreren Dateien gefunden:",
        }
    }

    pub fn select_version_to_use(&self) -> &str {
        match self.language {
            Language::English => "Select version to use",
            Language::Chinese => "选择要使用的版本",
            Language::Japanese => "使用するバージョンを選択",
            Language::Korean => "사용할 버전 선택",
            Language::Spanish => "Seleccionar versión a usar",
            Language::French => "Sélectionner la version à utiliser",
            Language::German => "Zu verwendende Version auswählen",
        }
    }

    pub fn profile_description(&self) -> &str {
        match self.language {
            Language::English => "Profile description (optional)",
            Language::Chinese => "配置文件描述（可选）",
            Language::Japanese => "プロファイルの説明（オプション）",
            Language::Korean => "프로필 설명(선택 사항)",
            Language::Spanish => "Descripción del perfil (opcional)",
            Language::French => "Description du profil (optionnel)",
            Language::German => "Profilbeschreibung (optional)",
        }
    }

    pub fn is_work_profile(&self) -> &str {
        match self.language {
            Language::English => "Is this a work profile?",
            Language::Chinese => "这是工作配置文件吗？",
            Language::Japanese => "これはワークプロファイルですか？",
            Language::Korean => "이것은 작업 프로필입니까?",
            Language::Spanish => "¿Es este un perfil de trabajo?",
            Language::French => "Est-ce un profil de travail ?",
            Language::German => "Ist dies ein Arbeitsprofil?",
        }
    }

    pub fn organization_name(&self) -> &str {
        match self.language {
            Language::English => "Organization/Company name",
            Language::Chinese => "组织/公司名称",
            Language::Japanese => "組織/会社名",
            Language::Korean => "조직/회사 이름",
            Language::Spanish => "Nombre de organización/empresa",
            Language::French => "Nom de l'organisation/entreprise",
            Language::German => "Organisations-/Unternehmensname",
        }
    }

    pub fn configure_ssh(&self) -> &str {
        match self.language {
            Language::English => "Configure SSH key?",
            Language::Chinese => "配置 SSH 密钥？",
            Language::Japanese => "SSHキーを設定しますか？",
            Language::Korean => "SSH 키를 구성하시겠습니까?",
            Language::Spanish => "¿Configurar clave SSH?",
            Language::French => "Configurer la clé SSH ?",
            Language::German => "SSH-Schlüssel konfigurieren?",
        }
    }

    pub fn configure_gpg(&self) -> &str {
        match self.language {
            Language::English => "Configure GPG signing?",
            Language::Chinese => "配置 GPG 签名？",
            Language::Japanese => "GPG署名を設定しますか？",
            Language::Korean => "GPG 서명을 구성하시겠습니까?",
            Language::Spanish => "¿Configurar firma GPG?",
            Language::French => "Configurer la signature GPG ?",
            Language::German => "GPG-Signatur konfigurieren?",
        }
    }

    pub fn ssh_private_key_path(&self) -> &str {
        match self.language {
            Language::English => "SSH private key path",
            Language::Chinese => "SSH 私钥路径",
            Language::Japanese => "SSH秘密鍵パス",
            Language::Korean => "SSH 개인 키 경로",
            Language::Spanish => "Ruta de clave privada SSH",
            Language::French => "Chemin de la clé privée SSH",
            Language::German => "Pfad zum privaten SSH-Schlüssel",
        }
    }

    pub fn has_passphrase(&self) -> &str {
        match self.language {
            Language::English => "Does this key have a passphrase?",
            Language::Chinese => "此密钥有密码吗？",
            Language::Japanese => "この鍵にパスフレーズがありますか？",
            Language::Korean => "이 키에 암호가 있습니까?",
            Language::Spanish => "¿Esta clave tiene frase de paso?",
            Language::French => "Cette clé a-t-elle une phrase de passe ?",
            Language::German => "Hat dieser Schlüssel eine Passphrase?",
        }
    }

    pub fn ssh_key_passphrase(&self) -> &str {
        match self.language {
            Language::English => "SSH key passphrase",
            Language::Chinese => "SSH 密钥密码",
            Language::Japanese => "SSHキーパスフレーズ",
            Language::Korean => "SSH 키 암호",
            Language::Spanish => "Frase de paso de clave SSH",
            Language::French => "Phrase de passe de clé SSH",
            Language::German => "SSH-Schlüssel-Passphrase",
        }
    }

    pub fn gpg_key_id(&self) -> &str {
        match self.language {
            Language::English => "GPG key ID",
            Language::Chinese => "GPG 密钥 ID",
            Language::Japanese => "GPGキーID",
            Language::Korean => "GPG 키 ID",
            Language::Spanish => "ID de clave GPG",
            Language::French => "ID de clé GPG",
            Language::German => "GPG-Schlüssel-ID",
        }
    }

    pub fn use_gpg_agent(&self) -> &str {
        match self.language {
            Language::English => "Use GPG agent?",
            Language::Chinese => "使用 GPG 代理？",
            Language::Japanese => "GPGエージェントを使用しますか？",
            Language::Korean => "GPG 에이전트를 사용하시겠습니까?",
            Language::Spanish => "¿Usar agente GPG?",
            Language::French => "Utiliser l'agent GPG ?",
            Language::German => "GPG-Agent verwenden?",
        }
    }

    pub fn openai_api_key(&self) -> &str {
        match self.language {
            Language::English => "OpenAI API key",
            Language::Chinese => "OpenAI API 密钥",
            Language::Japanese => "OpenAI APIキー",
            Language::Korean => "OpenAI API 키",
            Language::Spanish => "Clave API de OpenAI",
            Language::French => "Clé API OpenAI",
            Language::German => "OpenAI-API-Schlüssel",
        }
    }

    pub fn anthropic_api_key(&self) -> &str {
        match self.language {
            Language::English => "Anthropic API key",
            Language::Chinese => "Anthropic API 密钥",
            Language::Japanese => "Anthropic APIキー",
            Language::Korean => "Anthropic API 키",
            Language::Spanish => "Clave API de Anthropic",
            Language::French => "Clé API Anthropic",
            Language::German => "Anthropic-API-Schlüssel",
        }
    }

    pub fn kimi_api_key(&self) -> &str {
        match self.language {
            Language::English => "Kimi API key",
            Language::Chinese => "Kimi API 密钥",
            Language::Japanese => "Kimi APIキー",
            Language::Korean => "Kimi API 키",
            Language::Spanish => "Clave API de Kimi",
            Language::French => "Clé API Kimi",
            Language::German => "Kimi-API-Schlüssel",
        }
    }

    pub fn deepseek_api_key(&self) -> &str {
        match self.language {
            Language::English => "DeepSeek API key",
            Language::Chinese => "DeepSeek API 密钥",
            Language::Japanese => "DeepSeek APIキー",
            Language::Korean => "DeepSeek API 키",
            Language::Spanish => "Clave API de DeepSeek",
            Language::French => "Clé API DeepSeek",
            Language::German => "DeepSeek-API-Schlüssel",
        }
    }

    pub fn openrouter_api_key(&self) -> &str {
        match self.language {
            Language::English => "OpenRouter API key",
            Language::Chinese => "OpenRouter API 密钥",
            Language::Japanese => "OpenRouter APIキー",
            Language::Korean => "OpenRouter API 키",
            Language::Spanish => "Clave API de OpenRouter",
            Language::French => "Clé API OpenRouter",
            Language::German => "OpenRouter-API-Schlüssel",
        }
    }

    pub fn model(&self) -> &str {
        match self.language {
            Language::English => "Model",
            Language::Chinese => "模型",
            Language::Japanese => "モデル",
            Language::Korean => "모델",
            Language::Spanish => "Modelo",
            Language::French => "Modèle",
            Language::German => "Modell",
        }
    }

    pub fn base_url(&self) -> &str {
        match self.language {
            Language::English => "Base URL (optional)",
            Language::Chinese => "基础 URL（可选）",
            Language::Japanese => "ベースURL（オプション）",
            Language::Korean => "기본 URL(선택 사항)",
            Language::Spanish => "URL base (opcional)",
            Language::French => "URL de base (optionnel)",
            Language::German => "Basis-URL (optional)",
        }
    }

    pub fn configuration_updated(&self) -> &str {
        match self.language {
            Language::English => "Configuration updated",
            Language::Chinese => "配置已更新",
            Language::Japanese => "設定を更新しました",
            Language::Korean => "구성이 업데이트됨",
            Language::Spanish => "Configuración actualizada",
            Language::French => "Configuration mise à jour",
            Language::German => "Konfiguration aktualisiert",
        }
    }

    pub fn set_value(&self, key: &str, value: &str) -> String {
        match self.language {
            Language::English => format!("Set {} = {}", key, value),
            Language::Chinese => format!("设置 {} = {}", key, value),
            Language::Japanese => format!("{} = {} を設定", key, value),
            Language::Korean => format!("{} = {} 설정됨", key, value),
            Language::Spanish => format!("Establecer {} = {}", key, value),
            Language::French => format!("Définir {} = {}", key, value),
            Language::German => format!("{} = {} festlegen", key, value),
        }
    }

    pub fn select_output_language(&self) -> &str {
        match self.language {
            Language::English => "Select output language:",
            Language::Chinese => "选择输出语言：",
            Language::Japanese => "出力言語を選択：",
            Language::Korean => "출력 언어 선택:",
            Language::Spanish => "Seleccionar idioma de salida:",
            Language::French => "Sélectionner la langue de sortie :",
            Language::German => "Ausgabesprache auswählen:",
        }
    }

    // ---- init command (issue 18) ----

    pub fn config_exists_overwrite(&self) -> &str {
        match self.language {
            Language::English => "Configuration already exists. Overwrite?",
            Language::Chinese => "配置文件已存在。是否覆盖？",
            Language::Japanese => "設定ファイルは既に存在します。上書きしますか？",
            Language::Korean => "구성 파일이 이미 존재합니다. 덮어쓰시겠습니까?",
            Language::Spanish => "La configuración ya existe. ¿Sobrescribir?",
            Language::French => "La configuration existe déjà. Écraser ?",
            Language::German => "Konfiguration existiert bereits. Überschreiben?",
        }
    }

    pub fn init_cancelled(&self) -> &str {
        match self.language {
            Language::English => "Initialization cancelled.",
            Language::Chinese => "初始化已取消。",
            Language::Japanese => "初期化がキャンセルされました。",
            Language::Korean => "초기화가 취소되었습니다.",
            Language::Spanish => "Inicialización cancelada.",
            Language::French => "Initialisation annulée.",
            Language::German => "Initialisierung abgebrochen.",
        }
    }

    pub fn config_exists_use_reset(&self) -> &str {
        match self.language {
            Language::English => "Configuration already exists. Use --reset to overwrite.",
            Language::Chinese => "配置文件已存在。使用 --reset 覆盖。",
            Language::Japanese => {
                "設定ファイルは既に存在します。上書きするには --reset を使用してください。"
            }
            Language::Korean => "구성 파일이 이미 존재합니다. --reset을 사용하여 덮어쓰세요.",
            Language::Spanish => "La configuración ya existe. Use --reset para sobrescribir.",
            Language::French => "La configuration existe déjà. Utilisez --reset pour écraser.",
            Language::German => {
                "Konfiguration existiert bereits. Zum Überschreiben --reset verwenden."
            }
        }
    }

    pub fn next_steps_create_profile(&self) -> &str {
        match self.language {
            Language::English => "Create a profile",
            Language::Chinese => "创建配置文件",
            Language::Japanese => "プロファイルを作成",
            Language::Korean => "프로필 만들기",
            Language::Spanish => "Crear un perfil",
            Language::French => "Créer un profil",
            Language::German => "Profil erstellen",
        }
    }

    pub fn next_steps_configure_llm(&self) -> &str {
        match self.language {
            Language::English => "Configure LLM",
            Language::Chinese => "配置 LLM",
            Language::Japanese => "LLMを設定",
            Language::Korean => "LLM 구성",
            Language::Spanish => "Configurar LLM",
            Language::French => "Configurer le LLM",
            Language::German => "LLM konfigurieren",
        }
    }

    pub fn next_steps_start_committing(&self) -> &str {
        match self.language {
            Language::English => "Start committing",
            Language::Chinese => "开始提交",
            Language::Japanese => "コミットを開始",
            Language::Korean => "커밋 시작",
            Language::Spanish => "Empezar a hacer commit",
            Language::French => "Commencer à commiter",
            Language::German => "Mit Committen beginnen",
        }
    }

    pub fn quick_setup_summary(&self) -> &str {
        match self.language {
            Language::English => "Quick setup summary:",
            Language::Chinese => "快速设置摘要：",
            Language::Japanese => "クイックセットアップ概要：",
            Language::Korean => "빠른 설정 요약:",
            Language::Spanish => "Resumen de configuración rápida:",
            Language::French => "Résumé de la configuration rapide :",
            Language::German => "Schnelleinrichtungs-Zusammenfassung:",
        }
    }

    pub fn profile_label(&self) -> &str {
        match self.language {
            Language::English => "Profile",
            Language::Chinese => "配置文件",
            Language::Japanese => "プロファイル",
            Language::Korean => "프로필",
            Language::Spanish => "Perfil",
            Language::French => "Profil",
            Language::German => "Profil",
        }
    }

    pub fn identity_label(&self) -> &str {
        match self.language {
            Language::English => "Identity",
            Language::Chinese => "身份",
            Language::Japanese => "識別情報",
            Language::Korean => "신원",
            Language::Spanish => "Identidad",
            Language::French => "Identité",
            Language::German => "Identität",
        }
    }

    pub fn identity_placeholder_warning(&self) -> &str {
        match self.language {
            Language::English => {
                "Identity uses placeholder values because git user.name/user.email are not set. \
                 Update it with: quicommit profile edit default"
            }
            Language::Chinese => {
                "由于未设置 git user.name/user.email，身份使用了占位值。\
                 请使用 quicommit profile edit default 更新。"
            }
            Language::Japanese => {
                "git user.name/user.email が設定されていないため、識別情報はプレースホルダー値です。\
                 quicommit profile edit default で更新してください。"
            }
            Language::Korean => {
                "git user.name/user.email이 설정되지 않아 신원이 자리 표시자 값입니다. \
                 quicommit profile edit default로 업데이트하세요."
            }
            Language::Spanish => {
                "La identidad usa valores de marcador porque git user.name/user.email no están \
                 configurados. Actualícela con: quicommit profile edit default"
            }
            Language::French => {
                "L'identité utilise des valeurs par défaut car git user.name/user.email ne sont \
                 pas définis. Mettez-la à jour avec : quicommit profile edit default"
            }
            Language::German => {
                "Identität verwendet Platzhalterwerte, da git user.name/user.email nicht gesetzt \
                 sind. Mit quicommit profile edit default aktualisieren."
            }
        }
    }

    pub fn llm_provider_label(&self) -> &str {
        match self.language {
            Language::English => "LLM provider",
            Language::Chinese => "LLM 提供商",
            Language::Japanese => "LLMプロバイダー",
            Language::Korean => "LLM 공급자",
            Language::Spanish => "Proveedor LLM",
            Language::French => "Fournisseur LLM",
            Language::German => "LLM-Anbieter",
        }
    }

    pub fn keyring_unavailable(&self) -> &str {
        match self.language {
            Language::English => "Keyring is not available on this system.",
            Language::Chinese => "此系统上的密钥环不可用。",
            Language::Japanese => "このシステムではキーリングが利用できません。",
            Language::Korean => "이 시스템에서 키링을 사용할 수 없습니다.",
            Language::Spanish => "El keyring no está disponible en este sistema.",
            Language::French => "Le trousseau de clés n'est pas disponible sur ce système.",
            Language::German => "Der Schlüsselbund ist auf diesem System nicht verfügbar.",
        }
    }

    pub fn api_key_found_env(&self) -> &str {
        match self.language {
            Language::English => "Found API key in environment variable.",
            Language::Chinese => "在环境变量中找到了 API 密钥。",
            Language::Japanese => "環境変数でAPIキーが見つかりました。",
            Language::Korean => "환경 변수에서 API 키를 찾았습니다.",
            Language::Spanish => "Se encontró la clave API en la variable de entorno.",
            Language::French => "Clé API trouvée dans la variable d'environnement.",
            Language::German => "API-Schlüssel in Umgebungsvariable gefunden.",
        }
    }

    pub fn api_key_prompt_other(&self) -> &str {
        match self.language {
            Language::English => "API Key",
            Language::Chinese => "API 密钥",
            Language::Japanese => "APIキー",
            Language::Korean => "API 키",
            Language::Spanish => "Clave API",
            Language::French => "Clé API",
            Language::German => "API-Schlüssel",
        }
    }

    pub fn please_set_api_key_env(&self) -> &str {
        match self.language {
            Language::English => "Please set the QUICOMMIT_API_KEY environment variable.",
            Language::Chinese => "请设置 QUICOMMIT_API_KEY 环境变量。",
            Language::Japanese => "QUICOMMIT_API_KEY 環境変数を設定してください。",
            Language::Korean => "QUICOMMIT_API_KEY 환경 변수를 설정하세요.",
            Language::Spanish => "Configure la variable de entorno QUICOMMIT_API_KEY.",
            Language::French => "Veuillez définir la variable d'environnement QUICOMMIT_API_KEY.",
            Language::German => "Bitte die Umgebungsvariable QUICOMMIT_API_KEY setzen.",
        }
    }

    pub fn api_key_stored_keyring(&self) -> &str {
        match self.language {
            Language::English => "API key stored securely in system keyring.",
            Language::Chinese => "API 密钥已安全存储在系统密钥环中。",
            Language::Japanese => "APIキーはシステムキーリングに安全に保存されました。",
            Language::Korean => "API 키가 시스템 키링에 안전하게 저장되었습니다.",
            Language::Spanish => "Clave API almacenada de forma segura en el keyring del sistema.",
            Language::French => "Clé API stockée en toute sécurité dans le trousseau système.",
            Language::German => "API-Schlüssel sicher im System-Schlüsselbund gespeichert.",
        }
    }

    pub fn model_name(&self) -> &str {
        match self.language {
            Language::English => "Model name",
            Language::Chinese => "模型名称",
            Language::Japanese => "モデル名",
            Language::Korean => "모델 이름",
            Language::Spanish => "Nombre del modelo",
            Language::French => "Nom du modèle",
            Language::German => "Modellname",
        }
    }

    pub fn ollama_server_url(&self) -> &str {
        match self.language {
            Language::English => "Ollama server URL",
            Language::Chinese => "Ollama 服务器 URL",
            Language::Japanese => "OllamaサーバーURL",
            Language::Korean => "Ollama 서버 URL",
            Language::Spanish => "URL del servidor Ollama",
            Language::French => "URL du serveur Ollama",
            Language::German => "Ollama-Server-URL",
        }
    }

    pub fn use_custom_base_url(&self) -> &str {
        match self.language {
            Language::English => "Use custom API base URL?",
            Language::Chinese => "使用自定义 API 基础 URL？",
            Language::Japanese => "カスタムAPIベースURLを使用しますか？",
            Language::Korean => "사용자 지정 API 기본 URL을 사용하시겠습니까?",
            Language::Spanish => "¿Usar una URL base de API personalizada?",
            Language::French => "Utiliser une URL de base d'API personnalisée ?",
            Language::German => "Benutzerdefinierte API-Basis-URL verwenden?",
        }
    }

    pub fn base_url_plain(&self) -> &str {
        match self.language {
            Language::English => "Base URL",
            Language::Chinese => "基础 URL",
            Language::Japanese => "ベースURL",
            Language::Korean => "기본 URL",
            Language::Spanish => "URL base",
            Language::French => "URL de base",
            Language::German => "Basis-URL",
        }
    }

    pub fn ssh_public_key_path(&self) -> &str {
        match self.language {
            Language::English => "SSH public key path (optional, leave empty to auto-detect)",
            Language::Chinese => "SSH 公钥路径（可选，留空自动检测）",
            Language::Japanese => "SSH公開鍵パス（オプション、空のままにすると自動検出）",
            Language::Korean => "SSH 공개 키 경로(선택 사항, 비워 두면 자동 감지)",
            Language::Spanish => {
                "Ruta de clave pública SSH (opcional, dejar vacío para auto-detectar)"
            }
            Language::French => {
                "Chemin de la clé publique SSH (optionnel, laisser vide pour détection automatique)"
            }
            Language::German => {
                "Pfad zum öffentlichen SSH-Schlüssel (optional, leer lassen für Auto-Erkennung)"
            }
        }
    }

    pub fn ssh_agent_forwarding(&self) -> &str {
        match self.language {
            Language::English => "Enable SSH agent forwarding (-A)?",
            Language::Chinese => "启用 SSH 代理转发（-A）？",
            Language::Japanese => "SSHエージェント転送（-A）を有効にしますか？",
            Language::Korean => "SSH 에이전트 포워딩(-A)을 활성화하시겠습니까?",
            Language::Spanish => "¿Habilitar reenvío del agente SSH (-A)?",
            Language::French => "Activer le transfert d'agent SSH (-A) ?",
            Language::German => "SSH-Agent-Forwarding aktivieren (-A)?",
        }
    }

    pub fn known_hosts_path(&self) -> &str {
        match self.language {
            Language::English => "Custom known_hosts file path (optional)",
            Language::Chinese => "自定义 known_hosts 文件路径（可选）",
            Language::Japanese => "カスタムknown_hostsファイルパス（オプション）",
            Language::Korean => "사용자 지정 known_hosts 파일 경로(선택 사항)",
            Language::Spanish => "Ruta personalizada del archivo known_hosts (opcional)",
            Language::French => "Chemin personnalisé du fichier known_hosts (optionnel)",
            Language::German => "Benutzerdefinierter known_hosts-Dateipfad (optional)",
        }
    }

    pub fn custom_ssh_command(&self) -> &str {
        match self.language {
            Language::English => "Custom SSH command (optional, overrides all other SSH settings)",
            Language::Chinese => "自定义 SSH 命令（可选，覆盖所有其他 SSH 设置）",
            Language::Japanese => "カスタムSSHコマンド（オプション、他のすべてのSSH設定を上書き）",
            Language::Korean => "사용자 지정 SSH 명령(선택 사항, 다른 모든 SSH 설정 재정의)",
            Language::Spanish => {
                "Comando SSH personalizado (opcional, anula el resto de ajustes SSH)"
            }
            Language::French => {
                "Commande SSH personnalisée (optionnel, remplace tous les autres réglages SSH)"
            }
            Language::German => {
                "Benutzerdefinierter SSH-Befehl (optional, überschreibt alle anderen SSH-Einstellungen)"
            }
        }
    }

    // ---- scattered errors (issue 19) ----

    pub fn failed_to_stage(&self) -> &str {
        match self.language {
            Language::English => {
                "Failed to stage changes. Please try running 'git add -A' manually."
            }
            Language::Chinese => "暂存更改失败。请尝试手动运行 'git add -A'。",
            Language::Japanese => {
                "変更のステージに失敗しました。手動で 'git add -A' を実行してみてください。"
            }
            Language::Korean => "변경 사항 스테이징 실패. 'git add -A'를 수동으로 실행해 보세요.",
            Language::Spanish => {
                "No se pudieron preparar los cambios. Intente ejecutar 'git add -A' manualmente."
            }
            Language::French => {
                "Échec de l'indexation des modifications. Essayez 'git add -A' manuellement."
            }
            Language::German => {
                "Änderungen konnten nicht bereitgestellt werden. Führen Sie 'git add -A' manuell aus."
            }
        }
    }

    pub fn unknown_changelog_format(&self, format: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "Unknown format: {}. Use: keep-a-changelog, github-releases",
                    format
                )
            }
            Language::Chinese => {
                format!(
                    "未知格式：{}。可用：keep-a-changelog、github-releases",
                    format
                )
            }
            Language::Japanese => format!(
                "不明なフォーマット: {}。使用可能: keep-a-changelog、github-releases",
                format
            ),
            Language::Korean => format!(
                "알 수 없는 형식: {}. 사용 가능: keep-a-changelog, github-releases",
                format
            ),
            Language::Spanish => format!(
                "Formato desconocido: {}. Use: keep-a-changelog, github-releases",
                format
            ),
            Language::French => format!(
                "Format inconnu : {}. Utilisez : keep-a-changelog, github-releases",
                format
            ),
            Language::German => format!(
                "Unbekanntes Format: {}. Verwenden Sie: keep-a-changelog, github-releases",
                format
            ),
        }
    }

    pub fn thinking_unsupported(&self, provider: &str) -> String {
        match self.language {
            Language::English => format!(
                "Provider '{}' does not support thinking mode. \
                 Disabling thinking for this invocation.",
                provider
            ),
            Language::Chinese => {
                format!("提供商 '{}' 不支持思考模式。本次调用已禁用思考。", provider)
            }
            Language::Japanese => format!(
                "プロバイダー '{}' は思考モードをサポートしていません。\
                 今回の呼び出しでは思考を無効にします。",
                provider
            ),
            Language::Korean => format!(
                "'{}' 공급자는 사고 모드를 지원하지 않습니다. 이 호출에서는 사고 모드를 비활성화합니다.",
                provider
            ),
            Language::Spanish => format!(
                "El proveedor '{}' no admite el modo de pensamiento. \
                 Se deshabilita para esta invocación.",
                provider
            ),
            Language::French => format!(
                "Le fournisseur '{}' ne prend pas en charge le mode de réflexion. \
                 Désactivation pour cette invocation.",
                provider
            ),
            Language::German => format!(
                "Anbieter '{}' unterstützt den Thinking-Modus nicht. \
                 Thinking für diesen Aufruf deaktiviert.",
                provider
            ),
        }
    }

    pub fn failed_clean_ignored(&self) -> &str {
        match self.language {
            Language::English => "Failed to clean ignored files from index",
            Language::Chinese => "从索引中清理已忽略文件失败",
            Language::Japanese => {
                "インデックスから無視されたファイルをクリーンアップできませんでした"
            }
            Language::Korean => "인덱스에서 무시된 파일을 정리하지 못함",
            Language::Spanish => "No se pudieron limpiar los archivos ignorados del índice",
            Language::French => "Échec du nettoyage des fichiers ignorés de l'index",
            Language::German => "Ignorierte Dateien konnten nicht aus dem Index entfernt werden",
        }
    }

    // ---- profile command (issue 16) ----

    pub fn add_new_profile(&self) -> &str {
        match self.language {
            Language::English => "Add new profile",
            Language::Chinese => "添加新配置文件",
            Language::Japanese => "新しいプロファイルを追加",
            Language::Korean => "새 프로필 추가",
            Language::Spanish => "Añadir nuevo perfil",
            Language::French => "Ajouter un nouveau profil",
            Language::German => "Neues Profil hinzufügen",
        }
    }

    pub fn add_pat_confirm(&self) -> &str {
        match self.language {
            Language::English => "Add a Personal Access Token?",
            Language::Chinese => "添加个人访问令牌（PAT）？",
            Language::Japanese => "個人アクセストークンを追加しますか？",
            Language::Korean => "개인 액세스 토큰을 추가하시겠습니까?",
            Language::Spanish => "¿Añadir un token de acceso personal?",
            Language::French => "Ajouter un jeton d'accès personnel ?",
            Language::German => "Persönliches Zugriffstoken hinzufügen?",
        }
    }

    pub fn set_default_confirm(&self) -> &str {
        match self.language {
            Language::English => "Set as default profile?",
            Language::Chinese => "设为默认配置文件？",
            Language::Japanese => "デフォルトプロファイルに設定しますか？",
            Language::Korean => "기본 프로필로 설정하시겠습니까?",
            Language::Spanish => "¿Establecer como perfil predeterminado?",
            Language::French => "Définir comme profil par défaut ?",
            Language::German => "Als Standardprofil festlegen?",
        }
    }

    pub fn profile_added(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' added successfully", name),
            Language::Chinese => format!("配置文件 '{}' 添加成功", name),
            Language::Japanese => format!("プロファイル '{}' を追加しました", name),
            Language::Korean => format!("프로필 '{}' 추가됨", name),
            Language::Spanish => format!("Perfil '{}' añadido exitosamente", name),
            Language::French => format!("Profil '{}' ajouté avec succès", name),
            Language::German => format!("Profil '{}' erfolgreich hinzugefügt", name),
        }
    }

    pub fn set_default_done(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Set '{}' as default profile", name),
            Language::Chinese => format!("已将 '{}' 设为默认配置文件", name),
            Language::Japanese => format!("'{}' をデフォルトプロファイルに設定しました", name),
            Language::Korean => format!("'{}'을(를) 기본 프로필로 설정함", name),
            Language::Spanish => format!("'{}' establecido como perfil predeterminado", name),
            Language::French => format!("'{}' défini comme profil par défaut", name),
            Language::German => format!("'{}' als Standardprofil festgelegt", name),
        }
    }

    pub fn profile_not_found(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' not found", name),
            Language::Chinese => format!("未找到配置文件 '{}'", name),
            Language::Japanese => format!("プロファイル '{}' が見つかりません", name),
            Language::Korean => format!("프로필 '{}'을(를) 찾을 수 없음", name),
            Language::Spanish => format!("Perfil '{}' no encontrado", name),
            Language::French => format!("Profil '{}' introuvable", name),
            Language::German => format!("Profil '{}' nicht gefunden", name),
        }
    }

    pub fn profile_already_exists(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' already exists", name),
            Language::Chinese => format!("配置文件 '{}' 已存在", name),
            Language::Japanese => format!("プロファイル '{}' は既に存在します", name),
            Language::Korean => format!("프로필 '{}'이(가) 이미 존재합니다", name),
            Language::Spanish => format!("El perfil '{}' ya existe", name),
            Language::French => format!("Le profil '{}' existe déjà", name),
            Language::German => format!("Profil '{}' existiert bereits", name),
        }
    }

    pub fn remove_profile_confirm(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Are you sure you want to remove profile '{}'?", name),
            Language::Chinese => format!("确定要删除配置文件 '{}' 吗？", name),
            Language::Japanese => format!("プロファイル '{}' を削除してもよろしいですか？", name),
            Language::Korean => format!("프로필 '{}'을(를) 삭제하시겠습니까?", name),
            Language::Spanish => format!("¿Seguro que quiere eliminar el perfil '{}'?", name),
            Language::French => format!("Voulez-vous vraiment supprimer le profil '{}' ?", name),
            Language::German => format!("Profil '{}' wirklich entfernen?", name),
        }
    }

    pub fn profile_removed(&self, name: &str) -> String {
        match self.language {
            Language::English => {
                format!("Profile '{}' removed (including all stored tokens)", name)
            }
            Language::Chinese => format!("配置文件 '{}' 已删除（包括所有已存储的令牌）", name),
            Language::Japanese => format!(
                "プロファイル '{}' を削除しました（保存済みトークンを含む）",
                name
            ),
            Language::Korean => format!("프로필 '{}' 삭제됨(저장된 모든 토큰 포함)", name),
            Language::Spanish => {
                format!(
                    "Perfil '{}' eliminado (incluidos todos los tokens almacenados)",
                    name
                )
            }
            Language::French => {
                format!(
                    "Profil '{}' supprimé (y compris tous les jetons stockés)",
                    name
                )
            }
            Language::German => {
                format!(
                    "Profil '{}' entfernt (inklusive aller gespeicherten Tokens)",
                    name
                )
            }
        }
    }

    pub fn no_profiles_configured(&self) -> &str {
        match self.language {
            Language::English => "No profiles configured.",
            Language::Chinese => "未配置任何配置文件。",
            Language::Japanese => "プロファイルが設定されていません。",
            Language::Korean => "구성된 프로필이 없습니다.",
            Language::Spanish => "No hay perfiles configurados.",
            Language::French => "Aucun profil configuré.",
            Language::German => "Keine Profile konfiguriert.",
        }
    }

    pub fn run_to_create_one(&self, cmd: &str) -> String {
        match self.language {
            Language::English => format!("Run {} to create one.", cmd),
            Language::Chinese => format!("运行 {} 来创建一个。", cmd),
            Language::Japanese => format!("{} を実行して作成してください。", cmd),
            Language::Korean => format!("{}을(를) 실행하여 만드세요.", cmd),
            Language::Spanish => format!("Ejecute {} para crear uno.", cmd),
            Language::French => format!("Exécutez {} pour en créer un.", cmd),
            Language::German => format!("Führen Sie {} aus, um eines zu erstellen.", cmd),
        }
    }

    pub fn configured_profiles(&self) -> &str {
        match self.language {
            Language::English => "Configured profiles:",
            Language::Chinese => "已配置的配置文件：",
            Language::Japanese => "設定済みプロファイル：",
            Language::Korean => "구성된 프로필:",
            Language::Spanish => "Perfiles configurados:",
            Language::French => "Profils configurés :",
            Language::German => "Konfigurierte Profile:",
        }
    }

    pub fn work_marker(&self) -> &str {
        match self.language {
            Language::English => " [work]",
            Language::Chinese => " [工作]",
            Language::Japanese => " [仕事]",
            Language::Korean => " [업무]",
            Language::Spanish => " [trabajo]",
            Language::French => " [travail]",
            Language::German => " [Arbeit]",
        }
    }

    pub fn ssh_configured(&self) -> &str {
        match self.language {
            Language::English => "SSH configured",
            Language::Chinese => "已配置 SSH",
            Language::Japanese => "SSH設定済み",
            Language::Korean => "SSH 구성됨",
            Language::Spanish => "SSH configurado",
            Language::French => "SSH configuré",
            Language::German => "SSH konfiguriert",
        }
    }

    pub fn gpg_configured(&self) -> &str {
        match self.language {
            Language::English => "GPG configured",
            Language::Chinese => "已配置 GPG",
            Language::Japanese => "GPG設定済み",
            Language::Korean => "GPG 구성됨",
            Language::Spanish => "GPG configurado",
            Language::French => "GPG configuré",
            Language::German => "GPG konfiguriert",
        }
    }

    pub fn signing_key_value(&self, key: &str) -> String {
        match self.language {
            Language::English => format!("Signing key: {}", key),
            Language::Chinese => format!("签名密钥：{}", key),
            Language::Japanese => format!("署名キー: {}", key),
            Language::Korean => format!("서명 키: {}", key),
            Language::Spanish => format!("Clave de firma: {}", key),
            Language::French => format!("Clé de signature : {}", key),
            Language::German => format!("Signaturschlüssel: {}", key),
        }
    }

    pub fn tokens_count(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("{} token(s)", count),
            Language::Chinese => format!("{} 个令牌", count),
            Language::Japanese => format!("{} 個のトークン", count),
            Language::Korean => format!("토큰 {}개", count),
            Language::Spanish => format!("{} token(s)", count),
            Language::French => format!("{} jeton(s)", count),
            Language::German => format!("{} Token(s)", count),
        }
    }

    pub fn last_used_value(&self, value: &str) -> String {
        match self.language {
            Language::English => format!("Last used: {}", value),
            Language::Chinese => format!("最近使用：{}", value),
            Language::Japanese => format!("最終使用: {}", value),
            Language::Korean => format!("마지막 사용: {}", value),
            Language::Spanish => format!("Último uso: {}", value),
            Language::French => format!("Dernière utilisation : {}", value),
            Language::German => format!("Zuletzt verwendet: {}", value),
        }
    }

    pub fn repo_status_header(&self) -> &str {
        match self.language {
            Language::English => "Current Repository Status",
            Language::Chinese => "当前仓库状态",
            Language::Japanese => "現在のリポジトリステータス",
            Language::Korean => "현재 저장소 상태",
            Language::Spanish => "Estado actual del repositorio",
            Language::French => "État actuel du dépôt",
            Language::German => "Aktueller Repository-Status",
        }
    }

    pub fn repository_value(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Repository: {}", path),
            Language::Chinese => format!("仓库：{}", path),
            Language::Japanese => format!("リポジトリ: {}", path),
            Language::Korean => format!("저장소: {}", path),
            Language::Spanish => format!("Repositorio: {}", path),
            Language::French => format!("Dépôt : {}", path),
            Language::German => format!("Repository: {}", path),
        }
    }

    pub fn git_user_config_header(&self) -> &str {
        match self.language {
            Language::English => "Git User Configuration (merged local/global):",
            Language::Chinese => "Git 用户配置（合并本地/全局）：",
            Language::Japanese => "Gitユーザー設定（ローカル/グローバル統合）：",
            Language::Korean => "Git 사용자 구성(로컬/전역 병합):",
            Language::Spanish => "Configuración de usuario de Git (local/global combinada):",
            Language::French => "Configuration utilisateur Git (locale/globale fusionnée) :",
            Language::German => "Git-Benutzerkonfiguration (lokal/global zusammengeführt):",
        }
    }

    pub fn label_user_name(&self) -> &str {
        match self.language {
            Language::English => "User name",
            Language::Chinese => "用户名",
            Language::Japanese => "ユーザー名",
            Language::Korean => "사용자 이름",
            Language::Spanish => "Nombre de usuario",
            Language::French => "Nom d'utilisateur",
            Language::German => "Benutzername",
        }
    }

    pub fn label_user_email(&self) -> &str {
        match self.language {
            Language::English => "User email",
            Language::Chinese => "用户邮箱",
            Language::Japanese => "ユーザーメール",
            Language::Korean => "사용자 이메일",
            Language::Spanish => "Correo de usuario",
            Language::French => "E-mail utilisateur",
            Language::German => "Benutzer-E-Mail",
        }
    }

    pub fn label_signing_key(&self) -> &str {
        match self.language {
            Language::English => "Signing key",
            Language::Chinese => "签名密钥",
            Language::Japanese => "署名キー",
            Language::Korean => "서명 키",
            Language::Spanish => "Clave de firma",
            Language::French => "Clé de signature",
            Language::German => "Signaturschlüssel",
        }
    }

    pub fn label_ssh_command(&self) -> &str {
        match self.language {
            Language::English => "SSH command",
            Language::Chinese => "SSH 命令",
            Language::Japanese => "SSHコマンド",
            Language::Korean => "SSH 명령",
            Language::Spanish => "Comando SSH",
            Language::French => "Commande SSH",
            Language::German => "SSH-Befehl",
        }
    }

    pub fn label_commit_gpgsign(&self) -> &str {
        match self.language {
            Language::English => "Commit GPG sign",
            Language::Chinese => "提交 GPG 签名",
            Language::Japanese => "コミットGPG署名",
            Language::Korean => "커밋 GPG 서명",
            Language::Spanish => "Firma GPG de commit",
            Language::French => "Signature GPG de commit",
            Language::German => "Commit-GPG-Signatur",
        }
    }

    pub fn label_tag_gpgsign(&self) -> &str {
        match self.language {
            Language::English => "Tag GPG sign",
            Language::Chinese => "标签 GPG 签名",
            Language::Japanese => "タグGPG署名",
            Language::Korean => "태그 GPG 서명",
            Language::Spanish => "Firma GPG de etiqueta",
            Language::French => "Signature GPG d'étiquette",
            Language::German => "Tag-GPG-Signatur",
        }
    }

    pub fn source_local(&self) -> &str {
        match self.language {
            Language::English => "local",
            Language::Chinese => "本地",
            Language::Japanese => "ローカル",
            Language::Korean => "로컬",
            Language::Spanish => "local",
            Language::French => "local",
            Language::German => "lokal",
        }
    }

    pub fn source_global(&self) -> &str {
        match self.language {
            Language::English => "global",
            Language::Chinese => "全局",
            Language::Japanese => "グローバル",
            Language::Korean => "전역",
            Language::Spanish => "global",
            Language::French => "global",
            Language::German => "global",
        }
    }

    pub fn source_not_set(&self) -> &str {
        match self.language {
            Language::English => "not set",
            Language::Chinese => "未设置",
            Language::Japanese => "未設定",
            Language::Korean => "설정 안 됨",
            Language::Spanish => "no establecido",
            Language::French => "non défini",
            Language::German => "nicht gesetzt",
        }
    }

    pub fn not_set_value(&self) -> &str {
        match self.language {
            Language::English => "<not set>",
            Language::Chinese => "<未设置>",
            Language::Japanese => "<未設定>",
            Language::Korean => "<설정 안 됨>",
            Language::Spanish => "<no establecido>",
            Language::French => "<non défini>",
            Language::German => "<nicht gesetzt>",
        }
    }

    pub fn profile_status_header(&self) -> &str {
        match self.language {
            Language::English => "QuiCommit Profile Status:",
            Language::Chinese => "QuiCommit 配置文件状态：",
            Language::Japanese => "QuiCommitプロファイルステータス：",
            Language::Korean => "QuiCommit 프로필 상태:",
            Language::Spanish => "Estado del perfil de QuiCommit:",
            Language::French => "État du profil QuiCommit :",
            Language::German => "QuiCommit-Profilstatus:",
        }
    }

    pub fn profile_mapped(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' is mapped to this repository", name),
            Language::Chinese => format!("配置文件 '{}' 已映射到此仓库", name),
            Language::Japanese => format!(
                "プロファイル '{}' はこのリポジトリにマップされています",
                name
            ),
            Language::Korean => format!("프로필 '{}'이(가) 이 저장소에 매핑됨", name),
            Language::Spanish => format!("El perfil '{}' está asignado a este repositorio", name),
            Language::French => format!("Le profil '{}' est associé à ce dépôt", name),
            Language::German => format!("Profil '{}' ist diesem Repository zugeordnet", name),
        }
    }

    pub fn config_matches_saved(&self) -> &str {
        match self.language {
            Language::English => "This repository's git config matches the saved profile.",
            Language::Chinese => "此仓库的 git 配置与保存的配置文件一致。",
            Language::Japanese => "このリポジトリのgit設定は保存済みプロファイルと一致します。",
            Language::Korean => "이 저장소의 git 구성이 저장된 프로필과 일치합니다.",
            Language::Spanish => {
                "La configuración git de este repositorio coincide con el perfil guardado."
            }
            Language::French => "La configuration git de ce dépôt correspond au profil enregistré.",
            Language::German => {
                "Die Git-Konfiguration dieses Repositories entspricht dem gespeicherten Profil."
            }
        }
    }

    pub fn profile_matches(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' matches current config", name),
            Language::Chinese => format!("配置文件 '{}' 与当前配置一致", name),
            Language::Japanese => format!("プロファイル '{}' は現在の設定と一致します", name),
            Language::Korean => format!("프로필 '{}'이(가) 현재 구성과 일치함", name),
            Language::Spanish => {
                format!("El perfil '{}' coincide con la configuración actual", name)
            }
            Language::French => format!(
                "Le profil '{}' correspond à la configuration actuelle",
                name
            ),
            Language::German => format!("Profil '{}' entspricht der aktuellen Konfiguration", name),
        }
    }

    pub fn repo_mapped_different(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("But repository is mapped to different profile: {}", name),
            Language::Chinese => format!("但仓库映射到了不同的配置文件：{}", name),
            Language::Japanese => format!(
                "ただし、リポジトリは別のプロファイルにマップされています: {}",
                name
            ),
            Language::Korean => {
                format!("하지만 저장소가 다른 프로필에 매핑되어 있습니다: {}", name)
            }
            Language::Spanish => {
                format!(
                    "Pero el repositorio está asignado a un perfil diferente: {}",
                    name
                )
            }
            Language::French => {
                format!("Mais le dépôt est associé à un profil différent : {}", name)
            }
            Language::German => {
                format!(
                    "Aber das Repository ist einem anderen Profil zugeordnet: {}",
                    name
                )
            }
        }
    }

    pub fn repo_not_mapped(&self) -> &str {
        match self.language {
            Language::English => "This repository is not mapped to any profile.",
            Language::Chinese => "此仓库未映射到任何配置文件。",
            Language::Japanese => "このリポジトリはどのプロファイルにもマップされていません。",
            Language::Korean => "이 저장소는 어떤 프로필에도 매핑되지 않았습니다.",
            Language::Spanish => "Este repositorio no está asignado a ningún perfil.",
            Language::French => "Ce dépôt n'est associé à aucun profil.",
            Language::German => "Dieses Repository ist keinem Profil zugeordnet.",
        }
    }

    pub fn repo_mapped_profile(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Repository is mapped to profile '{}'", name),
            Language::Chinese => format!("仓库映射到配置文件 '{}'", name),
            Language::Japanese => {
                format!("リポジトリはプロファイル '{}' にマップされています", name)
            }
            Language::Korean => format!("저장소가 프로필 '{}'에 매핑됨", name),
            Language::Spanish => format!("El repositorio está asignado al perfil '{}'", name),
            Language::French => format!("Le dépôt est associé au profil '{}'", name),
            Language::German => format!("Repository ist dem Profil '{}' zugeordnet", name),
        }
    }

    pub fn config_does_not_match(&self) -> &str {
        match self.language {
            Language::English => "But current git config does not match this profile!",
            Language::Chinese => "但当前 git 配置与此配置文件不一致！",
            Language::Japanese => "ただし、現在のgit設定はこのプロファイルと一致しません！",
            Language::Korean => "하지만 현재 git 구성이 이 프로필과 일치하지 않습니다!",
            Language::Spanish => "¡Pero la configuración git actual no coincide con este perfil!",
            Language::French => {
                "Mais la configuration git actuelle ne correspond pas à ce profil !"
            }
            Language::German => {
                "Aber die aktuelle Git-Konfiguration entspricht nicht diesem Profil!"
            }
        }
    }

    pub fn mapped_profile_config(&self) -> &str {
        match self.language {
            Language::English => "Mapped profile config:",
            Language::Chinese => "映射的配置文件配置：",
            Language::Japanese => "マップされたプロファイル設定：",
            Language::Korean => "매핑된 프로필 구성:",
            Language::Spanish => "Configuración del perfil asignado:",
            Language::French => "Configuration du profil associé :",
            Language::German => "Konfiguration des zugeordneten Profils:",
        }
    }

    pub fn no_matching_profile(&self) -> &str {
        match self.language {
            Language::English => "No matching profile found in QuiCommit",
            Language::Chinese => "在 QuiCommit 中未找到匹配的配置文件",
            Language::Japanese => "QuiCommitに一致するプロファイルが見つかりません",
            Language::Korean => "QuiCommit에서 일치하는 프로필을 찾을 수 없음",
            Language::Spanish => "No se encontró un perfil coincidente en QuiCommit",
            Language::French => "Aucun profil correspondant trouvé dans QuiCommit",
            Language::German => "Kein passendes Profil in QuiCommit gefunden",
        }
    }

    pub fn identity_not_saved(&self) -> &str {
        match self.language {
            Language::English => "Current git identity is not saved as a QuiCommit profile.",
            Language::Chinese => "当前 git 身份未保存为 QuiCommit 配置文件。",
            Language::Japanese => {
                "現在のgit識別情報はQuiCommitプロファイルとして保存されていません。"
            }
            Language::Korean => "현재 git 신원이 QuiCommit 프로필로 저장되지 않았습니다.",
            Language::Spanish => {
                "La identidad git actual no está guardada como perfil de QuiCommit."
            }
            Language::French => {
                "L'identité git actuelle n'est pas enregistrée comme profil QuiCommit."
            }
            Language::German => {
                "Die aktuelle Git-Identität ist nicht als QuiCommit-Profil gespeichert."
            }
        }
    }

    pub fn similar_profiles(&self) -> &str {
        match self.language {
            Language::English => "Similar profiles exist:",
            Language::Chinese => "存在相似的配置文件：",
            Language::Japanese => "類似のプロファイルが存在します：",
            Language::Korean => "유사한 프로필이 존재합니다:",
            Language::Spanish => "Existen perfiles similares:",
            Language::French => "Des profils similaires existent :",
            Language::German => "Ähnliche Profile vorhanden:",
        }
    }

    pub fn same_name_email(&self) -> &str {
        match self.language {
            Language::English => "same name & email",
            Language::Chinese => "名称与邮箱相同",
            Language::Japanese => "名前とメールが同じ",
            Language::Korean => "이름과 이메일 동일",
            Language::Spanish => "mismo nombre y correo",
            Language::French => "même nom et e-mail",
            Language::German => "gleicher Name & E-Mail",
        }
    }

    pub fn same_name(&self) -> &str {
        match self.language {
            Language::English => "same name",
            Language::Chinese => "名称相同",
            Language::Japanese => "名前が同じ",
            Language::Korean => "이름 동일",
            Language::Spanish => "mismo nombre",
            Language::French => "même nom",
            Language::German => "gleicher Name",
        }
    }

    pub fn same_email(&self) -> &str {
        match self.language {
            Language::English => "same email",
            Language::Chinese => "邮箱相同",
            Language::Japanese => "メールが同じ",
            Language::Korean => "이메일 동일",
            Language::Spanish => "mismo correo",
            Language::French => "même e-mail",
            Language::German => "gleiche E-Mail",
        }
    }

    pub fn partial_match(&self) -> &str {
        match self.language {
            Language::English => "partial match",
            Language::Chinese => "部分匹配",
            Language::Japanese => "部分一致",
            Language::Korean => "부분 일치",
            Language::Spanish => "coincidencia parcial",
            Language::French => "correspondance partielle",
            Language::German => "teilweise Übereinstimmung",
        }
    }

    pub fn save_identity_suggestion(&self) -> &str {
        match self.language {
            Language::English => "Would you like to save this identity as a new profile?",
            Language::Chinese => "是否将此身份保存为新配置文件？",
            Language::Japanese => "この識別情報を新しいプロファイルとして保存しますか？",
            Language::Korean => "이 신원을 새 프로필로 저장하시겠습니까?",
            Language::Spanish => "¿Desea guardar esta identidad como un nuevo perfil?",
            Language::French => "Voulez-vous enregistrer cette identité comme nouveau profil ?",
            Language::German => "Möchten Sie diese Identität als neues Profil speichern?",
        }
    }

    pub fn save_identity_confirm(&self) -> &str {
        match self.language {
            Language::English => "Save current git identity as new profile?",
            Language::Chinese => "将当前 git 身份保存为新配置文件？",
            Language::Japanese => "現在のgit識別情報を新しいプロファイルとして保存しますか？",
            Language::Korean => "현재 git 신원을 새 프로필로 저장하시겠습니까?",
            Language::Spanish => "¿Guardar la identidad git actual como nuevo perfil?",
            Language::French => "Enregistrer l'identité git actuelle comme nouveau profil ?",
            Language::German => "Aktuelle Git-Identität als neues Profil speichern?",
        }
    }

    pub fn requested_profile(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Requested Profile: {}", name),
            Language::Chinese => format!("请求的配置文件：{}", name),
            Language::Japanese => format!("リクエストされたプロファイル: {}", name),
            Language::Korean => format!("요청된 프로필: {}", name),
            Language::Spanish => format!("Perfil solicitado: {}", name),
            Language::French => format!("Profil demandé : {}", name),
            Language::German => format!("Angefordertes Profil: {}", name),
        }
    }

    pub fn default_profile_header(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Default Profile: {}", name),
            Language::Chinese => format!("默认配置文件：{}", name),
            Language::Japanese => format!("デフォルトプロファイル: {}", name),
            Language::Korean => format!("기본 프로필: {}", name),
            Language::Spanish => format!("Perfil predeterminado: {}", name),
            Language::French => format!("Profil par défaut : {}", name),
            Language::German => format!("Standardprofil: {}", name),
        }
    }

    pub fn not_in_repo(&self) -> &str {
        match self.language {
            Language::English => "Not in a Git Repository",
            Language::Chinese => "不在 Git 仓库中",
            Language::Japanese => "Gitリポジトリ内ではありません",
            Language::Korean => "Git 저장소에 있지 않음",
            Language::Spanish => "No está en un repositorio Git",
            Language::French => "Pas dans un dépôt Git",
            Language::German => "Nicht in einem Git-Repository",
        }
    }

    pub fn run_inside_repo_hint(&self) -> &str {
        match self.language {
            Language::English => {
                "Run this command inside a git repository to see local config status."
            }
            Language::Chinese => "在 git 仓库内运行此命令可查看本地配置状态。",
            Language::Japanese => {
                "ローカル設定の状態を確認するには、gitリポジトリ内でこのコマンドを実行してください。"
            }
            Language::Korean => "로컬 구성 상태를 보려면 git 저장소 내에서 이 명령을 실행하세요.",
            Language::Spanish => {
                "Ejecute este comando dentro de un repositorio git para ver el estado de configuración local."
            }
            Language::French => {
                "Exécutez cette commande dans un dépôt git pour voir l'état de la configuration locale."
            }
            Language::German => {
                "Führen Sie diesen Befehl in einem Git-Repository aus, um den lokalen Konfigurationsstatus zu sehen."
            }
        }
    }

    pub fn profile_header(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile: {}", name),
            Language::Chinese => format!("配置文件：{}", name),
            Language::Japanese => format!("プロファイル: {}", name),
            Language::Korean => format!("프로필: {}", name),
            Language::Spanish => format!("Perfil: {}", name),
            Language::French => format!("Profil : {}", name),
            Language::German => format!("Profil: {}", name),
        }
    }

    pub fn no_default_profile(&self) -> &str {
        match self.language {
            Language::English => "No default profile set.",
            Language::Chinese => "未设置默认配置文件。",
            Language::Japanese => "デフォルトプロファイルが設定されていません。",
            Language::Korean => "기본 프로필이 설정되지 않았습니다.",
            Language::Spanish => "No hay perfil predeterminado.",
            Language::French => "Aucun profil par défaut défini.",
            Language::German => "Kein Standardprofil festgelegt.",
        }
    }

    pub fn label_work_profile(&self) -> &str {
        match self.language {
            Language::English => "Work profile:",
            Language::Chinese => "工作配置文件：",
            Language::Japanese => "ワークプロファイル:",
            Language::Korean => "업무 프로필:",
            Language::Spanish => "Perfil de trabajo:",
            Language::French => "Profil de travail :",
            Language::German => "Arbeitsprofil:",
        }
    }

    pub fn label_organization(&self) -> &str {
        match self.language {
            Language::English => "Organization:",
            Language::Chinese => "组织：",
            Language::Japanese => "組織:",
            Language::Korean => "조직:",
            Language::Spanish => "Organización:",
            Language::French => "Organisation :",
            Language::German => "Organisation:",
        }
    }

    pub fn label_description(&self) -> &str {
        match self.language {
            Language::English => "Description:",
            Language::Chinese => "描述：",
            Language::Japanese => "説明:",
            Language::Korean => "설명:",
            Language::Spanish => "Descripción:",
            Language::French => "Description :",
            Language::German => "Beschreibung:",
        }
    }

    pub fn settings_header(&self) -> &str {
        match self.language {
            Language::English => "Settings:",
            Language::Chinese => "设置：",
            Language::Japanese => "設定：",
            Language::Korean => "설정:",
            Language::Spanish => "Ajustes:",
            Language::French => "Paramètres :",
            Language::German => "Einstellungen:",
        }
    }

    pub fn auto_sign_commits(&self) -> &str {
        match self.language {
            Language::English => "Auto-sign commits:",
            Language::Chinese => "自动签名提交：",
            Language::Japanese => "コミットの自動署名:",
            Language::Korean => "커밋 자동 서명:",
            Language::Spanish => "Firmar commits automáticamente:",
            Language::French => "Signature automatique des commits :",
            Language::German => "Commits automatisch signieren:",
        }
    }

    pub fn auto_sign_tags(&self) -> &str {
        match self.language {
            Language::English => "Auto-sign tags:",
            Language::Chinese => "自动签名标签：",
            Language::Japanese => "タグの自動署名:",
            Language::Korean => "태그 자동 서명:",
            Language::Spanish => "Firmar etiquetas automáticamente:",
            Language::French => "Signature automatique des étiquettes :",
            Language::German => "Tags automatisch signieren:",
        }
    }

    pub fn default_commit_format(&self) -> &str {
        match self.language {
            Language::English => "Default commit format:",
            Language::Chinese => "默认提交格式：",
            Language::Japanese => "デフォルトコミットフォーマット:",
            Language::Korean => "기본 커밋 형식:",
            Language::Spanish => "Formato de commit predeterminado:",
            Language::French => "Format de commit par défaut :",
            Language::German => "Standard-Commit-Format:",
        }
    }

    pub fn repo_patterns(&self) -> &str {
        match self.language {
            Language::English => "Repo patterns:",
            Language::Chinese => "仓库模式：",
            Language::Japanese => "リポジトリパターン:",
            Language::Korean => "저장소 패턴:",
            Language::Spanish => "Patrones de repositorio:",
            Language::French => "Motifs de dépôt :",
            Language::German => "Repository-Muster:",
        }
    }

    pub fn preferred_llm(&self) -> &str {
        match self.language {
            Language::English => "Preferred LLM:",
            Language::Chinese => "首选 LLM：",
            Language::Japanese => "優先LLM:",
            Language::Korean => "선호 LLM:",
            Language::Spanish => "LLM preferido:",
            Language::French => "LLM préféré :",
            Language::German => "Bevorzugtes LLM:",
        }
    }

    pub fn commit_template(&self) -> &str {
        match self.language {
            Language::English => "Commit template:",
            Language::Chinese => "提交模板：",
            Language::Japanese => "コミットテンプレート:",
            Language::Korean => "커밋 템플릿:",
            Language::Spanish => "Plantilla de commit:",
            Language::French => "Modèle de commit :",
            Language::German => "Commit-Vorlage:",
        }
    }

    pub fn ssh_config_header(&self) -> &str {
        match self.language {
            Language::English => "SSH Configuration:",
            Language::Chinese => "SSH 配置：",
            Language::Japanese => "SSH設定：",
            Language::Korean => "SSH 구성:",
            Language::Spanish => "Configuración SSH:",
            Language::French => "Configuration SSH :",
            Language::German => "SSH-Konfiguration:",
        }
    }

    pub fn private_key(&self) -> &str {
        match self.language {
            Language::English => "Private key:",
            Language::Chinese => "私钥：",
            Language::Japanese => "秘密鍵:",
            Language::Korean => "개인 키:",
            Language::Spanish => "Clave privada:",
            Language::French => "Clé privée :",
            Language::German => "Privater Schlüssel:",
        }
    }

    pub fn public_key(&self) -> &str {
        match self.language {
            Language::English => "Public key:",
            Language::Chinese => "公钥：",
            Language::Japanese => "公開鍵:",
            Language::Korean => "공개 키:",
            Language::Spanish => "Clave pública:",
            Language::French => "Clé publique :",
            Language::German => "Öffentlicher Schlüssel:",
        }
    }

    pub fn public_key_autodetected(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Public key: {} (auto-detected)", path),
            Language::Chinese => format!("公钥：{}（自动检测）", path),
            Language::Japanese => format!("公開鍵: {}（自動検出）", path),
            Language::Korean => format!("공개 키: {}(자동 감지)", path),
            Language::Spanish => format!("Clave pública: {} (auto-detectada)", path),
            Language::French => format!("Clé publique : {} (détection automatique)", path),
            Language::German => format!("Öffentlicher Schlüssel: {} (automatisch erkannt)", path),
        }
    }

    pub fn agent_forwarding(&self) -> &str {
        match self.language {
            Language::English => "Agent forwarding:",
            Language::Chinese => "代理转发：",
            Language::Japanese => "エージェント転送:",
            Language::Korean => "에이전트 포워딩:",
            Language::Spanish => "Reenvío de agente:",
            Language::French => "Transfert d'agent :",
            Language::German => "Agent-Forwarding:",
        }
    }

    pub fn custom_command(&self) -> &str {
        match self.language {
            Language::English => "Custom command:",
            Language::Chinese => "自定义命令：",
            Language::Japanese => "カスタムコマンド:",
            Language::Korean => "사용자 지정 명령:",
            Language::Spanish => "Comando personalizado:",
            Language::French => "Commande personnalisée :",
            Language::German => "Benutzerdefinierter Befehl:",
        }
    }

    pub fn known_hosts_file(&self) -> &str {
        match self.language {
            Language::English => "Known hosts file:",
            Language::Chinese => "known_hosts 文件：",
            Language::Japanese => "known_hostsファイル:",
            Language::Korean => "known_hosts 파일:",
            Language::Spanish => "Archivo known_hosts:",
            Language::French => "Fichier known_hosts :",
            Language::German => "known_hosts-Datei:",
        }
    }

    pub fn passphrase_set(&self) -> &str {
        match self.language {
            Language::English => "Passphrase: [set]",
            Language::Chinese => "密码短语：[已设置]",
            Language::Japanese => "パスフレーズ: [設定済み]",
            Language::Korean => "암호: [설정됨]",
            Language::Spanish => "Frase de paso: [establecida]",
            Language::French => "Phrase de passe : [définie]",
            Language::German => "Passphrase: [gesetzt]",
        }
    }

    pub fn gpg_config_header(&self) -> &str {
        match self.language {
            Language::English => "GPG Configuration:",
            Language::Chinese => "GPG 配置：",
            Language::Japanese => "GPG設定：",
            Language::Korean => "GPG 구성:",
            Language::Spanish => "Configuración GPG:",
            Language::French => "Configuration GPG :",
            Language::German => "GPG-Konfiguration:",
        }
    }

    pub fn key_id(&self) -> &str {
        match self.language {
            Language::English => "Key ID:",
            Language::Chinese => "密钥 ID：",
            Language::Japanese => "キーID:",
            Language::Korean => "키 ID:",
            Language::Spanish => "ID de clave:",
            Language::French => "ID de clé :",
            Language::German => "Schlüssel-ID:",
        }
    }

    pub fn program(&self) -> &str {
        match self.language {
            Language::English => "Program:",
            Language::Chinese => "程序：",
            Language::Japanese => "プログラム:",
            Language::Korean => "프로그램:",
            Language::Spanish => "Programa:",
            Language::French => "Programme :",
            Language::German => "Programm:",
        }
    }

    pub fn use_agent(&self) -> &str {
        match self.language {
            Language::English => "Use agent:",
            Language::Chinese => "使用代理：",
            Language::Japanese => "エージェントを使用:",
            Language::Korean => "에이전트 사용:",
            Language::Spanish => "Usar agente:",
            Language::French => "Utiliser l'agent :",
            Language::German => "Agent verwenden:",
        }
    }

    pub fn tokens_header(&self) -> &str {
        match self.language {
            Language::English => "Tokens:",
            Language::Chinese => "令牌：",
            Language::Japanese => "トークン：",
            Language::Korean => "토큰:",
            Language::Spanish => "Tokens:",
            Language::French => "Jetons :",
            Language::German => "Tokens:",
        }
    }

    pub fn usage_stats_header(&self) -> &str {
        match self.language {
            Language::English => "Usage Statistics:",
            Language::Chinese => "使用统计：",
            Language::Japanese => "使用統計：",
            Language::Korean => "사용 통계:",
            Language::Spanish => "Estadísticas de uso:",
            Language::French => "Statistiques d'utilisation :",
            Language::German => "Nutzungsstatistik:",
        }
    }

    pub fn total_uses(&self) -> &str {
        match self.language {
            Language::English => "Total uses:",
            Language::Chinese => "总使用次数：",
            Language::Japanese => "総使用回数:",
            Language::Korean => "총 사용 횟수:",
            Language::Spanish => "Usos totales:",
            Language::French => "Utilisations totales :",
            Language::German => "Gesamtnutzungen:",
        }
    }

    pub fn save_new_profile(&self) -> &str {
        match self.language {
            Language::English => "Save New Profile",
            Language::Chinese => "保存新配置文件",
            Language::Japanese => "新しいプロファイルを保存",
            Language::Korean => "새 프로필 저장",
            Language::Spanish => "Guardar nuevo perfil",
            Language::French => "Enregistrer le nouveau profil",
            Language::German => "Neues Profil speichern",
        }
    }

    pub fn profile_exists_overwrite(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' already exists. Overwrite?", name),
            Language::Chinese => format!("配置文件 '{}' 已存在。是否覆盖？", name),
            Language::Japanese => {
                format!("プロファイル '{}' は既に存在します。上書きしますか？", name)
            }
            Language::Korean => {
                format!("프로필 '{}'이(가) 이미 존재합니다. 덮어쓰시겠습니까?", name)
            }
            Language::Spanish => format!("El perfil '{}' ya existe. ¿Sobrescribir?", name),
            Language::French => format!("Le profil '{}' existe déjà. Écraser ?", name),
            Language::German => format!("Profil '{}' existiert bereits. Überschreiben?", name),
        }
    }

    pub fn configure_gpg_details(&self) -> &str {
        match self.language {
            Language::English => "Configure GPG signing details?",
            Language::Chinese => "配置 GPG 签名详情？",
            Language::Japanese => "GPG署名の詳細を設定しますか？",
            Language::Korean => "GPG 서명 세부 정보를 구성하시겠습니까?",
            Language::Spanish => "¿Configurar detalles de firma GPG?",
            Language::French => "Configurer les détails de signature GPG ?",
            Language::German => "GPG-Signaturdetails konfigurieren?",
        }
    }

    pub fn configure_ssh_details(&self) -> &str {
        match self.language {
            Language::English => "Configure SSH key details?",
            Language::Chinese => "配置 SSH 密钥详情？",
            Language::Japanese => "SSHキーの詳細を設定しますか？",
            Language::Korean => "SSH 키 세부 정보를 구성하시겠습니까?",
            Language::Spanish => "¿Configurar detalles de la clave SSH?",
            Language::French => "Configurer les détails de la clé SSH ?",
            Language::German => "SSH-Schlüsseldetails konfigurieren?",
        }
    }

    pub fn profile_saved(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' saved successfully", name),
            Language::Chinese => format!("配置文件 '{}' 保存成功", name),
            Language::Japanese => format!("プロファイル '{}' を保存しました", name),
            Language::Korean => format!("프로필 '{}' 저장됨", name),
            Language::Spanish => format!("Perfil '{}' guardado exitosamente", name),
            Language::French => format!("Profil '{}' enregistré avec succès", name),
            Language::German => format!("Profil '{}' erfolgreich gespeichert", name),
        }
    }

    pub fn editing_profile(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Editing profile: {}", name),
            Language::Chinese => format!("正在编辑配置文件：{}", name),
            Language::Japanese => format!("プロファイルを編集中: {}", name),
            Language::Korean => format!("프로필 편집 중: {}", name),
            Language::Spanish => format!("Editando perfil: {}", name),
            Language::French => format!("Modification du profil : {}", name),
            Language::German => format!("Profil wird bearbeitet: {}", name),
        }
    }

    pub fn done_save_changes(&self) -> &str {
        match self.language {
            Language::English => "Done / Save changes",
            Language::Chinese => "完成 / 保存更改",
            Language::Japanese => "完了 / 変更を保存",
            Language::Korean => "완료 / 변경 사항 저장",
            Language::Spanish => "Hecho / Guardar cambios",
            Language::French => "Terminé / Enregistrer les modifications",
            Language::German => "Fertig / Änderungen speichern",
        }
    }

    pub fn edit_ssh_config(&self) -> &str {
        match self.language {
            Language::English => "Edit SSH configuration",
            Language::Chinese => "编辑 SSH 配置",
            Language::Japanese => "SSH設定を編集",
            Language::Korean => "SSH 구성 편집",
            Language::Spanish => "Editar configuración SSH",
            Language::French => "Modifier la configuration SSH",
            Language::German => "SSH-Konfiguration bearbeiten",
        }
    }

    pub fn edit_gpg_config(&self) -> &str {
        match self.language {
            Language::English => "Edit GPG configuration",
            Language::Chinese => "编辑 GPG 配置",
            Language::Japanese => "GPG設定を編集",
            Language::Korean => "GPG 구성 편집",
            Language::Spanish => "Editar configuración GPG",
            Language::French => "Modifier la configuration GPG",
            Language::German => "GPG-Konfiguration bearbeiten",
        }
    }

    pub fn edit_signing_prefs(&self) -> &str {
        match self.language {
            Language::English => "Edit signing preferences",
            Language::Chinese => "编辑签名偏好",
            Language::Japanese => "署名設定を編集",
            Language::Korean => "서명 기본 설정 편집",
            Language::Spanish => "Editar preferencias de firma",
            Language::French => "Modifier les préférences de signature",
            Language::German => "Signatur-Einstellungen bearbeiten",
        }
    }

    pub fn manage_tokens(&self) -> &str {
        match self.language {
            Language::English => "Manage tokens",
            Language::Chinese => "管理令牌",
            Language::Japanese => "トークンを管理",
            Language::Korean => "토큰 관리",
            Language::Spanish => "Gestionar tokens",
            Language::French => "Gérer les jetons",
            Language::German => "Tokens verwalten",
        }
    }

    pub fn what_to_edit(&self) -> &str {
        match self.language {
            Language::English => "What would you like to edit?",
            Language::Chinese => "你想编辑什么？",
            Language::Japanese => "何を編集しますか？",
            Language::Korean => "무엇을 편집하시겠습니까?",
            Language::Spanish => "¿Qué desea editar?",
            Language::French => "Que souhaitez-vous modifier ?",
            Language::German => "Was möchten Sie bearbeiten?",
        }
    }

    pub fn auto_sign_commits_confirm(&self) -> &str {
        match self.language {
            Language::English => "Auto-sign commits?",
            Language::Chinese => "自动签名提交？",
            Language::Japanese => "コミットを自動署名しますか？",
            Language::Korean => "커밋을 자동 서명하시겠습니까?",
            Language::Spanish => "¿Firmar commits automáticamente?",
            Language::French => "Signer automatiquement les commits ?",
            Language::German => "Commits automatisch signieren?",
        }
    }

    pub fn auto_sign_tags_confirm(&self) -> &str {
        match self.language {
            Language::English => "Auto-sign tags?",
            Language::Chinese => "自动签名标签？",
            Language::Japanese => "タグを自動署名しますか？",
            Language::Korean => "태그를 자동 서명하시겠습니까?",
            Language::Spanish => "¿Firmar etiquetas automáticamente?",
            Language::French => "Signer automatiquement les étiquettes ?",
            Language::German => "Tags automatisch signieren?",
        }
    }

    pub fn profile_updated(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Profile '{}' updated", name),
            Language::Chinese => format!("配置文件 '{}' 已更新", name),
            Language::Japanese => format!("プロファイル '{}' を更新しました", name),
            Language::Korean => format!("프로필 '{}' 업데이트됨", name),
            Language::Spanish => format!("Perfil '{}' actualizado", name),
            Language::French => format!("Profil '{}' mis à jour", name),
            Language::German => format!("Profil '{}' aktualisiert", name),
        }
    }

    pub fn remove_token_option(&self, service: &str) -> String {
        match self.language {
            Language::English => format!("Remove token: {}", service),
            Language::Chinese => format!("删除令牌：{}", service),
            Language::Japanese => format!("トークンを削除: {}", service),
            Language::Korean => format!("토큰 제거: {}", service),
            Language::Spanish => format!("Eliminar token: {}", service),
            Language::French => format!("Supprimer le jeton : {}", service),
            Language::German => format!("Token entfernen: {}", service),
        }
    }

    pub fn add_new_token(&self) -> &str {
        match self.language {
            Language::English => "Add new token",
            Language::Chinese => "添加新令牌",
            Language::Japanese => "新しいトークンを追加",
            Language::Korean => "새 토큰 추가",
            Language::Spanish => "Añadir nuevo token",
            Language::French => "Ajouter un nouveau jeton",
            Language::German => "Neues Token hinzufügen",
        }
    }

    pub fn back(&self) -> &str {
        match self.language {
            Language::English => "Back",
            Language::Chinese => "返回",
            Language::Japanese => "戻る",
            Language::Korean => "뒤로",
            Language::Spanish => "Atrás",
            Language::French => "Retour",
            Language::German => "Zurück",
        }
    }

    pub fn manage_tokens_for(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Manage tokens for '{}'", name),
            Language::Chinese => format!("管理 '{}' 的令牌", name),
            Language::Japanese => format!("'{}' のトークンを管理", name),
            Language::Korean => format!("'{}'의 토큰 관리", name),
            Language::Spanish => format!("Gestionar tokens de '{}'", name),
            Language::French => format!("Gérer les jetons de '{}'", name),
            Language::German => format!("Tokens für '{}' verwalten", name),
        }
    }

    pub fn token_removed(&self, service: &str) -> String {
        match self.language {
            Language::English => format!("Token '{}' removed", service),
            Language::Chinese => format!("令牌 '{}' 已删除", service),
            Language::Japanese => format!("トークン '{}' を削除しました", service),
            Language::Korean => format!("토큰 '{}' 제거됨", service),
            Language::Spanish => format!("Token '{}' eliminado", service),
            Language::French => format!("Jeton '{}' supprimé", service),
            Language::German => format!("Token '{}' entfernt", service),
        }
    }

    pub fn set_for_current_repo(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Set '{}' for current repository", name),
            Language::Chinese => format!("已为当前仓库设置 '{}'", name),
            Language::Japanese => format!("'{}' を現在のリポジトリに設定しました", name),
            Language::Korean => format!("'{}'을(를) 현재 저장소에 설정함", name),
            Language::Spanish => format!("'{}' establecido para el repositorio actual", name),
            Language::French => format!("'{}' défini pour le dépôt actuel", name),
            Language::German => format!("'{}' für das aktuelle Repository festgelegt", name),
        }
    }

    pub fn applied_to_current_repo(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Applied profile '{}' to current repository", name),
            Language::Chinese => format!("已将配置文件 '{}' 应用到当前仓库", name),
            Language::Japanese => {
                format!("プロファイル '{}' を現在のリポジトリに適用しました", name)
            }
            Language::Korean => format!("프로필 '{}'을(를) 현재 저장소에 적용함", name),
            Language::Spanish => format!("Perfil '{}' aplicado al repositorio actual", name),
            Language::French => format!("Profil '{}' appliqué au dépôt actuel", name),
            Language::German => format!("Profil '{}' auf das aktuelle Repository angewendet", name),
        }
    }

    pub fn applied_globally(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Applied profile '{}' globally", name),
            Language::Chinese => format!("已全局应用配置文件 '{}'", name),
            Language::Japanese => format!("プロファイル '{}' をグローバルに適用しました", name),
            Language::Korean => format!("프로필 '{}'을(를) 전역으로 적용함", name),
            Language::Spanish => format!("Perfil '{}' aplicado globalmente", name),
            Language::French => format!("Profil '{}' appliqué globalement", name),
            Language::German => format!("Profil '{}' global angewendet", name),
        }
    }

    pub fn select_profile_to_switch(&self) -> &str {
        match self.language {
            Language::English => "Select profile to switch to",
            Language::Chinese => "选择要切换到的配置文件",
            Language::Japanese => "切り替えるプロファイルを選択",
            Language::Korean => "전환할 프로필 선택",
            Language::Spanish => "Seleccione el perfil al que cambiar",
            Language::French => "Sélectionnez le profil vers lequel basculer",
            Language::German => "Profil zum Wechseln auswählen",
        }
    }

    pub fn switched_to(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Switched to profile '{}'", name),
            Language::Chinese => format!("已切换到配置文件 '{}'", name),
            Language::Japanese => format!("プロファイル '{}' に切り替えました", name),
            Language::Korean => format!("프로필 '{}'로 전환됨", name),
            Language::Spanish => format!("Cambiado al perfil '{}'", name),
            Language::French => format!("Basculé vers le profil '{}'", name),
            Language::German => format!("Zum Profil '{}' gewechselt", name),
        }
    }

    pub fn apply_to_current_repo(&self) -> &str {
        match self.language {
            Language::English => "Apply to current repository?",
            Language::Chinese => "应用到当前仓库？",
            Language::Japanese => "現在のリポジトリに適用しますか？",
            Language::Korean => "현재 저장소에 적용하시겠습니까?",
            Language::Spanish => "¿Aplicar al repositorio actual?",
            Language::French => "Appliquer au dépôt actuel ?",
            Language::German => "Auf das aktuelle Repository anwenden?",
        }
    }

    pub fn copied_profile(&self, from: &str, to: &str) -> String {
        match self.language {
            Language::English => format!("Copied profile '{}' to '{}'", from, to),
            Language::Chinese => format!("已将配置文件 '{}' 复制为 '{}'", from, to),
            Language::Japanese => format!("プロファイル '{}' を '{}' にコピーしました", from, to),
            Language::Korean => format!("프로필 '{}'을(를) '{}'에 복사함", from, to),
            Language::Spanish => format!("Perfil '{}' copiado a '{}'", from, to),
            Language::French => format!("Profil '{}' copié vers '{}'", from, to),
            Language::German => format!("Profil '{}' nach '{}' kopiert", from, to),
        }
    }

    pub fn add_token_header(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Add token to profile '{}'", name),
            Language::Chinese => format!("向配置文件 '{}' 添加令牌", name),
            Language::Japanese => format!("プロファイル '{}' にトークンを追加", name),
            Language::Korean => format!("프로필 '{}'에 토큰 추가", name),
            Language::Spanish => format!("Añadir token al perfil '{}'", name),
            Language::French => format!("Ajouter un jeton au profil '{}'", name),
            Language::German => format!("Token zum Profil '{}' hinzufügen", name),
        }
    }

    pub fn token_prompt(&self, service: &str) -> String {
        match self.language {
            Language::English => format!("Token for {}", service),
            Language::Chinese => format!("{} 的令牌", service),
            Language::Japanese => format!("{} のトークン", service),
            Language::Korean => format!("{}용 토큰", service),
            Language::Spanish => format!("Token para {}", service),
            Language::French => format!("Jeton pour {}", service),
            Language::German => format!("Token für {}", service),
        }
    }

    pub fn token_type_prompt(&self) -> &str {
        match self.language {
            Language::English => "Token type",
            Language::Chinese => "令牌类型",
            Language::Japanese => "トークンタイプ",
            Language::Korean => "토큰 유형",
            Language::Spanish => "Tipo de token",
            Language::French => "Type de jeton",
            Language::German => "Token-Typ",
        }
    }

    pub fn token_added(&self, service: &str, profile: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "Token for '{}' added to profile '{}' (stored securely in keyring)",
                    service, profile
                )
            }
            Language::Chinese => format!(
                "'{}' 的令牌已添加到配置文件 '{}'（安全存储在密钥环中）",
                service, profile
            ),
            Language::Japanese => format!(
                "'{}' のトークンをプロファイル '{}' に追加しました（キーリングに安全に保存）",
                service, profile
            ),
            Language::Korean => format!(
                "'{}'용 토큰이 프로필 '{}'에 추가됨(키링에 안전하게 저장)",
                service, profile
            ),
            Language::Spanish => format!(
                "Token de '{}' añadido al perfil '{}' (almacenado de forma segura en el keyring)",
                service, profile
            ),
            Language::French => format!(
                "Jeton de '{}' ajouté au profil '{}' (stocké en toute sécurité dans le trousseau)",
                service, profile
            ),
            Language::German => format!(
                "Token für '{}' zum Profil '{}' hinzugefügt (sicher im Schlüsselbund gespeichert)",
                service, profile
            ),
        }
    }

    pub fn remove_token_confirm(&self, service: &str, profile: &str) -> String {
        match self.language {
            Language::English => {
                format!("Remove token '{}' from profile '{}'?", service, profile)
            }
            Language::Chinese => format!("从配置文件 '{}' 删除令牌 '{}'？", profile, service),
            Language::Japanese => format!(
                "プロファイル '{}' からトークン '{}' を削除しますか？",
                profile, service
            ),
            Language::Korean => format!(
                "프로필 '{}'에서 토큰 '{}'을(를) 제거하시겠습니까?",
                profile, service
            ),
            Language::Spanish => {
                format!("¿Eliminar el token '{}' del perfil '{}'?", service, profile)
            }
            Language::French => {
                format!("Supprimer le jeton '{}' du profil '{}' ?", service, profile)
            }
            Language::German => {
                format!("Token '{}' aus Profil '{}' entfernen?", service, profile)
            }
        }
    }

    pub fn token_removed_from(&self, service: &str, profile: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "Token '{}' removed from profile '{}' (deleted from keyring)",
                    service, profile
                )
            }
            Language::Chinese => format!(
                "令牌 '{}' 已从配置文件 '{}' 删除（已从密钥环中删除）",
                service, profile
            ),
            Language::Japanese => format!(
                "トークン '{}' をプロファイル '{}' から削除しました（キーリングから削除済み）",
                service, profile
            ),
            Language::Korean => format!(
                "토큰 '{}'이(가) 프로필 '{}'에서 제거됨(키링에서 삭제됨)",
                service, profile
            ),
            Language::Spanish => format!(
                "Token '{}' eliminado del perfil '{}' (borrado del keyring)",
                service, profile
            ),
            Language::French => format!(
                "Jeton '{}' supprimé du profil '{}' (effacé du trousseau)",
                service, profile
            ),
            Language::German => format!(
                "Token '{}' aus Profil '{}' entfernt (aus dem Schlüsselbund gelöscht)",
                service, profile
            ),
        }
    }

    pub fn no_tokens_configured(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("No tokens configured for profile '{}'", name),
            Language::Chinese => format!("配置文件 '{}' 未配置令牌", name),
            Language::Japanese => format!("プロファイル '{}' にトークンが設定されていません", name),
            Language::Korean => format!("프로필 '{}'에 구성된 토큰이 없습니다", name),
            Language::Spanish => format!("No hay tokens configurados para el perfil '{}'", name),
            Language::French => format!("Aucun jeton configuré pour le profil '{}'", name),
            Language::German => format!("Keine Tokens für Profil '{}' konfiguriert", name),
        }
    }

    pub fn tokens_for_profile(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Tokens for profile '{}':", name),
            Language::Chinese => format!("配置文件 '{}' 的令牌：", name),
            Language::Japanese => format!("プロファイル '{}' のトークン：", name),
            Language::Korean => format!("프로필 '{}'의 토큰:", name),
            Language::Spanish => format!("Tokens del perfil '{}':", name),
            Language::French => format!("Jetons du profil '{}' :", name),
            Language::German => format!("Tokens für Profil '{}':", name),
        }
    }

    pub fn token_stored_marker(&self) -> &str {
        match self.language {
            Language::English => "stored",
            Language::Chinese => "已存储",
            Language::Japanese => "保存済み",
            Language::Korean => "저장됨",
            Language::Spanish => "almacenado",
            Language::French => "stocké",
            Language::German => "gespeichert",
        }
    }

    pub fn token_not_stored_marker(&self) -> &str {
        match self.language {
            Language::English => "not stored",
            Language::Chinese => "未存储",
            Language::Japanese => "未保存",
            Language::Korean => "저장 안 됨",
            Language::Spanish => "no almacenado",
            Language::French => "non stocké",
            Language::German => "nicht gespeichert",
        }
    }

    pub fn checking_profile(&self, name: &str) -> String {
        match self.language {
            Language::English => format!("Checking profile '{}' against git configuration", name),
            Language::Chinese => format!("正在将配置文件 '{}' 与 git 配置进行核对", name),
            Language::Japanese => format!("プロファイル '{}' をgit設定と照合しています", name),
            Language::Korean => format!("프로필 '{}'을(를) git 구성과 대조하는 중", name),
            Language::Spanish => {
                format!(
                    "Comprobando el perfil '{}' contra la configuración git",
                    name
                )
            }
            Language::French => {
                format!(
                    "Vérification du profil '{}' par rapport à la configuration git",
                    name
                )
            }
            Language::German => {
                format!(
                    "Profil '{}' wird mit der Git-Konfiguration abgeglichen",
                    name
                )
            }
        }
    }

    pub fn config_matches(&self) -> &str {
        match self.language {
            Language::English => "Profile configuration matches git settings",
            Language::Chinese => "配置文件配置与 git 设置一致",
            Language::Japanese => "プロファイル設定はgit設定と一致します",
            Language::Korean => "프로필 구성이 git 설정과 일치함",
            Language::Spanish => "La configuración del perfil coincide con los ajustes de git",
            Language::French => "La configuration du profil correspond aux paramètres git",
            Language::German => "Profilkonfiguration stimmt mit den Git-Einstellungen überein",
        }
    }

    pub fn config_differs(&self) -> &str {
        match self.language {
            Language::English => "Profile configuration differs from git settings",
            Language::Chinese => "配置文件配置与 git 设置不一致",
            Language::Japanese => "プロファイル設定はgit設定と異なります",
            Language::Korean => "프로필 구성이 git 설정과 다름",
            Language::Spanish => "La configuración del perfil difiere de los ajustes de git",
            Language::French => "La configuration du profil diffère des paramètres git",
            Language::German => "Profilkonfiguration weicht von den Git-Einstellungen ab",
        }
    }

    pub fn differences_header(&self) -> &str {
        match self.language {
            Language::English => "Differences:",
            Language::Chinese => "差异：",
            Language::Japanese => "相違点：",
            Language::Korean => "차이점:",
            Language::Spanish => "Diferencias:",
            Language::French => "Différences :",
            Language::German => "Unterschiede:",
        }
    }

    pub fn profile_diff_label(&self) -> &str {
        match self.language {
            Language::English => "Profile:",
            Language::Chinese => "配置文件：",
            Language::Japanese => "プロファイル:",
            Language::Korean => "프로필:",
            Language::Spanish => "Perfil:",
            Language::French => "Profil :",
            Language::German => "Profil:",
        }
    }

    pub fn git_diff_label(&self) -> &str {
        match self.language {
            Language::English => "Git:",
            Language::Chinese => "Git：",
            Language::Japanese => "Git:",
            Language::Korean => "Git:",
            Language::Spanish => "Git:",
            Language::French => "Git :",
            Language::German => "Git:",
        }
    }

    pub fn profile_usage_stats(&self) -> &str {
        match self.language {
            Language::English => "Profile Usage Statistics:",
            Language::Chinese => "配置文件使用统计：",
            Language::Japanese => "プロファイル使用統計：",
            Language::Korean => "프로필 사용 통계:",
            Language::Spanish => "Estadísticas de uso del perfil:",
            Language::French => "Statistiques d'utilisation du profil :",
            Language::German => "Profil-Nutzungsstatistik:",
        }
    }

    pub fn repositories_header(&self) -> &str {
        match self.language {
            Language::English => "Repositories:",
            Language::Chinese => "仓库：",
            Language::Japanese => "リポジトリ：",
            Language::Korean => "저장소:",
            Language::Spanish => "Repositorios:",
            Language::French => "Dépôts :",
            Language::German => "Repositories:",
        }
    }

    pub fn uses_line(&self, repo: &str, count: u64) -> String {
        match self.language {
            Language::English => format!("{} ({} uses)", repo, count),
            Language::Chinese => format!("{}（{} 次使用）", repo, count),
            Language::Japanese => format!("{}（{} 回使用）", repo, count),
            Language::Korean => format!("{}({}회 사용)", repo, count),
            Language::Spanish => format!("{} ({} usos)", repo, count),
            Language::French => format!("{} ({} utilisations)", repo, count),
            Language::German => format!("{} ({} Nutzungen)", repo, count),
        }
    }

    pub fn ssh_setup_header(&self) -> &str {
        match self.language {
            Language::English => "SSH Configuration",
            Language::Chinese => "SSH 配置",
            Language::Japanese => "SSH設定",
            Language::Korean => "SSH 구성",
            Language::Spanish => "Configuración SSH",
            Language::French => "Configuration SSH",
            Language::German => "SSH-Konfiguration",
        }
    }

    pub fn keyring_unavailable_pat(&self) -> &str {
        match self.language {
            Language::English => "Keyring is not available. Cannot store PAT securely.",
            Language::Chinese => "密钥环不可用。无法安全存储 PAT。",
            Language::Japanese => "キーリングが利用できません。PATを安全に保存できません。",
            Language::Korean => "키링을 사용할 수 없습니다. PAT을 안전하게 저장할 수 없습니다.",
            Language::Spanish => {
                "El keyring no está disponible. No se puede almacenar el PAT de forma segura."
            }
            Language::French => {
                "Le trousseau n'est pas disponible. Impossible de stocker le PAT en toute sécurité."
            }
            Language::German => {
                "Schlüsselbund nicht verfügbar. PAT kann nicht sicher gespeichert werden."
            }
        }
    }

    pub fn continue_without_secure(&self) -> &str {
        match self.language {
            Language::English => "Continue without secure token storage?",
            Language::Chinese => "在没有安全令牌存储的情况下继续？",
            Language::Japanese => "安全なトークン保存なしで続行しますか？",
            Language::Korean => "안전한 토큰 저장 없이 계속하시겠습니까?",
            Language::Spanish => "¿Continuar sin almacenamiento seguro de tokens?",
            Language::French => "Continuer sans stockage sécurisé des jetons ?",
            Language::German => "Ohne sichere Token-Speicherung fortfahren?",
        }
    }

    pub fn service_name_prompt(&self) -> &str {
        match self.language {
            Language::English => "Service name (e.g., github, gitlab)",
            Language::Chinese => "服务名称（例如：github、gitlab）",
            Language::Japanese => "サービス名（例：github、gitlab）",
            Language::Korean => "서비스 이름(예: github, gitlab)",
            Language::Spanish => "Nombre del servicio (p. ej., github, gitlab)",
            Language::French => "Nom du service (ex. : github, gitlab)",
            Language::German => "Dienstname (z.B. github, gitlab)",
        }
    }

    pub fn token_value_prompt(&self) -> &str {
        match self.language {
            Language::English => "Token value",
            Language::Chinese => "令牌值",
            Language::Japanese => "トークン値",
            Language::Korean => "토큰 값",
            Language::Spanish => "Valor del token",
            Language::French => "Valeur du jeton",
            Language::German => "Token-Wert",
        }
    }

    pub fn token_stored_keyring(&self) -> &str {
        match self.language {
            Language::English => "Token stored securely in keyring",
            Language::Chinese => "令牌已安全存储在密钥环中",
            Language::Japanese => "トークンをキーリングに安全に保存しました",
            Language::Korean => "토큰이 키링에 안전하게 저장됨",
            Language::Spanish => "Token almacenado de forma segura en el keyring",
            Language::French => "Jeton stocké en toute sécurité dans le trousseau",
            Language::German => "Token sicher im Schlüsselbund gespeichert",
        }
    }

    pub fn description_optional(&self) -> &str {
        match self.language {
            Language::English => "Description (optional)",
            Language::Chinese => "描述（可选）",
            Language::Japanese => "説明（オプション）",
            Language::Korean => "설명(선택 사항)",
            Language::Spanish => "Descripción (opcional)",
            Language::French => "Description (optionnel)",
            Language::German => "Beschreibung (optional)",
        }
    }

    pub fn organization_prompt(&self) -> &str {
        match self.language {
            Language::English => "Organization",
            Language::Chinese => "组织",
            Language::Japanese => "組織",
            Language::Korean => "조직",
            Language::Spanish => "Organización",
            Language::French => "Organisation",
            Language::German => "Organisation",
        }
    }

    // ---- config command (issue 17) ----

    pub fn keyring_status_header(&self) -> &str {
        match self.language {
            Language::English => "Keyring Status",
            Language::Chinese => "密钥环状态",
            Language::Japanese => "キーリングステータス",
            Language::Korean => "키링 상태",
            Language::Spanish => "Estado del keyring",
            Language::French => "État du trousseau",
            Language::German => "Schlüsselbund-Status",
        }
    }

    pub fn environment_variables_header(&self) -> &str {
        match self.language {
            Language::English => "Environment Variables:",
            Language::Chinese => "环境变量：",
            Language::Japanese => "環境変数：",
            Language::Korean => "환경 변수:",
            Language::Spanish => "Variables de entorno:",
            Language::French => "Variables d'environnement :",
            Language::German => "Umgebungsvariablen:",
        }
    }

    pub fn keyring_available_status(&self) -> &str {
        match self.language {
            Language::English => "Keyring is available",
            Language::Chinese => "密钥环可用",
            Language::Japanese => "キーリングは利用可能です",
            Language::Korean => "키링 사용 가능",
            Language::Spanish => "El keyring está disponible",
            Language::French => "Le trousseau est disponible",
            Language::German => "Schlüsselbund ist verfügbar",
        }
    }

    pub fn keyring_not_available_status(&self) -> &str {
        match self.language {
            Language::English => "Keyring is not available",
            Language::Chinese => "密钥环不可用",
            Language::Japanese => "キーリングは利用できません",
            Language::Korean => "키링 사용 불가",
            Language::Spanish => "El keyring no está disponible",
            Language::French => "Le trousseau n'est pas disponible",
            Language::German => "Schlüsselbund ist nicht verfügbar",
        }
    }

    pub fn quicommit_configuration(&self) -> &str {
        match self.language {
            Language::English => "QuiCommit Configuration",
            Language::Chinese => "QuiCommit 配置",
            Language::Japanese => "QuiCommit設定",
            Language::Korean => "QuiCommit 구성",
            Language::Spanish => "Configuración de QuiCommit",
            Language::French => "Configuration QuiCommit",
            Language::German => "QuiCommit-Konfiguration",
        }
    }

    pub fn general_section(&self) -> &str {
        match self.language {
            Language::English => "General:",
            Language::Chinese => "常规：",
            Language::Japanese => "一般：",
            Language::Korean => "일반:",
            Language::Spanish => "General:",
            Language::French => "Général :",
            Language::German => "Allgemein:",
        }
    }

    pub fn config_file_value(&self) -> &str {
        match self.language {
            Language::English => "Config file:",
            Language::Chinese => "配置文件：",
            Language::Japanese => "設定ファイル：",
            Language::Korean => "구성 파일:",
            Language::Spanish => "Archivo de configuración:",
            Language::French => "Fichier de configuration :",
            Language::German => "Konfigurationsdatei:",
        }
    }

    pub fn default_profile_value(&self) -> &str {
        match self.language {
            Language::English => "Default profile:",
            Language::Chinese => "默认配置文件：",
            Language::Japanese => "デフォルトプロファイル:",
            Language::Korean => "기본 프로필:",
            Language::Spanish => "Perfil predeterminado:",
            Language::French => "Profil par défaut :",
            Language::German => "Standardprofil:",
        }
    }

    pub fn profiles_value(&self) -> &str {
        match self.language {
            Language::English => "Profiles:",
            Language::Chinese => "配置文件：",
            Language::Japanese => "プロファイル：",
            Language::Korean => "프로필:",
            Language::Spanish => "Perfiles:",
            Language::French => "Profils :",
            Language::German => "Profile:",
        }
    }

    pub fn none_value(&self) -> &str {
        match self.language {
            Language::English => "(none)",
            Language::Chinese => "（无）",
            Language::Japanese => "（なし）",
            Language::Korean => "(없음)",
            Language::Spanish => "(ninguno)",
            Language::French => "(aucun)",
            Language::German => "(keine)",
        }
    }

    pub fn llm_configuration_section(&self) -> &str {
        match self.language {
            Language::English => "LLM Configuration:",
            Language::Chinese => "LLM 配置：",
            Language::Japanese => "LLM設定：",
            Language::Korean => "LLM 구성:",
            Language::Spanish => "Configuración LLM:",
            Language::French => "Configuration LLM :",
            Language::German => "LLM-Konfiguration:",
        }
    }

    pub fn provider_value(&self) -> &str {
        match self.language {
            Language::English => "Provider:",
            Language::Chinese => "提供商：",
            Language::Japanese => "プロバイダー:",
            Language::Korean => "공급자:",
            Language::Spanish => "Proveedor:",
            Language::French => "Fournisseur :",
            Language::German => "Anbieter:",
        }
    }

    pub fn model_value(&self) -> &str {
        match self.language {
            Language::English => "Model:",
            Language::Chinese => "模型：",
            Language::Japanese => "モデル:",
            Language::Korean => "모델:",
            Language::Spanish => "Modelo:",
            Language::French => "Modèle :",
            Language::German => "Modell:",
        }
    }

    pub fn base_url_value(&self) -> &str {
        match self.language {
            Language::English => "Base URL:",
            Language::Chinese => "基础 URL：",
            Language::Japanese => "ベースURL:",
            Language::Korean => "기본 URL:",
            Language::Spanish => "URL base:",
            Language::French => "URL de base :",
            Language::German => "Basis-URL:",
        }
    }

    pub fn api_key_value(&self) -> &str {
        match self.language {
            Language::English => "API key:",
            Language::Chinese => "API 密钥：",
            Language::Japanese => "APIキー:",
            Language::Korean => "API 키:",
            Language::Spanish => "Clave API:",
            Language::French => "Clé API :",
            Language::German => "API-Schlüssel:",
        }
    }

    pub fn max_tokens_value(&self) -> &str {
        match self.language {
            Language::English => "Max tokens:",
            Language::Chinese => "最大令牌数：",
            Language::Japanese => "最大トークン数:",
            Language::Korean => "최대 토큰:",
            Language::Spanish => "Tokens máximos:",
            Language::French => "Jetons maximum :",
            Language::German => "Maximale Tokens:",
        }
    }

    pub fn temperature_value(&self) -> &str {
        match self.language {
            Language::English => "Temperature:",
            Language::Chinese => "温度：",
            Language::Japanese => "温度:",
            Language::Korean => "온도:",
            Language::Spanish => "Temperatura:",
            Language::French => "Température :",
            Language::German => "Temperatur:",
        }
    }

    pub fn timeout_value(&self) -> &str {
        match self.language {
            Language::English => "Timeout:",
            Language::Chinese => "超时：",
            Language::Japanese => "タイムアウト:",
            Language::Korean => "시간 초과:",
            Language::Spanish => "Tiempo de espera:",
            Language::French => "Délai d'attente :",
            Language::German => "Zeitlimit:",
        }
    }

    pub fn commit_configuration_section(&self) -> &str {
        match self.language {
            Language::English => "Commit Configuration:",
            Language::Chinese => "提交配置：",
            Language::Japanese => "コミット設定：",
            Language::Korean => "커밋 구성:",
            Language::Spanish => "Configuración de commit:",
            Language::French => "Configuration de commit :",
            Language::German => "Commit-Konfiguration:",
        }
    }

    pub fn format_value(&self) -> &str {
        match self.language {
            Language::English => "Format:",
            Language::Chinese => "格式：",
            Language::Japanese => "フォーマット:",
            Language::Korean => "형식:",
            Language::Spanish => "Formato:",
            Language::French => "Format :",
            Language::German => "Format:",
        }
    }

    pub fn auto_generate_value(&self) -> &str {
        match self.language {
            Language::English => "Auto-generate:",
            Language::Chinese => "自动生成：",
            Language::Japanese => "自動生成:",
            Language::Korean => "자동 생성:",
            Language::Spanish => "Generación automática:",
            Language::French => "Génération automatique :",
            Language::German => "Automatisch generieren:",
        }
    }

    pub fn tag_configuration_section(&self) -> &str {
        match self.language {
            Language::English => "Tag Configuration:",
            Language::Chinese => "标签配置：",
            Language::Japanese => "タグ設定：",
            Language::Korean => "태그 구성:",
            Language::Spanish => "Configuración de etiquetas:",
            Language::French => "Configuration des étiquettes :",
            Language::German => "Tag-Konfiguration:",
        }
    }

    pub fn version_prefix_value(&self) -> &str {
        match self.language {
            Language::English => "Version prefix:",
            Language::Chinese => "版本前缀：",
            Language::Japanese => "バージョンプレフィックス:",
            Language::Korean => "버전 접두사:",
            Language::Spanish => "Prefijo de versión:",
            Language::French => "Préfixe de version :",
            Language::German => "Versionspräfix:",
        }
    }

    pub fn language_configuration_section(&self) -> &str {
        match self.language {
            Language::English => "Language Configuration:",
            Language::Chinese => "语言配置：",
            Language::Japanese => "言語設定：",
            Language::Korean => "언어 구성:",
            Language::Spanish => "Configuración de idioma:",
            Language::French => "Configuration de langue :",
            Language::German => "Sprachkonfiguration:",
        }
    }

    pub fn output_language_value(&self) -> &str {
        match self.language {
            Language::English => "Output language:",
            Language::Chinese => "输出语言：",
            Language::Japanese => "出力言語:",
            Language::Korean => "출력 언어:",
            Language::Spanish => "Idioma de salida:",
            Language::French => "Langue de sortie :",
            Language::German => "Ausgabesprache:",
        }
    }

    pub fn keep_types_english_value(&self) -> &str {
        match self.language {
            Language::English => "Keep commit types in English:",
            Language::Chinese => "保持提交类型为英文：",
            Language::Japanese => "コミットタイプを英語のままにする:",
            Language::Korean => "커밋 유형을 영어로 유지:",
            Language::Spanish => "Mantener tipos de commit en inglés:",
            Language::French => "Conserver les types de commit en anglais :",
            Language::German => "Commit-Typen auf Englisch belassen:",
        }
    }

    pub fn keep_changelog_types_english_value(&self) -> &str {
        match self.language {
            Language::English => "Keep changelog types in English:",
            Language::Chinese => "保持变更日志类型为英文：",
            Language::Japanese => "変更ログタイプを英語のままにする:",
            Language::Korean => "변경 로그 유형을 영어로 유지:",
            Language::Spanish => "Mantener tipos de changelog en inglés:",
            Language::French => "Conserver les types de changelog en anglais :",
            Language::German => "Changelog-Typen auf Englisch belassen:",
        }
    }

    pub fn emoji_decorations_value(&self) -> &str {
        match self.language {
            Language::English => "Emoji decorations:",
            Language::Chinese => "Emoji 装饰：",
            Language::Japanese => "絵文字装飾:",
            Language::Korean => "이모지 장식:",
            Language::Spanish => "Decoraciones emoji:",
            Language::French => "Décorations emoji :",
            Language::German => "Emoji-Dekorationen:",
        }
    }

    pub fn changelog_configuration_section(&self) -> &str {
        match self.language {
            Language::English => "Changelog Configuration:",
            Language::Chinese => "变更日志配置：",
            Language::Japanese => "変更ログ設定：",
            Language::Korean => "변경 로그 구성:",
            Language::Spanish => "Configuración del changelog:",
            Language::French => "Configuration du changelog :",
            Language::German => "Changelog-Konfiguration:",
        }
    }

    pub fn path_value(&self) -> &str {
        match self.language {
            Language::English => "Path:",
            Language::Chinese => "路径：",
            Language::Japanese => "パス:",
            Language::Korean => "경로:",
            Language::Spanish => "Ruta:",
            Language::French => "Chemin :",
            Language::German => "Pfad:",
        }
    }

    pub fn security_section(&self) -> &str {
        match self.language {
            Language::English => "Security:",
            Language::Chinese => "安全：",
            Language::Japanese => "セキュリティ：",
            Language::Korean => "보안:",
            Language::Spanish => "Seguridad:",
            Language::French => "Sécurité :",
            Language::German => "Sicherheit:",
        }
    }

    pub fn repository_mappings_value(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("Repository mappings: {} mapping(s)", count),
            Language::Chinese => format!("仓库映射：{} 个", count),
            Language::Japanese => format!("リポジトリマッピング: {} 件", count),
            Language::Korean => format!("저장소 매핑: {}개", count),
            Language::Spanish => format!("Asignaciones de repositorio: {} asignación(es)", count),
            Language::French => format!("Associations de dépôt : {} association(s)", count),
            Language::German => format!("Repository-Zuordnungen: {} Zuordnung(en)", count),
        }
    }

    pub fn keyring_value(&self) -> &str {
        match self.language {
            Language::English => "Keyring:",
            Language::Chinese => "密钥环：",
            Language::Japanese => "キーリング:",
            Language::Korean => "키링:",
            Language::Spanish => "Keyring:",
            Language::French => "Trousseau :",
            Language::German => "Schlüsselbund:",
        }
    }

    pub fn available_value(&self) -> &str {
        match self.language {
            Language::English => "available",
            Language::Chinese => "可用",
            Language::Japanese => "利用可能",
            Language::Korean => "사용 가능",
            Language::Spanish => "disponible",
            Language::French => "disponible",
            Language::German => "verfügbar",
        }
    }

    pub fn unavailable_value(&self) -> &str {
        match self.language {
            Language::English => "unavailable",
            Language::Chinese => "不可用",
            Language::Japanese => "利用不可",
            Language::Korean => "사용 불가",
            Language::Spanish => "no disponible",
            Language::French => "indisponible",
            Language::German => "nicht verfügbar",
        }
    }

    pub fn select_llm_provider_header(&self) -> &str {
        match self.language {
            Language::English => "Select LLM Provider:",
            Language::Chinese => "选择 LLM 提供商：",
            Language::Japanese => "LLMプロバイダーを選択：",
            Language::Korean => "LLM 공급자 선택:",
            Language::Spanish => "Seleccione el proveedor LLM:",
            Language::French => "Sélectionnez le fournisseur LLM :",
            Language::German => "LLM-Anbieter auswählen:",
        }
    }

    pub fn api_key_exists_update(&self) -> &str {
        match self.language {
            Language::English => "API key already exists. Update it?",
            Language::Chinese => "API 密钥已存在。是否更新？",
            Language::Japanese => "APIキーは既に存在します。更新しますか？",
            Language::Korean => "API 키가 이미 존재합니다. 업데이트하시겠습니까?",
            Language::Spanish => "La clave API ya existe. ¿Actualizarla?",
            Language::French => "La clé API existe déjà. La mettre à jour ?",
            Language::German => "API-Schlüssel existiert bereits. Aktualisieren?",
        }
    }

    pub fn reset_confirm(&self) -> &str {
        match self.language {
            Language::English => "Reset all configuration to defaults?",
            Language::Chinese => "将所有配置重置为默认值？",
            Language::Japanese => "すべての設定をデフォルトにリセットしますか？",
            Language::Korean => "모든 구성을 기본값으로 재설정하시겠습니까?",
            Language::Spanish => {
                "¿Restablecer toda la configuración a los valores predeterminados?"
            }
            Language::French => "Réinitialiser toute la configuration aux valeurs par défaut ?",
            Language::German => "Gesamte Konfiguration auf Standardwerte zurücksetzen?",
        }
    }

    pub fn reset_cancelled(&self) -> &str {
        match self.language {
            Language::English => "Reset cancelled.",
            Language::Chinese => "已取消重置。",
            Language::Japanese => "リセットがキャンセルされました。",
            Language::Korean => "재설정이 취소되었습니다.",
            Language::Spanish => "Restablecimiento cancelado.",
            Language::French => "Réinitialisation annulée.",
            Language::German => "Zurücksetzen abgebrochen.",
        }
    }

    pub fn encrypt_export_confirm(&self) -> &str {
        match self.language {
            Language::English => "Encrypt the exported configuration?",
            Language::Chinese => "加密导出的配置？",
            Language::Japanese => "エクスポートする設定を暗号化しますか？",
            Language::Korean => "내보낸 구성을 암호화하시겠습니까?",
            Language::Spanish => "¿Cifrar la configuración exportada?",
            Language::French => "Chiffrer la configuration exportée ?",
            Language::German => "Exportierte Konfiguration verschlüsseln?",
        }
    }

    pub fn enter_encryption_password(&self) -> &str {
        match self.language {
            Language::English => "Enter encryption password",
            Language::Chinese => "输入加密密码",
            Language::Japanese => "暗号化パスワードを入力",
            Language::Korean => "암호화 비밀번호 입력",
            Language::Spanish => "Introduzca la contraseña de cifrado",
            Language::French => "Saisissez le mot de passe de chiffrement",
            Language::German => "Verschlüsselungspasswort eingeben",
        }
    }

    pub fn confirm_encryption_password(&self) -> &str {
        match self.language {
            Language::English => "Confirm encryption password",
            Language::Chinese => "确认加密密码",
            Language::Japanese => "暗号化パスワードを確認",
            Language::Korean => "암호화 비밀번호 확인",
            Language::Spanish => "Confirme la contraseña de cifrado",
            Language::French => "Confirmez le mot de passe de chiffrement",
            Language::German => "Verschlüsselungspasswort bestätigen",
        }
    }

    pub fn enter_decryption_password(&self) -> &str {
        match self.language {
            Language::English => "Enter decryption password",
            Language::Chinese => "输入解密密码",
            Language::Japanese => "復号化パスワードを入力",
            Language::Korean => "복호화 비밀번호 입력",
            Language::Spanish => "Introduzca la contraseña de descifrado",
            Language::French => "Saisissez le mot de passe de déchiffrement",
            Language::German => "Entschlüsselungspasswort eingeben",
        }
    }

    pub fn importing_pats_header(&self) -> &str {
        match self.language {
            Language::English => "Importing Personal Access Tokens...",
            Language::Chinese => "正在导入个人访问令牌...",
            Language::Japanese => "個人アクセストークンをインポート中...",
            Language::Korean => "개인 액세스 토큰 가져오는 중...",
            Language::Spanish => "Importando tokens de acceso personal...",
            Language::French => "Importation des jetons d'accès personnel...",
            Language::German => "Persönliche Zugriffstokens werden importiert...",
        }
    }

    pub fn available_models_header(&self) -> &str {
        match self.language {
            Language::English => "Available Models",
            Language::Chinese => "可用模型",
            Language::Japanese => "利用可能なモデル",
            Language::Korean => "사용 가능한 모델",
            Language::Spanish => "Modelos disponibles",
            Language::French => "Modèles disponibles",
            Language::German => "Verfügbare Modelle",
        }
    }

    pub fn current_model_value(&self) -> &str {
        match self.language {
            Language::English => "Current model:",
            Language::Chinese => "当前模型：",
            Language::Japanese => "現在のモデル:",
            Language::Korean => "현재 모델:",
            Language::Spanish => "Modelo actual:",
            Language::French => "Modèle actuel :",
            Language::German => "Aktuelles Modell:",
        }
    }

    pub fn testing_llm_header(&self) -> &str {
        match self.language {
            Language::English => "Testing LLM Connection...",
            Language::Chinese => "正在测试 LLM 连接...",
            Language::Japanese => "LLM接続をテスト中...",
            Language::Korean => "LLM 연결 테스트 중...",
            Language::Spanish => "Probando la conexión LLM...",
            Language::French => "Test de la connexion LLM...",
            Language::German => "LLM-Verbindung wird getestet...",
        }
    }

    pub fn sending_test_request(&self) -> &str {
        match self.language {
            Language::English => "Sending test request...",
            Language::Chinese => "正在发送测试请求...",
            Language::Japanese => "テストリクエストを送信中...",
            Language::Korean => "테스트 요청 보내는 중...",
            Language::Spanish => "Enviando solicitud de prueba...",
            Language::French => "Envoi de la requête de test...",
            Language::German => "Testanfrage wird gesendet...",
        }
    }

    pub fn response_header(&self) -> &str {
        match self.language {
            Language::English => "Response:",
            Language::Chinese => "响应：",
            Language::Japanese => "応答:",
            Language::Korean => "응답:",
            Language::Spanish => "Respuesta:",
            Language::French => "Réponse :",
            Language::German => "Antwort:",
        }
    }

    pub fn select_output_language_header(&self) -> &str {
        match self.language {
            Language::English => "Select Output Language:",
            Language::Chinese => "选择输出语言：",
            Language::Japanese => "出力言語を選択：",
            Language::Korean => "출력 언어 선택:",
            Language::Spanish => "Seleccione el idioma de salida:",
            Language::French => "Sélectionnez la langue de sortie :",
            Language::German => "Ausgabesprache auswählen:",
        }
    }

    pub fn invalid_value_use(&self, value: &str, allowed: &str) -> String {
        match self.language {
            Language::English => format!("Invalid value: '{}'. Use: {}", value, allowed),
            Language::Chinese => format!("无效值：'{}'。可用：{}", value, allowed),
            Language::Japanese => format!("無効な値: '{}'。使用可能: {}", value, allowed),
            Language::Korean => format!("잘못된 값: '{}'. 사용 가능: {}", value, allowed),
            Language::Spanish => format!("Valor no válido: '{}'. Use: {}", value, allowed),
            Language::French => format!("Valeur non valide : '{}'. Utilisez : {}", value, allowed),
            Language::German => format!("Ungültiger Wert: '{}'. Verwenden Sie: {}", value, allowed),
        }
    }

    pub fn invalid_format(&self, value: &str) -> String {
        match self.language {
            Language::English => {
                format!("Invalid format: {}. Use: conventional, commitlint", value)
            }
            Language::Chinese => format!("无效格式：{}。可用：conventional、commitlint", value),
            Language::Japanese => format!(
                "無効なフォーマット: {}。使用可能: conventional、commitlint",
                value
            ),
            Language::Korean => format!(
                "잘못된 형식: {}. 사용 가능: conventional, commitlint",
                value
            ),
            Language::Spanish => format!(
                "Formato no válido: {}. Use: conventional, commitlint",
                value
            ),
            Language::French => format!(
                "Format non valide : {}. Utilisez : conventional, commitlint",
                value
            ),
            Language::German => format!(
                "Ungültiges Format: {}. Verwenden Sie: conventional, commitlint",
                value
            ),
        }
    }

    pub fn unknown_config_key(&self, key: &str) -> String {
        match self.language {
            Language::English => format!("Unknown configuration key: {}", key),
            Language::Chinese => format!("未知配置键：{}", key),
            Language::Japanese => format!("不明な設定キー: {}", key),
            Language::Korean => format!("알 수 없는 구성 키: {}", key),
            Language::Spanish => format!("Clave de configuración desconocida: {}", key),
            Language::French => format!("Clé de configuration inconnue : {}", key),
            Language::German => format!("Unbekannter Konfigurationsschlüssel: {}", key),
        }
    }

    pub fn invalid_provider(&self, provider: &str, options: &str) -> String {
        match self.language {
            Language::English => {
                format!("Invalid provider: {}. Valid options: {}", provider, options)
            }
            Language::Chinese => format!("无效提供商：{}。可用选项：{}", provider, options),
            Language::Japanese => format!(
                "無効なプロバイダー: {}。有効なオプション: {}",
                provider, options
            ),
            Language::Korean => format!("잘못된 공급자: {}. 유효한 옵션: {}", provider, options),
            Language::Spanish => format!(
                "Proveedor no válido: {}. Opciones válidas: {}",
                provider, options
            ),
            Language::French => format!(
                "Fournisseur non valide : {}. Options valides : {}",
                provider, options
            ),
            Language::German => format!(
                "Ungültiger Anbieter: {}. Gültige Optionen: {}",
                provider, options
            ),
        }
    }

    pub fn passwords_do_not_match(&self) -> &str {
        match self.language {
            Language::English => "Passwords do not match",
            Language::Chinese => "两次输入的密码不一致",
            Language::Japanese => "パスワードが一致しません",
            Language::Korean => "비밀번호가 일치하지 않습니다",
            Language::Spanish => "Las contraseñas no coinciden",
            Language::French => "Les mots de passe ne correspondent pas",
            Language::German => "Passwörter stimmen nicht überein",
        }
    }

    pub fn password_requires_output(&self) -> &str {
        match self.language {
            Language::English => "--password requires --output",
            Language::Chinese => "--password 需要 --output",
            Language::Japanese => "--password には --output が必要です",
            Language::Korean => "--password에는 --output이 필요합니다",
            Language::Spanish => "--password requiere --output",
            Language::French => "--password nécessite --output",
            Language::German => "--password erfordert --output",
        }
    }

    pub fn keyring_unavailable_env_hint(&self) -> &str {
        match self.language {
            Language::English => {
                "Keyring is not available. Set QUICOMMIT_API_KEY environment variable instead or change api_key_storage to 'config'."
            }
            Language::Chinese => {
                "密钥环不可用。请改用 QUICOMMIT_API_KEY 环境变量，或将 api_key_storage 改为 'config'。"
            }
            Language::Japanese => {
                "キーリングが利用できません。代わりに QUICOMMIT_API_KEY 環境変数を設定するか、api_key_storage を 'config' に変更してください。"
            }
            Language::Korean => {
                "키링을 사용할 수 없습니다. 대신 QUICOMMIT_API_KEY 환경 변수를 설정하거나 api_key_storage를 'config'로 변경하세요."
            }
            Language::Spanish => {
                "El keyring no está disponible. Configure la variable QUICOMMIT_API_KEY o cambie api_key_storage a 'config'."
            }
            Language::French => {
                "Le trousseau n'est pas disponible. Définissez la variable QUICOMMIT_API_KEY ou passez api_key_storage à 'config'."
            }
            Language::German => {
                "Schlüsselbund nicht verfügbar. Setzen Sie die Umgebungsvariable QUICOMMIT_API_KEY oder ändern Sie api_key_storage auf 'config'."
            }
        }
    }

    pub fn keyring_unavailable_plain(&self) -> &str {
        match self.language {
            Language::English => "Keyring is not available.",
            Language::Chinese => "密钥环不可用。",
            Language::Japanese => "キーリングは利用できません。",
            Language::Korean => "키링을 사용할 수 없습니다.",
            Language::Spanish => "El keyring no está disponible.",
            Language::French => "Le trousseau n'est pas disponible.",
            Language::German => "Schlüsselbund ist nicht verfügbar.",
        }
    }

    pub fn api_key_env_storage_bail(&self, provider: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "API key storage set to 'environment'. Please set QUICOMMIT_{}_API_KEY environment variable.",
                    provider
                )
            }
            Language::Chinese => {
                format!(
                    "API 密钥存储方式为 'environment'。请设置 QUICOMMIT_{}_API_KEY 环境变量。",
                    provider
                )
            }
            Language::Japanese => {
                format!(
                    "APIキー保存方法が 'environment' です。QUICOMMIT_{}_API_KEY 環境変数を設定してください。",
                    provider
                )
            }
            Language::Korean => {
                format!(
                    "API 키 저장 방식이 'environment'입니다. QUICOMMIT_{}_API_KEY 환경 변수를 설정하세요.",
                    provider
                )
            }
            Language::Spanish => {
                format!(
                    "El almacenamiento de clave API está en 'environment'. Configure QUICOMMIT_{}_API_KEY.",
                    provider
                )
            }
            Language::French => {
                format!(
                    "Stockage de clé API défini sur 'environment'. Définissez QUICOMMIT_{}_API_KEY.",
                    provider
                )
            }
            Language::German => {
                format!(
                    "API-Schlüssel-Speicherung auf 'environment' gesetzt. Setzen Sie QUICOMMIT_{}_API_KEY.",
                    provider
                )
            }
        }
    }

    pub fn api_key_env_storage_info(&self, provider: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "API key storage set to 'environment'. Please remove QUICOMMIT_{}_API_KEY environment variable manually.",
                    provider
                )
            }
            Language::Chinese => {
                format!(
                    "API 密钥存储方式为 'environment'。请手动移除 QUICOMMIT_{}_API_KEY 环境变量。",
                    provider
                )
            }
            Language::Japanese => {
                format!(
                    "APIキー保存方法が 'environment' です。QUICOMMIT_{}_API_KEY 環境変数を手動で削除してください。",
                    provider
                )
            }
            Language::Korean => {
                format!(
                    "API 키 저장 방식이 'environment'입니다. QUICOMMIT_{}_API_KEY 환경 변수를 수동으로 제거하세요.",
                    provider
                )
            }
            Language::Spanish => {
                format!(
                    "El almacenamiento está en 'environment'. Elimine QUICOMMIT_{}_API_KEY manualmente.",
                    provider
                )
            }
            Language::French => {
                format!(
                    "Stockage défini sur 'environment'. Supprimez QUICOMMIT_{}_API_KEY manuellement.",
                    provider
                )
            }
            Language::German => {
                format!(
                    "Speicherung auf 'environment' gesetzt. Entfernen Sie QUICOMMIT_{}_API_KEY manuell.",
                    provider
                )
            }
        }
    }

    pub fn invalid_storage_method(&self, method: &str) -> String {
        match self.language {
            Language::English => format!("Invalid API key storage method: {}", method),
            Language::Chinese => format!("无效的 API 密钥存储方式：{}", method),
            Language::Japanese => format!("無効なAPIキー保存方法: {}", method),
            Language::Korean => format!("잘못된 API 키 저장 방식: {}", method),
            Language::Spanish => format!(
                "Método de almacenamiento de clave API no válido: {}",
                method
            ),
            Language::French => format!("Méthode de stockage de clé API non valide : {}", method),
            Language::German => format!("Ungültige API-Schlüssel-Speichermethode: {}", method),
        }
    }

    pub fn api_key_configured(&self) -> &str {
        match self.language {
            Language::English => "API Key: configured",
            Language::Chinese => "API 密钥：已配置",
            Language::Japanese => "APIキー: 設定済み",
            Language::Korean => "API 키: 구성됨",
            Language::Spanish => "Clave API: configurada",
            Language::French => "Clé API : configurée",
            Language::German => "API-Schlüssel: konfiguriert",
        }
    }

    pub fn api_key_not_set(&self) -> &str {
        match self.language {
            Language::English => "API Key: not set",
            Language::Chinese => "API 密钥：未设置",
            Language::Japanese => "APIキー: 未設定",
            Language::Korean => "API 키: 설정 안 됨",
            Language::Spanish => "Clave API: no establecida",
            Language::French => "Clé API : non définie",
            Language::German => "API-Schlüssel: nicht gesetzt",
        }
    }

    pub fn connection_successful(&self) -> &str {
        match self.language {
            Language::English => "Connection successful!",
            Language::Chinese => "连接成功！",
            Language::Japanese => "接続に成功しました！",
            Language::Korean => "연결 성공!",
            Language::Spanish => "¡Conexión exitosa!",
            Language::French => "Connexion réussie !",
            Language::German => "Verbindung erfolgreich!",
        }
    }

    pub fn llm_configuration_updated(&self) -> &str {
        match self.language {
            Language::English => "LLM configuration updated",
            Language::Chinese => "LLM 配置已更新",
            Language::Japanese => "LLM設定を更新しました",
            Language::Korean => "LLM 구성 업데이트됨",
            Language::Spanish => "Configuración LLM actualizada",
            Language::French => "Configuration LLM mise à jour",
            Language::German => "LLM-Konfiguration aktualisiert",
        }
    }

    pub fn api_key_stored_for(&self, provider: &str) -> String {
        match self.language {
            Language::English => {
                format!("API key stored securely in system keyring for {}", provider)
            }
            Language::Chinese => format!("API 密钥已安全存储在系统密钥环中（{}）", provider),
            Language::Japanese => format!(
                "APIキーをシステムキーリングに安全に保存しました（{}）",
                provider
            ),
            Language::Korean => format!("API 키가 시스템 키링에 안전하게 저장됨({})", provider),
            Language::Spanish => format!("Clave API almacenada de forma segura para {}", provider),
            Language::French => format!("Clé API stockée en toute sécurité pour {}", provider),
            Language::German => format!("API-Schlüssel sicher gespeichert für {}", provider),
        }
    }

    pub fn api_key_stored_config_for(&self, provider: &str) -> String {
        match self.language {
            Language::English => format!("API key stored in configuration file for {}", provider),
            Language::Chinese => format!("API 密钥已存储到配置文件中（{}）", provider),
            Language::Japanese => format!("APIキーを設定ファイルに保存しました（{}）", provider),
            Language::Korean => format!("API 키가 구성 파일에 저장됨({})", provider),
            Language::Spanish => format!(
                "Clave API almacenada en el archivo de configuración para {}",
                provider
            ),
            Language::French => format!(
                "Clé API stockée dans le fichier de configuration pour {}",
                provider
            ),
            Language::German => format!(
                "API-Schlüssel in Konfigurationsdatei gespeichert für {}",
                provider
            ),
        }
    }

    pub fn api_key_plain_text_note(&self) -> &str {
        match self.language {
            Language::English => {
                "Note: API key is stored in plain text. Consider using 'keyring' storage for better security."
            }
            Language::Chinese => {
                "注意：API 密钥以明文存储。为更安全考虑，建议使用 'keyring' 存储。"
            }
            Language::Japanese => {
                "注意：APIキーは平文で保存されています。より安全な 'keyring' 保存を検討してください。"
            }
            Language::Korean => {
                "참고: API 키가 평문으로 저장됩니다. 더 나은 보안을 위해 'keyring' 저장을 고려하세요."
            }
            Language::Spanish => {
                "Nota: la clave API se almacena en texto plano. Considere usar 'keyring' para mayor seguridad."
            }
            Language::French => {
                "Note : la clé API est stockée en clair. Envisagez le stockage 'keyring' pour plus de sécurité."
            }
            Language::German => {
                "Hinweis: API-Schlüssel wird im Klartext gespeichert. Für mehr Sicherheit 'keyring' verwenden."
            }
        }
    }

    pub fn api_key_deleted_keyring_for(&self, provider: &str) -> String {
        match self.language {
            Language::English => format!("API key deleted from system keyring for {}", provider),
            Language::Chinese => format!("已从系统密钥环删除 API 密钥（{}）", provider),
            Language::Japanese => format!(
                "APIキーをシステムキーリングから削除しました（{}）",
                provider
            ),
            Language::Korean => format!("API 키가 시스템 키링에서 삭제됨({})", provider),
            Language::Spanish => format!(
                "Clave API eliminada del keyring del sistema para {}",
                provider
            ),
            Language::French => format!("Clé API supprimée du trousseau système pour {}", provider),
            Language::German => format!(
                "API-Schlüssel aus dem Schlüsselbund gelöscht für {}",
                provider
            ),
        }
    }

    pub fn api_key_deleted_config_for(&self, provider: &str) -> String {
        match self.language {
            Language::English => {
                format!("API key deleted from configuration file for {}", provider)
            }
            Language::Chinese => format!("已从配置文件删除 API 密钥（{}）", provider),
            Language::Japanese => format!("APIキーを設定ファイルから削除しました（{}）", provider),
            Language::Korean => format!("API 키가 구성 파일에서 삭제됨({})", provider),
            Language::Spanish => format!(
                "Clave API eliminada del archivo de configuración para {}",
                provider
            ),
            Language::French => format!(
                "Clé API supprimée du fichier de configuration pour {}",
                provider
            ),
            Language::German => format!(
                "API-Schlüssel aus Konfigurationsdatei gelöscht für {}",
                provider
            ),
        }
    }

    pub fn commit_format_set(&self, format: &str) -> String {
        match self.language {
            Language::English => format!("Commit format set to {}", format),
            Language::Chinese => format!("提交格式已设置为 {}", format),
            Language::Japanese => format!("コミットフォーマットを {} に設定しました", format),
            Language::Korean => format!("커밋 형식이 {}로 설정됨", format),
            Language::Spanish => format!("Formato de commit establecido en {}", format),
            Language::French => format!("Format de commit défini sur {}", format),
            Language::German => format!("Commit-Format auf {} gesetzt", format),
        }
    }

    pub fn version_prefix_set(&self, prefix: &str) -> String {
        match self.language {
            Language::English => format!("Version prefix set to '{}'", prefix),
            Language::Chinese => format!("版本前缀已设置为 '{}'", prefix),
            Language::Japanese => format!("バージョンプレフィックスを '{}' に設定しました", prefix),
            Language::Korean => format!("버전 접두사가 '{}'(으)로 설정됨", prefix),
            Language::Spanish => format!("Prefijo de versión establecido en '{}'", prefix),
            Language::French => format!("Préfixe de version défini sur '{}'", prefix),
            Language::German => format!("Versionspräfix auf '{}' gesetzt", prefix),
        }
    }

    pub fn changelog_path_set(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Changelog path set to {}", path),
            Language::Chinese => format!("变更日志路径已设置为 {}", path),
            Language::Japanese => format!("変更ログパスを {} に設定しました", path),
            Language::Korean => format!("변경 로그 경로가 {}로 설정됨", path),
            Language::Spanish => format!("Ruta del changelog establecida en {}", path),
            Language::French => format!("Chemin du changelog défini sur {}", path),
            Language::German => format!("Changelog-Pfad auf {} gesetzt", path),
        }
    }

    pub fn output_language_set(&self, code: &str) -> String {
        match self.language {
            Language::English => format!("Output language set to {}", code),
            Language::Chinese => format!("输出语言已设置为 {}", code),
            Language::Japanese => format!("出力言語を {} に設定しました", code),
            Language::Korean => format!("출력 언어가 {}로 설정됨", code),
            Language::Spanish => format!("Idioma de salida establecido en {}", code),
            Language::French => format!("Langue de sortie définie sur {}", code),
            Language::German => format!("Ausgabesprache auf {} gesetzt", code),
        }
    }

    pub fn keep_types_english_set(&self, keep: bool) -> String {
        match self.language {
            Language::English => format!("Keep commit types in English: {}", keep),
            Language::Chinese => format!("保持提交类型为英文：{}", keep),
            Language::Japanese => format!("コミットタイプを英語のままにする: {}", keep),
            Language::Korean => format!("커밋 유형을 영어로 유지: {}", keep),
            Language::Spanish => format!("Mantener tipos de commit en inglés: {}", keep),
            Language::French => format!("Conserver les types de commit en anglais : {}", keep),
            Language::German => format!("Commit-Typen auf Englisch belassen: {}", keep),
        }
    }

    pub fn keep_changelog_types_english_set(&self, keep: bool) -> String {
        match self.language {
            Language::English => format!("Keep changelog types in English: {}", keep),
            Language::Chinese => format!("保持变更日志类型为英文：{}", keep),
            Language::Japanese => format!("変更ログタイプを英語のままにする: {}", keep),
            Language::Korean => format!("변경 로그 유형을 영어로 유지: {}", keep),
            Language::Spanish => format!("Mantener tipos de changelog en inglés: {}", keep),
            Language::French => format!("Conserver les types de changelog en anglais : {}", keep),
            Language::German => format!("Changelog-Typen auf Englisch belassen: {}", keep),
        }
    }

    pub fn configuration_reset_done(&self) -> &str {
        match self.language {
            Language::English => "Configuration reset to defaults",
            Language::Chinese => "配置已重置为默认值",
            Language::Japanese => "設定をデフォルトにリセットしました",
            Language::Korean => "구성이 기본값으로 재설정됨",
            Language::Spanish => "Configuración restablecida a los valores predeterminados",
            Language::French => "Configuration réinitialisée aux valeurs par défaut",
            Language::German => "Konfiguration auf Standardwerte zurückgesetzt",
        }
    }

    pub fn export_warning_no_encryption(&self) -> &str {
        match self.language {
            Language::English => "WARNING: Exporting without encryption.",
            Language::Chinese => "警告：正在以未加密方式导出。",
            Language::Japanese => "警告：暗号化なしでエクスポートしています。",
            Language::Korean => "경고: 암호화 없이 내보내는 중입니다.",
            Language::Spanish => "ADVERTENCIA: Exportando sin cifrado.",
            Language::French => "AVERTISSEMENT : exportation sans chiffrement.",
            Language::German => "WARNUNG: Export ohne Verschlüsselung.",
        }
    }

    pub fn export_pats_not_included(&self) -> &str {
        match self.language {
            Language::English => {
                "Personal Access Tokens (PATs) stored in keyring will NOT be exported."
            }
            Language::Chinese => "存储在密钥环中的个人访问令牌（PAT）将不会被导出。",
            Language::Japanese => {
                "キーリングに保存された個人アクセストークン（PAT）はエクスポートされません。"
            }
            Language::Korean => "키링에 저장된 개인 액세스 토큰(PAT)은 내보내지지 않습니다.",
            Language::Spanish => {
                "Los tokens de acceso personal (PAT) almacenados en el keyring NO se exportarán."
            }
            Language::French => {
                "Les jetons d'accès personnel (PAT) stockés dans le trousseau ne seront PAS exportés."
            }
            Language::German => {
                "Im Schlüsselbund gespeicherte persönliche Zugriffstokens (PATs) werden NICHT exportiert."
            }
        }
    }

    pub fn export_enable_encryption_hint(&self) -> &str {
        match self.language {
            Language::English => "To export PATs securely, please enable encryption.",
            Language::Chinese => "如需安全导出 PAT，请启用加密。",
            Language::Japanese => "PATを安全にエクスポートするには、暗号化を有効にしてください。",
            Language::Korean => "PAT을 안전하게 내보내려면 암호화를 활성화하세요.",
            Language::Spanish => "Para exportar PAT de forma segura, habilite el cifrado.",
            Language::French => "Pour exporter les PAT en toute sécurité, activez le chiffrement.",
            Language::German => {
                "Um PATs sicher zu exportieren, aktivieren Sie die Verschlüsselung."
            }
        }
    }

    pub fn export_plain_pat_warning(&self) -> &str {
        match self.language {
            Language::English => {
                "WARNING: Plain export does not include PATs stored in keyring. \
                 Use --output with --password to export them encrypted."
            }
            Language::Chinese => {
                "警告：明文导出不包含密钥环中存储的 PAT。\
                 使用 --output 与 --password 加密导出。"
            }
            Language::Japanese => {
                "警告：平文エクスポートにはキーリングのPATは含まれません。\
                 暗号化してエクスポートするには --output と --password を使用してください。"
            }
            Language::Korean => {
                "경고: 평문 내보내기에는 키링에 저장된 PAT이 포함되지 않습니다. \
                 암호화하여 내보내려면 --output과 --password를 사용하세요."
            }
            Language::Spanish => {
                "ADVERTENCIA: la exportación en texto plano no incluye PAT del keyring. \
                 Use --output con --password para exportarlos cifrados."
            }
            Language::French => {
                "AVERTISSEMENT : l'export en clair n'inclut pas les PAT du trousseau. \
                 Utilisez --output avec --password pour les exporter chiffrés."
            }
            Language::German => {
                "WARNUNG: Klartext-Export enthält keine PATs aus dem Schlüsselbund. \
                 Verwenden Sie --output mit --password für verschlüsselten Export."
            }
        }
    }

    pub fn configuration_encrypted_exported(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Configuration encrypted and exported to {}", path),
            Language::Chinese => format!("配置已加密并导出到 {}", path),
            Language::Japanese => format!("設定を暗号化して {} にエクスポートしました", path),
            Language::Korean => format!("구성이 암호화되어 {}로 내보내짐", path),
            Language::Spanish => format!("Configuración cifrada y exportada a {}", path),
            Language::French => format!("Configuration chiffrée et exportée vers {}", path),
            Language::German => format!("Konfiguration verschlüsselt und exportiert nach {}", path),
        }
    }

    pub fn configuration_exported(&self, path: &str) -> String {
        match self.language {
            Language::English => format!("Configuration exported to {}", path),
            Language::Chinese => format!("配置已导出到 {}", path),
            Language::Japanese => format!("設定を {} にエクスポートしました", path),
            Language::Korean => format!("구성이 {}로 내보내짐", path),
            Language::Spanish => format!("Configuración exportada a {}", path),
            Language::French => format!("Configuration exportée vers {}", path),
            Language::German => format!("Konfiguration exportiert nach {}", path),
        }
    }

    pub fn configuration_imported(&self, file: &str) -> String {
        match self.language {
            Language::English => format!("Configuration imported from {}", file),
            Language::Chinese => format!("已从 {} 导入配置", file),
            Language::Japanese => format!("{} から設定をインポートしました", file),
            Language::Korean => format!("{}에서 구성 가져옴", file),
            Language::Spanish => format!("Configuración importada desde {}", file),
            Language::French => format!("Configuration importée depuis {}", file),
            Language::German => format!("Konfiguration importiert aus {}", file),
        }
    }

    pub fn token_imported_to_keyring(&self, profile: &str, service: &str) -> String {
        match self.language {
            Language::English => {
                format!("Token for {} ({}) imported to keyring", profile, service)
            }
            Language::Chinese => format!("{}（{}）的令牌已导入密钥环", profile, service),
            Language::Japanese => format!(
                "{}（{}）のトークンをキーリングにインポートしました",
                profile, service
            ),
            Language::Korean => format!("{}({})용 토큰이 키링으로 가져와짐", profile, service),
            Language::Spanish => format!("Token de {} ({}) importado al keyring", profile, service),
            Language::French => format!(
                "Jeton de {} ({}) importé dans le trousseau",
                profile, service
            ),
            Language::German => format!(
                "Token für {} ({}) in den Schlüsselbund importiert",
                profile, service
            ),
        }
    }

    pub fn failed_store_token(&self, profile: &str, service: &str) -> String {
        match self.language {
            Language::English => format!("Failed to store token for {} ({})", profile, service),
            Language::Chinese => format!("存储 {}（{}）的令牌失败", profile, service),
            Language::Japanese => {
                format!("{}（{}）のトークンの保存に失敗しました", profile, service)
            }
            Language::Korean => format!("{}({})용 토큰 저장 실패", profile, service),
            Language::Spanish => {
                format!("No se pudo almacenar el token de {} ({})", profile, service)
            }
            Language::French => format!("Échec du stockage du jeton de {} ({})", profile, service),
            Language::German => format!(
                "Token für {} ({}) konnte nicht gespeichert werden",
                profile, service
            ),
        }
    }

    pub fn keyring_unavailable_token_import(&self, profile: &str, service: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "Keyring not available, cannot store token for {} ({})",
                    profile, service
                )
            }
            Language::Chinese => format!("密钥环不可用，无法存储 {}（{}）的令牌", profile, service),
            Language::Japanese => format!(
                "キーリングが利用できないため、{}（{}）のトークンを保存できません",
                profile, service
            ),
            Language::Korean => format!(
                "키링을 사용할 수 없어 {}({})용 토큰을 저장할 수 없습니다",
                profile, service
            ),
            Language::Spanish => {
                format!(
                    "Keyring no disponible, no se puede almacenar el token de {} ({})",
                    profile, service
                )
            }
            Language::French => {
                format!(
                    "Trousseau indisponible, impossible de stocker le jeton de {} ({})",
                    profile, service
                )
            }
            Language::German => {
                format!(
                    "Schlüsselbund nicht verfügbar, Token für {} ({}) kann nicht gespeichert werden",
                    profile, service
                )
            }
        }
    }

    pub fn invalid_token_format(&self, profile: &str, service: &str) -> String {
        match self.language {
            Language::English => format!("Invalid token format for {} ({})", profile, service),
            Language::Chinese => format!("{}（{}）的令牌格式无效", profile, service),
            Language::Japanese => format!("{}（{}）のトークン形式が無効です", profile, service),
            Language::Korean => format!("{}({})의 토큰 형식이 잘못됨", profile, service),
            Language::Spanish => {
                format!("Formato de token no válido para {} ({})", profile, service)
            }
            Language::French => {
                format!("Format de jeton non valide pour {} ({})", profile, service)
            }
            Language::German => format!("Ungültiges Token-Format für {} ({})", profile, service),
        }
    }

    pub fn failed_decrypt_token(&self, profile: &str, service: &str) -> String {
        match self.language {
            Language::English => format!("Failed to decrypt token for {} ({})", profile, service),
            Language::Chinese => format!("解密 {}（{}）的令牌失败", profile, service),
            Language::Japanese => {
                format!("{}（{}）のトークンの復号に失敗しました", profile, service)
            }
            Language::Korean => format!("{}({})용 토큰 복호화 실패", profile, service),
            Language::Spanish => {
                format!("No se pudo descifrar el token de {} ({})", profile, service)
            }
            Language::French => format!(
                "Échec du déchiffrement du jeton de {} ({})",
                profile, service
            ),
            Language::German => format!(
                "Token für {} ({}) konnte nicht entschlüsselt werden",
                profile, service
            ),
        }
    }

    pub fn tokens_imported_count(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("{} token(s) imported to keyring", count),
            Language::Chinese => format!("已将 {} 个令牌导入密钥环", count),
            Language::Japanese => format!("{} 個のトークンをキーリングにインポートしました", count),
            Language::Korean => format!("토큰 {}개를 키링으로 가져옴", count),
            Language::Spanish => format!("{} token(s) importados al keyring", count),
            Language::French => format!("{} jeton(s) importés dans le trousseau", count),
            Language::German => format!("{} Token(s) in den Schlüsselbund importiert", count),
        }
    }

    pub fn tokens_failed_count(&self, count: usize) -> String {
        match self.language {
            Language::English => format!("{} token(s) failed to import", count),
            Language::Chinese => format!("{} 个令牌导入失败", count),
            Language::Japanese => format!("{} 個のトークンのインポートに失敗しました", count),
            Language::Korean => format!("토큰 {}개 가져오기 실패", count),
            Language::Spanish => format!("{} token(s) no se pudieron importar", count),
            Language::French => format!("{} jeton(s) n'ont pas pu être importés", count),
            Language::German => format!("{} Token(s) konnten nicht importiert werden", count),
        }
    }

    pub fn failed_decrypt_config(&self, error: &str) -> String {
        match self.language {
            Language::English => {
                format!(
                    "Failed to decrypt configuration: {}. Please check your password.",
                    error
                )
            }
            Language::Chinese => format!("配置解密失败：{}。请检查你的密码。", error),
            Language::Japanese => {
                format!(
                    "設定の復号に失敗しました: {}。パスワードを確認してください。",
                    error
                )
            }
            Language::Korean => format!("구성 복호화 실패: {}. 비밀번호를 확인하세요.", error),
            Language::Spanish => {
                format!(
                    "No se pudo descifrar la configuración: {}. Compruebe su contraseña.",
                    error
                )
            }
            Language::French => {
                format!(
                    "Échec du déchiffrement de la configuration : {}. Vérifiez votre mot de passe.",
                    error
                )
            }
            Language::German => {
                format!(
                    "Konfiguration konnte nicht entschlüsselt werden: {}. Bitte Passwort prüfen.",
                    error
                )
            }
        }
    }
}