module Common.Message.Translation
  ( get
  ) where

import           Data.Text           (Text)
import qualified Data.Text           as T

import           Common.Message.Key
import           Common.Message.Lang (Lang (..))

get :: Lang -> Key -> Text
get = m

m :: Lang -> Key -> Text

m l App_Title =
  case l of
    English -> "Shared Cost"
    French  -> "Partage des frais"

m l Category_Add =
  case l of
    English -> "Add an category"
    French  -> "Ajouter une catégorie"

m l Category_Clone =
  case l of
    English -> "Clone an category"
    French  -> "Cloner une catégorie"

m l Category_Color =
  case l of
    English -> "Color"
    French  -> "Couleur"

m l Category_DeleteConfirm =
  case l of
    English -> "Are you sure to delete this category ?"
    French  -> "Voulez-vous vraiment supprimer cette catégorie ?"

m l Category_Edit =
  case l of
    English -> "Edit an category"
    French  -> "Modifier une catégorie"

m l Category_Empty =
  case l of
    English -> "No category."
    French  -> "Aucune catégorie."

m l Category_Name =
  case l of
    English -> "Name"
    French  -> "Nom"

m l Category_NotDeleted =
  case l of
    English -> "The category could not have been deleted."
    French  -> "La catégorie n’a pas pu être supprimé."

m l Category_Title =
  case l of
    English -> "Categories"
    French  -> "Catégories"

m l Category_Used =
  case l of
    English -> "This category is currently being used"
    French  -> "Cette catégorie est actuellement utilisée"

m l (Date_Short day month year) =
  case l of
    English ->
      T.intercalate "-" [ padded year 4, padded month 2, padded day 2 ]
    French ->
      T.intercalate "/" [ padded day 2, padded month 2, padded year 4 ]
  where padded num pad =
          let str = show num
          in  T.pack $ replicate (pad - length str) '0' ++ str

m l (Date_ShortMonthAndYear month year) =
  case l of
    English ->
      T.intercalate "-" . map (T.pack . show) $ [ year, month ]
    French ->
      T.intercalate "/" . map (T.pack . show) $ [ month, year ]

m l (Date_Long day month year) =
  case l of
    English ->
      T.concat [ month, " " , T.pack . show $ day, ", ", T.pack . show $ year ]
    French ->
      T.intercalate " " [ T.pack . show $ day, month, T.pack . show $ year ]

m l Dialog_Confirm =
  case l of
    English -> "Confirm"
    French  -> "Confirmer"

m l Dialog_Undo =
  case l of
    English -> "Undo"
    French  -> "Annuler"

m l Error_CategoryCreate =
  case l of
    English -> "Error at category creation"
    French  -> "Erreur lors de la création de la catégorie"

m l Error_CategoryDelete =
  case l of
    English -> "Error at category deletion"
    French  -> "Erreur lors de la suppression de la catégorie"

m l Error_CategoryEdit =
  case l of
    English -> "Error at category edition"
    French  -> "Erreur lors de la modification de la catégorie"

m l Error_IncomeCreate =
  case l of
    English -> "Error at income creation"
    French  -> "Erreur lors de la création du revenu"

m l Error_IncomeDelete =
  case l of
    English -> "Error at income deletion"
    French  -> "Erreur lors de la suppression du revenu"

m l Error_IncomeEdit =
  case l of
    English -> "Error at income edition"
    French  -> "Erreur lors de la modification du revenu"

m l Error_PaymentCreate =
  case l of
    English -> "Error at payment creation"
    French  -> "Erreur lors de la création du paiement"

m l Error_PaymentDelete =
  case l of
    English -> "Error at payment deletion"
    French  -> "Erreur lors de la suppression du paiement"

m l Error_PaymentEdit =
  case l of
    English -> "Error at payment edition"
    French  -> "Erreur lors de la modification du paiement"

m l Error_SignOut =
  case l of
    English -> "Error at sign out"
    French  -> "Erreur lors de la déconnexion"

m l Form_AlreadyExists =
  case l of
    English -> "Dupplicate field"
    French  -> "Doublon"

m l Form_NonEmpty =
  case l of
    English -> "Required field"
    French  -> "Champ requis"

