//! Strings for the pull request conversation, Files tab review threads and review routes.
//! See `docs` in `super` for the pattern.

use std::fmt::Display;

use super::Lang;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum K {
    StateMerged,
    StateOpen,
    StateClosed,
    Unknown,
    ByWantsToMerge,
    ByInto,
    ByFrom,
    BylineEnd,
    TabConversation,
    PullPages,
    MergeClean,
    MergeConflict,
    MergeUpToDate,
    MergeChecking,
    ReloadToCheck,
    MergeStyleLegend,
    StyleMergeCommit,
    StyleSquash,
    StyleFastForward,
    MergeMessageLabel,
    MergeButton,
    MergedByPrefix,
    MergedByMiddle,
    MergedAsSep,
    DismissButton,
    ArchivedReadOnly,
    LoginBefore,
    LoginLink,
    LoginAfter,
    MergedCannotChange,
    NoCommits,
    Committed,
    BrowseFiles,
    ErrConflict,
    ErrUpToDate,
    ErrFfImpossible,
    ErrBaseMoved,
    ErrAlreadyMerged,
    ErrNotOpen,
    ErrHeadMissing,
    ErrBaseMissing,
    ErrNeedsApprovals,
    ErrChangesRequested,
    ErrNotUpToDate,
    ErrMessageInvalid,
    ReviewErrStale,
    ReviewErrOwnPr,
    ReviewErrEmpty,
    ReviewErrInvalid,
    ReviewErrBadLine,
    ReviewErrClosed,
    EditReviewComment,
    CommentLabel,
    SaveComment,
    CancelButton,
    Unresolve,
    Resolve,
    Outdated,
    Pending,
    ReplyLabel,
    ReplyButton,
    Edited,
    EditLink,
    DeleteButton,
}

