import { EvenementFamille } from "../EvenementFamille";
import { Famille } from "../Famille";
import { checkDataConsistency } from "./checkDataConsistency";
import {
  MessageDeNettoyage,
  msgDonneeBloquante,
  msgDonneeIgnoree,
  msgDonneeSuspecte,
} from "./MessageDeNettoyage";

type DonneesNettoyees = {
  familles: Famille[];
  messages: MessageDeNettoyage[];
};

export function nettoyerDonneesFamilles(
  donneesFamillesBrutes: Famille[]
): DonneesNettoyees {
  let familles = donneesFamillesBrutes;

  let messages: MessageDeNettoyage[] = [];

  const output1 = supprimerLesEntreesVide(familles);
  messages = [...messages, ...output1.messages];
  familles = output1.familles;

  // TODO convert checkDataConsistency to filters
  const consistencyReport = checkDataConsistency(familles);

  // Adapte les message
  const errorMessages: MessageDeNettoyage[] = consistencyReport.errors.map(
    (e) => msgDonneeBloquante(`${e.familyId} - ${e.issueType}`)
  );
  const warnings: MessageDeNettoyage[] = consistencyReport.warnings.map((e) =>
    msgDonneeSuspecte(`${e.familyId} - ${e.issueType}`)
  );

  messages = [...messages, ...errorMessages, ...warnings];

  const output2 = supprimerLesEvenementsSansDate(familles);
  messages = [...messages, ...output2.messages];
  familles = output2.familles;

  const output3 = supprimerLesEvenementsHorsResisstance(familles);
  messages = [...messages, ...output3.messages];
  familles = output3.familles;

  return {
    familles,
    messages,
  };
}

/**
 * Supprime "Famille de résistant" qui sont souvent créé  par erreur
 */
function supprimerLesEntreesVide(familles: Famille[]): DonneesNettoyees {
  const nettoyees = familles.filter((f) => f.Titre !== "Famille de résistant");
  const ignorees = familles.filter((f) => f.Titre === "Famille de résistant");
  if (ignorees.length > 0) {
    return {
      familles: nettoyees,
      messages: [
        msgDonneeIgnoree(
          `${
            nettoyees.length - familles.length
          } enregistrement(s) famille "vide" ignoré(s)`
        ),
      ],
    };
  } else {
    return {
      familles: nettoyees,
      messages: [],
    };
  }
}

function supprimerLesEvenementsSansDate(familles: Famille[]): DonneesNettoyees {
  return ignorerEvenements(
    familles,
    (e: EvenementFamille) => e.Date === null,
    (e, f) =>
      `Evenement "${f.Titre} - ${e.Évènement}" [${e.notionId}] n'as pas de Date il sera ignoré`
  );
}

function supprimerLesEvenementsHorsResisstance(
  familles: Famille[]
): DonneesNettoyees {
  return ignorerEvenements(
    familles,
    (e: EvenementFamille, f: Famille) => {
      return (
        e.Date !== null &&
        ((f.Integration !== null && e.Date < f.Integration) ||
          (f.Sortie !== null && e.Date > f.Sortie))
      );
    },
    (e, f) =>
      `Evenement "${f.Titre} - ${e.Évènement}" [${e.notionId}] hors période de résistance il sera ignoré`
  );
}

function ignorerEvenements(
  familles: Famille[],
  conditionAIgnoree: (evt: EvenementFamille, f: Famille) => boolean,
  messageIgnoreeFn: (evt: EvenementFamille, f: Famille) => string
): DonneesNettoyees {
  let messages: MessageDeNettoyage[] = [];
  const nettoyees = familles.map((f) => {
    const nettoyees = f.Evenements.filter((e) => !conditionAIgnoree(e, f));
    const evtIgnorees = f.Evenements.filter((e) => conditionAIgnoree(e, f));
    messages = [
      ...messages,
      ...evtIgnorees.map((e) => msgDonneeIgnoree(messageIgnoreeFn(e, f))),
    ];
    return { ...f, Evenements: nettoyees };
  });
  return {
    familles: nettoyees,
    messages,
  };
}