m l (Form_MinChars number) =
  case l of
    English -> T.concat [ "This field must contains at least ", T.pack . show $ number, " characters" ]
    French  -> T.concat [ "Ce champ doit contenir au moins ", T.pack . show $ number, " caractères" ]

m l Form_NonNullNumber =
  case l of
    English -> "Number must not be null"
    French  -> "Le nombre ne doit pas être nul"

m l (Form_GreaterIntThan number) =
  case l of
    English -> T.concat [ "Integer smaller than ", T.pack . show $ number, " or equal required" ]
    French  -> T.concat [ "Entier inférieur ou égal à ", T.pack . show $ number, " requis" ]

m l Form_InvalidCategory =
  case l of
    English -> "Invalid category"
    French  -> "Catégorie invalide"

m l Form_InvalidColor =
  case l of
    English -> "Invalid color"
    French  -> "Couleur invalide"

m l Form_InvalidDate =
  case l of
    English -> "Date required"
    French  -> "Date requise"

m l Form_InvalidInt =
  case l of
    English -> "Integer required"
    French  -> "Entier requis"

m l Form_InvalidString =
  case l of
    English -> "String required"
    French  -> "Chaîne de caractères requise"

m l (Form_SmallerIntThan number) =
  case l of
    English -> T.concat [ "Integer bigger than ", T.pack . show $ number, " or equal required" ]
    French  -> T.concat [ "Entier supérieur ou égal à ", T.pack . show $ number, " requis" ]

m l HttpError_BadPayload =
  case l of
    English -> "Bad payload server error"
    French  -> "Contenu inattendu en provenance du serveur"

m l HttpError_BadUrl =
  case l of
    English -> "URL not valid"
    French  -> "l’URL n’est pas valide"

m l HttpError_NetworkError =
  case l of
    English -> "Network can not be reached"
    French  -> "Le serveur n’est pas accessible"

m l HttpError_Timeout =
  case l of
    English -> "Timeout server error"
    French  -> "Le serveur met trop de temps à répondre"

m l Income_AddLong =
  case l of
    English -> "Add an income"
    French  -> "Ajouter un revenu"

m l Income_AddShort =
  case l of
    English -> "Add"
    French  -> "Ajouter"

m l Income_Name =
  case l of
    English -> "Name"
    French  -> "Nom"

m l Income_Amount =
  case l of
    English -> "Income"
    French  -> "Revenu"

m l Income_Clone =
  case l of
    English -> "Clone an income"
    French  -> "Cloner un revenu"

m l (Income_CumulativeSince since) =
  case l of
    English -> T.concat [ "Cumulative incomes since ", since ]
    French  -> T.concat [ "Revenus nets cumulés depuis le ", since ]

m l Income_Date =
  case l of
    English -> "Date"
    French  -> "Date"

m l Income_DeleteConfirm =
  case l of
    English -> "Are you sure to delete this income ?"
    French  -> "Voulez-vous vraiment supprimer ce revenu ?"

m l Income_Edit =
  case l of
    English -> "Edit an income"
    French  -> "Modifier un revenu"

m l Income_Empty =
  case l of
    English -> "No income."
    French  -> "Aucun revenu."

m l Income_MonthlyNet =
  case l of
    English -> "Net monthly incomes"
    French  -> "Revenus mensuels nets"

m l Income_Title =
  case l of
    English -> "Income"
    French  -> "Revenu"

m l Month_January =
  case l of
    English -> "january"
    French  -> "janvier"

m l Month_February =
  case l of
    English -> "february"
    French  -> "février"

m l Month_March =
  case l of
    English -> "march"
    French  -> "mars"

m l Month_April =
  case l of
    English -> "april"
    French  -> "avril"

m l Month_May =
  case l of
    English -> "may"
    French  -> "mai"

m l Month_June =
  case l of
    English -> "june"
    French  -> "juin"

m l Month_July =
  case l of
    English -> "july"
    French  -> "juillet"

m l Month_August =
  case l of
    English -> "august"
    French  -> "août"

m l Month_September =
  case l of
    English -> "september"
    French  -> "septembre"

m l Month_October =
  case l of
    English -> "october"
    French  -> "octobre"

m l Month_November =
  case l of
    English -> "november"
    French  -> "novembre"

m l Month_December =
  case l of
    English -> "december"
    French  -> "décembre"