pub fn t(lang: Lang, key: K) -> &'static str {
    use K::*;
    use Lang::{En, Tr};
    match (key, lang) {
        (StateMerged, En) => "Merged",
        (StateMerged, Tr) => "Birleştirildi",
        (StateOpen, En) => "Open",
        (StateOpen, Tr) => "Açık",
        (StateClosed, En) => "Closed",
        (StateClosed, Tr) => "Kapalı",
        (Unknown, En) => "unknown",
        (Unknown, Tr) => "bilinmiyor",
        (ByWantsToMerge, En) => " wants to merge ",
        (ByWantsToMerge, Tr) => ", ",
        (ByInto, En) => " into ",
        (ByInto, Tr) => " dalına ",
        (ByFrom, En) => " from ",
        (ByFrom, Tr) => " dalından ",
        (BylineEnd, En) => " · ",
        (BylineEnd, Tr) => " birleştirmek istiyor · ",
        (TabConversation, En) => "Conversation",
        (TabConversation, Tr) => "Tartışma",
        (PullPages, En) => "Pull request pages",
        (PullPages, Tr) => "Çekme isteği sayfaları",
        (MergeClean, En) => "This branch has no conflicts with the base branch",
        (MergeClean, Tr) => "Bu dalın taban dalla çakışması yok",
        (MergeConflict, En) => "This branch has conflicts that must be resolved",
        (MergeConflict, Tr) => "Bu dalda çözülmesi gereken çakışmalar var",
        (MergeUpToDate, En) => "This branch is already up to date with base",
        (MergeUpToDate, Tr) => "Bu dal zaten taban dalla güncel",
        (MergeChecking, En) => "Checking mergeability\u{2026}",
        (MergeChecking, Tr) => "Birleştirilebilirlik kontrol ediliyor\u{2026}",
        (ReloadToCheck, En) => "Reload to check again",
        (ReloadToCheck, Tr) => "Yeniden kontrol etmek için sayfayı yenileyin",
        (MergeStyleLegend, En) => "Merge style",
        (MergeStyleLegend, Tr) => "Birleştirme yöntemi",
        (StyleMergeCommit, En) => " Create a merge commit",
        (StyleMergeCommit, Tr) => " Birleştirme commit’i oluştur",
        (StyleSquash, En) => " Squash and merge",
        (StyleSquash, Tr) => " Sıkıştır ve birleştir",
        (StyleFastForward, En) => " Fast-forward",
        (StyleFastForward, Tr) => " İleri sarma (fast-forward)",
        (MergeMessageLabel, En) => "Merge commit message (optional)",
        (MergeMessageLabel, Tr) => "Birleştirme commit mesajı (isteğe bağlı)",
        (MergeButton, En) => "Merge pull request",
        (MergeButton, Tr) => "Çekme isteğini birleştir",
        (MergedByPrefix, En) => "Merged by ",
        (MergedByPrefix, Tr) => "Birleştiren: ",
        (MergedByMiddle, En) => " ",
        (MergedByMiddle, Tr) => " · ",
        (MergedAsSep, En) => " as ",
        (MergedAsSep, Tr) => " · commit ",
        (DismissButton, En) => "Dismiss",
        (DismissButton, Tr) => "Yok say",
        (ArchivedReadOnly, En) => {
            "This repository is archived, so its pull requests are read-only."
        }
        (ArchivedReadOnly, Tr) => "Bu depo arşivlendiği için çekme istekleri salt okunurdur.",
        (LoginBefore, En) => "",
        (LoginBefore, Tr) => "Yorum yazmak için ",
        (LoginLink, En) => "Log in",
        (LoginLink, Tr) => "giriş yapın",
        (LoginAfter, En) => " to comment.",
        (LoginAfter, Tr) => ".",
        (MergedCannotChange, En) => "A merged pull request cannot change state.",
        (MergedCannotChange, Tr) => "Birleştirilmiş bir çekme isteğinin durumu değiştirilemez.",
        (NoCommits, En) => "No commits.",
        (NoCommits, Tr) => "Commit yok.",
        (Committed, En) => "committed",
        (Committed, Tr) => "işledi",
        (BrowseFiles, En) => "Browse files",
        (BrowseFiles, Tr) => "Dosyalara göz at",
        (ErrConflict, En) => {
            "This branch has conflicts that must be resolved. Resolve them on the branch, then try again."
        }
        (ErrConflict, Tr) => {
            "Bu dalda çözülmesi gereken çakışmalar var. Çakışmaları dalda çözün, sonra yeniden deneyin."
        }
        (ErrUpToDate, En) => {
            "There is nothing to merge: this branch is already contained in the base branch."
        }
        (ErrUpToDate, Tr) => {
            "Birleştirilecek bir şey yok: bu dal zaten taban dalın içinde yer alıyor."
        }
        (ErrFfImpossible, En) => {
            "A fast-forward is not possible because the base branch has commits this branch does not contain. Choose a merge commit or a squash instead."
        }
        (ErrFfImpossible, Tr) => {
            "Taban dalda bu dalda bulunmayan commitler olduğu için ileri sarma yapılamaz. Bunun yerine birleştirme commit’i veya sıkıştırma seçin."
        }
        (ErrBaseMoved, En) => {
            "The base branch changed while you were merging. Reload this page and try again."
        }
        (ErrBaseMoved, Tr) => {
            "Birleştirme sırasında taban dal değişti. Bu sayfayı yenileyip yeniden deneyin."
        }
        (ErrAlreadyMerged, En) => "This pull request is already merged.",
        (ErrAlreadyMerged, Tr) => "Bu çekme isteği zaten birleştirilmiş.",
        (ErrNotOpen, En) => "This pull request is closed, so it cannot be merged.",
        (ErrNotOpen, Tr) => "Bu çekme isteği kapalı olduğu için birleştirilemez.",
        (ErrHeadMissing, En) => {
            "The head repository was deleted, so this pull request cannot be merged."
        }
        (ErrHeadMissing, Tr) => "Kaynak depo silindiği için bu çekme isteği birleştirilemez.",
        (ErrBaseMissing, En) => "The base branch does not exist.",
        (ErrBaseMissing, Tr) => "Taban dal mevcut değil.",
        (ErrNeedsApprovals, En) => {
            "This branch needs more approvals from reviewers with Write access before it can be merged."
        }
        (ErrNeedsApprovals, Tr) => {
            "Bu dalın birleştirilmesi için yazma yetkisi olan inceleyenlerden daha fazla onay gerekiyor."
        }
        (ErrChangesRequested, En) => {
            "Changes have been requested, so this branch cannot be merged until they are resolved."
        }
        (ErrChangesRequested, Tr) => {
            "Değişiklik istendiği için bu dal, istenen değişiklikler çözülene kadar birleştirilemez."
        }
        (ErrNotUpToDate, En) => {
            "The pull request head must contain the latest base branch before it can be merged. Update the branch, then try again."
        }
        (ErrNotUpToDate, Tr) => {
            "Çekme isteğinin kaynak dalı, birleştirilmeden önce en son taban dalı içermelidir. Dalı güncelleyip yeniden deneyin."
        }
        (ErrMessageInvalid, En) => {
            "The merge message is longer than 64 KiB or contains a NUL byte. Shorten it and try again."
        }
        (ErrMessageInvalid, Tr) => {
            "Birleştirme mesajı 64 KiB’tan uzun veya NUL karakteri içeriyor. Kısaltıp yeniden deneyin."
        }
        (ReviewErrStale, En) => "The pull request changed. Reload the page and try again.",
        (ReviewErrStale, Tr) => "Çekme isteği değişti. Sayfayı yenileyip yeniden deneyin.",
        (ReviewErrOwnPr, En) => "You cannot approve or request changes on your own pull request.",
        (ReviewErrOwnPr, Tr) => {
            "Kendi çekme isteğinizi onaylayamaz veya üzerinde değişiklik isteyemezsiniz."
        }
        (ReviewErrEmpty, En) => "Write a comment before you submit.",
        (ReviewErrEmpty, Tr) => "Göndermeden önce bir yorum yazın.",
        (ReviewErrInvalid, En) => "That comment could not be saved.",
        (ReviewErrInvalid, Tr) => "Bu yorum kaydedilemedi.",
        (ReviewErrBadLine, En) => {
            "That line is not part of this diff any more. Reload the page and try again."
        }
        (ReviewErrBadLine, Tr) => {
            "Bu satır artık bu farkın parçası değil. Sayfayı yenileyip yeniden deneyin."
        }
        (ReviewErrClosed, En) => "This pull request is closed, so new reviews cannot be submitted.",
        (ReviewErrClosed, Tr) => {
            "Bu çekme isteği kapalı olduğu için yeni incelemeler gönderilemez."
        }
        (EditReviewComment, En) => "Edit review comment",
        (EditReviewComment, Tr) => "İnceleme yorumunu düzenle",
        (CommentLabel, En) => "Comment",
        (CommentLabel, Tr) => "Yorum",
        (SaveComment, En) => "Save comment",
        (SaveComment, Tr) => "Yorumu kaydet",
        (CancelButton, En) => "Cancel",
        (CancelButton, Tr) => "İptal",
        (Unresolve, En) => "Unresolve",
        (Unresolve, Tr) => "Çözümü geri al",
        (Resolve, En) => "Resolve",
        (Resolve, Tr) => "Çözüldü olarak işaretle",
        (Outdated, En) => "Outdated",
        (Outdated, Tr) => "Güncel değil",
        (Pending, En) => "Pending",
        (Pending, Tr) => "Bekliyor",
        (ReplyLabel, En) => "Reply",
        (ReplyLabel, Tr) => "Yanıt",
        (ReplyButton, En) => "Reply",
        (ReplyButton, Tr) => "Yanıtla",
        (Edited, En) => "edited",
        (Edited, Tr) => "düzenlendi",
        (EditLink, En) => "Edit",
        (EditLink, Tr) => "Düzenle",
        (DeleteButton, En) => "Delete",
        (DeleteButton, Tr) => "Sil",
    }
}

