'use strict';

const { createCoreController } = require('@strapi/strapi').factories;

const VALID_LANGS = new Set(['fr', 'en', 'es', 'de', 'it'])

module.exports = createCoreController('api::parole.parole', ({strapi}) => ({
  async export(ctx) {
    const { type = 'pairs', lang, format = 'jsonl' } = ctx.query

    const langs = lang
      ? lang.split(',').map(l => l.trim()).filter(l => VALID_LANGS.has(l))
      : null

    if (lang && (!langs || langs.length === 0)) {
      return ctx.badRequest('Langue(s) invalide(s). Valeurs acceptées : fr, en, es, de, it.')
    }

    if (!['pairs', 'instruct'].includes(type)) {
      return ctx.badRequest('type invalide. Valeurs acceptées : pairs, instruct.')
    }

    const paroles = await strapi.service('api::parole.parole').fetchAllParoles()
    const { metadata, pairs } = strapi.service('api::parole.parole').buildExport(paroles, type, langs)

    if (format === 'json') {
      return ctx.send({ metadata, data: pairs })
    }

    // JSONL : première ligne = métadonnées, suivies des exemples d'entraînement.
    // Pour filtrer la ligne de métadonnées : jq 'select(._metadata | not)'
    const lines = [
      JSON.stringify({ _metadata: true, ...metadata }),
      ...pairs.map(p => JSON.stringify(p)),
    ]

    ctx.set('Content-Type', 'application/x-ndjson')
    ctx.set('Content-Disposition', `attachment; filename="pawol-nu-export-${Date.now()}.jsonl"`)
    ctx.body = lines.join('\n')
  },

  async bulkTranslate(ctx) {
    const result = await strapi.service('api::parole.parole').bulkTranslateMissing()
    return ctx.send(result)
  },

  async findOne(ctx) {
    const {id: documentId} = ctx.params
    const parole = await strapi.documents('api::parole.parole').findOne({
      documentId,
      populate: ['artistes']
    })

    return parole
  },
  async update(ctx) {
    const {body} = ctx.request
    const {data} = body

    const updatedParole = await strapi.documents('api::parole.parole').update({
      documentId: data.documentId,

      data: {
        ...data
      }
    })

    return updatedParole
  },
  async create(ctx) {
    const {body} = ctx.request
    const {data} = body

    if (!data?.user?.documentId || !data?.artistes?.[0]?.documentId) {
      return ctx.badRequest('Informations manquantes.')
    }

    strapi.service('api::parole.parole').validateParoles(data.titre, data.transcription)

    const user = await strapi.documents('plugin::users-permissions.user').findOne({
      documentId: body.data.user.documentId
    })

    if (!user) {
      return ctx.notFound('Utilisateur introuvable.')
    }

    if (user.id !== data.user.id || user.username !== data.user.username || user.email !== data.user.email) {
      return ctx.badRequest('Informations non valides.')
    }

    const artiste = await strapi.documents('api::artiste.artiste').findOne({
      documentId: data.artistes[0].documentId
    })

    if (!artiste) {
      return ctx.notFound('Artiste introuvable.')
    }

    const currentUserParole = await strapi.documents('api::parole.parole').findMany({
      fields: ['id'],
      filters: {
        user: {
          id: {
            $eq: user.id
          }
        },
        publishedAt: {
          $eq: null
        }
      }
    })


    if (user && user.canAutoTranslate && data.traductionAuto && data.traductions.francais && (!data.traductions.anglais || !data.traductions.espagnol || !data.traductions.allemand || !data.traductions.italien)) {
      const translated = await strapi.service('api::parole.parole').translateLyrics(data.traductions.francais)
      data.traductions = translated
    }

    const newParole = await strapi.documents('api::parole.parole').create({
      data: {
        ...data
      }
    })

    const parolesIds = currentUserParole.map(({id}) => id)
    parolesIds.push(newParole.id)

    await strapi.documents('plugin::users-permissions.user').update({
      documentId: user.documentId,

      data: {
        paroles: parolesIds
      }
    })

    return newParole
  }
}))