m l PageNotFound_Title =
  case l of
    English -> "Page not found"
    French  -> "Page introuvable"

m l Payment_Add =
  case l of
    English -> "Add a payment"
    French  -> "Ajouter un paiement"

m l Payment_Balanced =
  case l of
    English -> "Payments are balanced."
    French  -> "Les paiements sont équilibrés."

m l (Payment_By key value) =
  case l of
    English -> T.concat [ key, ": ", value ]
    French  -> T.concat [ key, " : ", value ]

m l Payment_Category =
  case l of
    English -> "Category"
    French  -> "Catégorie"

m l Payment_CloneLong =
  case l of
    English -> "Clone a payment"
    French  -> "Cloner un paiement"

m l Payment_CloneShort =
  case l of
    English -> "Clone"
    French  -> "Cloner"

m l Payment_Cost =
  case l of
    English -> "Cost"
    French  -> "Coût"

m l Payment_Date =
  case l of
    English -> "Date"
    French  -> "Date"

m l Payment_Delete =
  case l of
    English -> "Delete"
    French  -> "Supprimer"

m l Payment_DeleteConfirm =
  case l of
    English -> "Are you sure to delete this payment ?"
    French  -> "Voulez-vous vraiment supprimer ce paiement ?"

m l Payment_EditLong =
  case l of
    English -> "Edit a payment"
    French  -> "Modifier un paiement"

m l Payment_EditShort =
  case l of
    English -> "Edit"
    French  -> "Modifier"

m l Payment_Empty =
  case l of
    English -> "No payment found from your search criteria."
    French  -> "Aucun paiement ne correspond à vos critères de recherches."

m l Payment_Frequency =
  case l of
    English -> "Frequency"
    French  -> "Fréquence"

m l Payment_InvalidFrequency =
  case l of
    English -> "Invalid frequency"
    French  -> "Fréquence invalide"

m l Payment_Many =
  case l of
    English -> "payments"
    French  -> "paiements"

m l Payment_MonthlyFemale =
  case l of
    English -> "Monthly"
    French  -> "Mensuelle"

m l Payment_MonthlyMale =
  case l of
    English -> "Monthly"
    French  -> "Mensuel"

m l Payment_Name =
  case l of
    English -> "Name"
    French  -> "Nom"

m l Payment_NotDeleted =
  case l of
    English -> "The payment could not have been deleted."
    French  -> "Le paiement n’a pas pu être supprimé."

m l Payment_One =
  case l of
    English -> "payment"
    French  -> "paiement"

m l Payment_PunctualFemale =
  case l of
    English -> "Punctual"
    French  -> "Ponctuelle"

m l Payment_PunctualMale =
  case l of
    English -> "Punctual"
    French  -> "Ponctuel"

m l Payment_Title =
  case l of
    English -> "Payments"
    French  -> "Paiements"

m l Payment_User =
  case l of
    English -> "Payer"
    French  -> "Payeur"

m l (Payment_Worth subject amount) =
  case l of
    English -> T.concat [ subject, " worth ", amount ]
    French  -> T.concat [ subject, " comptabilisant ", amount ]

m l Search_Monthly =
  case l of
    English -> "Monthly"
    French  -> "Mensuel"

m l Search_Name =
  case l of
    English -> "Search"
    French  -> "Recherche"

m l Search_Punctual =
  case l of
    English -> "Punctual"
    French  -> "Ponctuel"

m l Secure_Unauthorized =
  case l of
    English -> "You are not authorized to sign in."
    French  -> "Tu n’es pas autorisé à te connecter."

m l Secure_Forbidden =
  case l of
    English -> "You need to be logged in to perform this action"
    French  -> "Tu dois te connecter pour effectuer cette action"

m l SignIn_Button =
  case l of
    English -> "Sign in"
    French  -> "Connexion"

m l SignIn_DisconnectSuccess =
  case l of
    English -> "You have successfully disconnected"
    French  -> "Vous êtes à présent déconnecté."

m l SignIn_InvalidCredentials =
  case l of
    English -> "Your credentials are not valid."
    French  -> "Vos identifiants de connexion ne sont pas valides."

m l SignIn_EmailLabel =
  case l of
    English -> "Email"
    French  -> "Courriel"

m l SignIn_PasswordLabel =
  case l of
    English -> "Password"
    French  -> "Mot de passe"

