A bot in two languages

// The default catalog is typed; every other one only has to cover what it translates
const enUS = defineCatalog({
  announce: {
    name: 'announce',
    description: 'Post an announcement',
    message: 'The announcement',
    heading: '📣 Announcement',
    posted: 'Posted. Everyone sees it in the server’s language.',
  },
  welcome: 'Welcome to {server}, {user}!',
})

const id = {
  announce: {
    name: 'umumkan',
    description: 'Kirim pengumuman',
    message: 'Isi pengumuman',
    heading: '📣 Pengumuman',
    posted: 'Terkirim. Semua orang melihatnya dalam bahasa server.',
  },
  welcome: 'Selamat datang di {server}, {user}!',
// …
}

// MeoCord's own texts, all of them; one left out would stay in MeoCord's English
meocord: {
  usage: {
    heading: 'Cara pakai: {usage}',
    headingMany: 'Cara pakai:\n{usages}',
    missing: '{param} belum diisi',
    notValid: '{label}: "{word}" bukan {type} yang sah',
    notOneOf: '{label}: "{word}" bukan salah satu dari {choices}',
    notMember: '{label}: <@{id}> bukan anggota server ini',
    noUser: '{label}: tidak ada pengguna dengan ID {id}',
    notRole: '{label}: <@&{id}> bukan peran di server ini',
    notChannel: '{label}: "{word}" bukan saluran',
    unknownFlag: '--{flag} bukan opsi perintah ini',
    notYesNo: '{label}: "{value}" bukan ya atau tidak',
    flagNeedsValue: '{label} perlu nilai, seperti {label}=<{flag}>',
    tooManyWords: 'Perintah ini menerima lebih sedikit kata',
    serverOnly: 'Perintah ini hanya bisa dipakai di server.',
    dmOnly: 'Perintah ini hanya bisa dipakai di pesan langsung.',
  },
  types: {
    string: 'teks',
    int: 'bilangan bulat',
    number: 'angka',
    bool: 'jawaban ya atau tidak',
    duration: 'lama waktu, seperti 10m',
    member: 'anggota',
    user: 'pengguna',
    role: 'peran',
    channel: 'saluran',
  },
  cooldown: {
    // {when} is a Discord timestamp, which Discord words in the reader's language: "dalam 45 detik"
    until: 'Pelan-pelan: coba lagi {when}.',
    storeDown: 'Cooldown tidak bisa diperiksa sekarang: coba lagi sebentar lagi.',
  },
  fallback: {
    notFound: 'Perintah tidak ditemukan!',
    error: 'Terjadi kesalahan saat menjalankan perintah.',
  },
  dm: {
    error: '{command} di {channel} pada {server}: {reason}',
    cooldown: '{command} di {channel} pada {server}: {wait}',
  },
  presenter: {
    loading: 'Sedang diproses…',
    errorTitle: 'Ups!',
  },
  help: {
    commandsHeading: 'Perintah:',
    commandsHint: 'Ketik {invocation} <perintah> untuk cara pakai satu perintah.',
    describedCommand: '{usage} — {description}',
    param: '{name}: {label}',
    optionalParam: '{name} (opsional): {label}',
    params: '{params}',
    aliases: 'Juga: {aliases}',
    serverOnly: 'Hanya bisa dipakai di server.',
    dmOnly: 'Hanya bisa dipakai di pesan langsung.',
    unknown: 'Tidak ada perintah bernama "{query}". Ketik {invocation} untuk melihat daftarnya.',
    emptyHere: 'Tidak ada perintah yang bisa kamu pakai di sini.',
    emptyServerOnly: 'Perintah-perintah ini hanya bisa dipakai di server.',
    listOf: '{label}, satu atau lebih',
    flagOn: 'aktif bila diberikan',
    oneOf: 'salah satu dari {choices}',
  },
},

// At module scope: the builder runs when its class is decorated
export const t = createTranslator({ default: 'en-US', locales: { 'en-US': enUS, id } })