/// "1 commit", "3 commits"; Turkish does not pluralise after a number.
pub fn commit_count_line(lang: Lang, count: usize) -> String {
    match lang {
        Lang::En if count == 1 => "1 commit".to_owned(),
        Lang::En => format!("{count} commits"),
        Lang::Tr => format!("{count} commit’i"),
    }
}

/// The Commits sub-tab label with its count.
pub fn commits_tab(lang: Lang, count: usize) -> String {
    match lang {
        Lang::En => format!("Commits {count}"),
        Lang::Tr => format!("Commitler {count}"),
    }
}

/// The Files changed sub-tab label with its count.
pub fn files_tab(lang: Lang, count: usize) -> String {
    match lang {
        Lang::En => format!("Files changed {count}"),
        Lang::Tr => format!("Değişen dosyalar {count}"),
    }
}

/// A head branch whose repository was deleted.
pub fn branch_deleted(lang: Lang, branch: &str) -> String {
    match lang {
        Lang::En => format!("{branch} (deleted)"),
        Lang::Tr => format!("{branch} (silinmiş)"),
    }
}

/// "2 of 3 required approvals".
pub fn approvals_of(lang: Lang, have: impl Display, need: impl Display) -> String {
    match lang {
        Lang::En => format!("{have} of {need} required approvals"),
        Lang::Tr => format!("{have} / {need} gerekli onay"),
    }
}

/// "Approved by Ada, Lin".
pub fn approved_by(lang: Lang, names: &str) -> String {
    match lang {
        Lang::En => format!("Approved by {names}"),
        Lang::Tr => format!("{names} tarafından onaylandı"),
    }
}