m l (Statistics_ByMonthsAndMean paymentMean incomeMean ) =
  case l of
    English ->
      T.concat [ "Payments by category (mean ", paymentMean, ") and income (mean ", incomeMean, ") by month" ]
    French  ->
      T.concat [ "Paiements par catégorie (moy. ", paymentMean, ") et revenu (moy. ", incomeMean, ") par mois" ]

m l Statistics_Title =
  case l of
    English -> "Statistics"
    French  -> "Statistiques"

m l Statistics_TotalPayments =
  case l of
    English -> "Payment total"
    French  -> "Total des paiements"

m l Statistics_TotalIncomes =
  case l of
    English -> "Income total"
    French  -> "Total des revenus"

m l WeeklyReport_Empty =
  case l of
    English -> "No activity the previous week."
    French  -> "Pas d’activité la semaine passée."

m l (WeeklyReport_IncomesCreated count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " incomes created:" ]
    French  -> T.concat [ T.pack . show $ count, " revenus créés :" ]

m l (WeeklyReport_IncomesDeleted count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " incomes deleted:" ]
    French  -> T.concat [ T.pack . show $ count, " revenus supprimés :" ]

m l (WeeklyReport_IncomesEdited count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " incomes edited:" ]
    French  -> T.concat [ T.pack . show $ count, " revenus modifiés :" ]

m l (WeeklyReport_IncomeCreated count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " income created:" ]
    French  -> T.concat [ T.pack . show $ count, " revenu créé :" ]

m l (WeeklyReport_IncomeDeleted count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " income deleted:" ]
    French  -> T.concat [ T.pack . show $ count, " revenu supprimé :" ]

m l (WeeklyReport_IncomeEdited count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " income edited:" ]
    French  -> T.concat [ T.pack . show $ count, " revenu modifié :" ]

m l (WeeklyReport_PayedFor name amount for at) =
  case l of
    English -> T.concat [ name, " payed ", amount, " for “", for, "” at ", at ]
    French  -> T.concat [ name, " a payé ", amount, " de « ", for, " » le ", at ]

m l (WeeklyReport_PayedForNot name amount for at) =
  case l of
    English -> T.concat [ name, " didn’t pay ", amount, " for “", for, "” at ", at ]
    French  -> T.concat [ name, " n’a pas payé ", amount, " de « ", for, " » le ", at ]

m l (WeeklyReport_PayedFrom name amount for) =
  case l of
    English -> T.concat [ name, " is payed ", amount, " of net monthly income from ", for ]
    French  -> T.concat [ name, " est payé ", amount, " net par mois à partir du ", for ]

m l (WeeklyReport_PayedFromNot name amount for) =
  case l of
    English -> T.concat [ name, " isn’t payed ", amount, " of net monthly income from ", for ]
    French  -> T.concat [ name, " n’est pas payé ", amount, " net par mois à partir du ", for ]

m l (WeeklyReport_PaymentsCreated count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payments created:" ]
    French  -> T.concat [ T.pack . show $ count, " paiements créés :" ]

m l (WeeklyReport_PaymentsDeleted count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payments deleted:" ]
    French  -> T.concat [ T.pack . show $ count, " paiements supprimés :" ]

m l (WeeklyReport_PaymentsEdited count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payments edited:" ]
    French  -> T.concat [ T.pack . show $ count, " paiements modifiés :" ]

m l (WeeklyReport_PaymentCreated count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payment created:" ]
    French  -> T.concat [ T.pack . show $ count, " paiement créé :" ]

m l (WeeklyReport_PaymentDeleted count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payment deleted:" ]
    French  -> T.concat [ T.pack . show $ count, " paiement supprimé :" ]

m l (WeeklyReport_PaymentEdited count) =
  case l of
    English -> T.concat [ T.pack . show $ count, " payment edited:" ]
    French  -> T.concat [ T.pack . show $ count, " paiement modifié :" ]

m l WeeklyReport_Title =
  case l of
    English -> "Weekly report"
    French  -> "Rapport hebdomadaire"

m l NotFound_Message =
  case l of
    English -> "There is nothing here!"
    French  -> "Il n’y a rien à voir ici."

m l NotFound_LinkMessage =
  case l of
    English -> "Go back to the home page."
    French  -> "Retour à l’accueil."