'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: {
        titre: data.titre,
        transcription: data.transcription,
        traductions: data.traductions,
        traductionAuto: data.traductionAuto,
        artistes: data.artistes
      }
    });

    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: {
        titre: data.titre,
        transcription: data.transcription,
        traductions: data.traductions,
        traductionAuto: data.traductionAuto,
        artistes: [artiste.id],
        user: user.id
      }
    });

    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;
  }
}));