/// "Changes requested by Ada".
pub fn changes_requested_by(lang: Lang, names: &str) -> String {
    match lang {
        Lang::En => format!("Changes requested by {names}"),
        Lang::Tr => format!("{names} tarafından değişiklik istendi"),
    }
}

/// The label of the reason field on a Dismiss form.
pub fn dismiss_reason(lang: Lang, author: &str) -> String {
    match lang {
        Lang::En => format!("Reason for dismissing {author}'s review"),
        Lang::Tr => format!("{author} adlı kullanıcının incelemesini yok saymanın nedeni"),
    }
}

/// The summary of a resolved thread, naming its `path:line`.
pub fn resolved_conversation(lang: Lang, location: &str) -> String {
    match lang {
        Lang::En => format!("Resolved conversation on {location}"),
        Lang::Tr => format!("{location} konumundaki tartışma çözüldü"),
    }
}

/// The page title of the edit form for a review comment on a pull request.
pub fn edit_title(lang: Lang, number: i64, repo: &str) -> String {
    match lang {
        Lang::En => format!("Edit review comment on #{number} \u{b7} {repo}"),
        Lang::Tr => {
            format!("#{number} numaralı çekme isteğindeki inceleme yorumunu düzenle \u{b7} {repo}")
        }
    }
}

#[cfg(test)]
pub const ALL: &[K] = &[
    K::StateMerged,
    K::StateOpen,
    K::StateClosed,
    K::Unknown,
    K::ByWantsToMerge,
    K::ByInto,
    K::ByFrom,
    K::BylineEnd,
    K::TabConversation,
    K::PullPages,
    K::MergeClean,
    K::MergeConflict,
    K::MergeUpToDate,
    K::MergeChecking,
    K::ReloadToCheck,
    K::MergeStyleLegend,
    K::StyleMergeCommit,
    K::StyleSquash,
    K::StyleFastForward,
    K::MergeMessageLabel,
    K::MergeButton,
    K::MergedByPrefix,
    K::MergedByMiddle,
    K::MergedAsSep,
    K::DismissButton,
    K::ArchivedReadOnly,
    K::LoginBefore,
    K::LoginLink,
    K::LoginAfter,
    K::MergedCannotChange,
    K::NoCommits,
    K::Committed,
    K::BrowseFiles,
    K::ErrConflict,
    K::ErrUpToDate,
    K::ErrFfImpossible,
    K::ErrBaseMoved,
    K::ErrAlreadyMerged,
    K::ErrNotOpen,
    K::ErrHeadMissing,
    K::ErrBaseMissing,
    K::ErrNeedsApprovals,
    K::ErrChangesRequested,
    K::ErrNotUpToDate,
    K::ErrMessageInvalid,
    K::ReviewErrStale,
    K::ReviewErrOwnPr,
    K::ReviewErrEmpty,
    K::ReviewErrInvalid,
    K::ReviewErrBadLine,
    K::ReviewErrClosed,
    K::EditReviewComment,
    K::CommentLabel,
    K::SaveComment,
    K::CancelButton,
    K::Unresolve,
    K::Resolve,
    K::Outdated,
    K::Pending,
    K::ReplyLabel,
    K::ReplyButton,
    K::Edited,
    K::EditLink,
    K::DeleteButton,
];

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn every_key_has_english_and_turkish() {
        for key in ALL {
            // The English lead before a login link is empty by design.
            if *key != K::LoginBefore {
                assert!(!t(Lang::En, *key).is_empty(), "{key:?} has no English");
            }
            assert!(!t(Lang::Tr, *key).is_empty(), "{key:?} has no Turkish");
        }
    }

    #[test]
    fn turkish_differs_from_english_for_translated_keys() {
        let differing = ALL
            .iter()
            .filter(|key| t(Lang::En, **key) != t(Lang::Tr, **key))
            .count();
        assert!(differing >= 3, "only {differing} keys differ");
        assert_eq!(t(Lang::En, K::StateOpen), "Open");
        assert_eq!(t(Lang::Tr, K::StateOpen), "Açık");
    }

    #[test]
    fn counted_helpers_match_english_text() {
        assert_eq!(commit_count_line(Lang::En, 1), "1 commit");
        assert_eq!(commit_count_line(Lang::En, 3), "3 commits");
        assert_eq!(commits_tab(Lang::En, 4), "Commits 4");
        assert_eq!(files_tab(Lang::En, 2), "Files changed 2");
        assert_eq!(approvals_of(Lang::En, 1, 2), "1 of 2 required approvals");
        assert_eq!(commit_count_line(Lang::Tr, 3), "3 commit’i");
    }
}