// Discord shows the command's name and description in each member's language
@CommandBuilder(CommandType.SLASH)
export class AnnounceCommandBuilder {
  build(commandName: string) {
    return new SlashCommandBuilder()
      .setName(commandName)
      .setNameLocalizations(t.localizations('announce.name'))
      .setDescription(t.default('announce.description'))
      .setDescriptionLocalizations(t.localizations('announce.description'))
      .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
      .setContexts(InteractionContextType.Guild)
      .addStringOption(option =>
        option
          .setName('message')
          .setDescription(t.default('announce.message'))
          .setDescriptionLocalizations(t.localizations('announce.message'))
          .setRequired(true),
      )
  }
}

@Controller()
export class AnnounceController {
  // Interactions report the default name, so the route is `announce` in every language
  @Command('announce', AnnounceCommandBuilder)
  // One announcement a minute in each server; MeoCord answers a second one in the author's language
  @Cooldown({ uses: 1, seconds: 60, per: 'guild' })
  async announce(interaction: ChatInputCommandInteraction, { message }: { message: string }) {
    // What everyone sees, in the server's language
    const everyone = t.for(interaction, { public: true })
    await respond(interaction).send({ content: `**${everyone('announce.heading')}**\n${message}` })
    // What only the author sees, in their own
    await respond(interaction).followUp({
      content: t.for(interaction)('announce.posted'),
      flags: MessageFlags.Ephemeral,
    })
  }

  // An event has no user locale: greet in the server's
  @On('guildMemberAdd')
  async welcome(member: GuildMember) {
    const text = t.forGuild(member.guild)('welcome', { server: member.guild.name, user: member.toString() })
    await member.guild.systemChannel?.send({ content: text })
  }
}

// The translator answers MeoCord's own texts too: cooldowns, usage, errors and "Command not found!"
@MeoCord({
  controllers: [AnnounceController],
  i18n: t,
  clientOptions: { intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers] },
})
export default class AnnounceApp {}

describe('AnnounceApp', () => {
  afterEach(() => vi.useRealTimers())

  it('announces in the server’s language, and confirms in the author’s', async () => {
    const module = MeoCordTestingModule.create({ controllers: [AnnounceController] }).compile()
    const interaction = announce('Maintenance at 20:00.')

    await module.invoke(AnnounceController, 'announce', interaction)

    const [announcement, confirmation] = getResponse(interaction).calls
    expect(announcement.payload).toMatchObject({ content: '**📣 Announcement**\nMaintenance at 20:00.' })
    expect(confirmation.payload).toMatchObject({ content: 'Terkirim. Semua orang melihatnya dalam bahasa server.' })
  })

  it('tells the author how long to wait, in their language, through MeoCord’s own text', async () => {
    vi.useFakeTimers({ toFake: ['Date'] })
    const module = MeoCordTestingModule.fromApp(AnnounceApp).compile()

    await module.dispatch(announce('Maintenance at 20:00.'))
    vi.advanceTimersByTime(15_000)
    const again = announce('And again.')
    await module.dispatch(again)

    // The presenter shows it as an embed, its title translated too
    expect(getResponse(again).calls[0].payload).toMatchObject({
      embeds: [
        { title: 'Ups!', description: `Pelan-pelan: coba lagi <t:${Math.ceil((Date.now() + 45_000) / 1000)}:R>.` },
      ],
    })
    expect(again.ephemeral).toBe(true)
  })

  it('welcomes a new member in the server’s language', async () => {
    const module = MeoCordTestingModule.create({ controllers: [AnnounceController] }).compile()
    const systemChannel = createMockInteraction(TextChannel)
    const guild = createMockInteraction(Guild, {
      name: 'Kafe Kucing',
      preferredLocale: Locale.Indonesian,
      systemChannel,
    })
    // discord.js's own toString() mentions the member through its user
    const member = createMockInteraction(GuildMember, { guild, user: createMockInteraction(User, { id: '111' }) })

    await module.emit('guildMemberAdd', member)

    expect(systemChannel.send).toHaveBeenCalledWith({ content: 'Selamat datang di Kafe Kucing, <@111>!' })
  })

  it('has every message in every language, MeoCord’s own included', () => {
    expectCompleteCatalog(t, { meocord: true })
  })
})