import { getDb } from "./db";
import { logsRappels, InsertLogRappel, LogRappel } from "../drizzle/schema";
import { eq, and } from "drizzle-orm";

/**
 * Enregistre l'envoi d'un rappel dans les logs
 */
export async function logRappelEnvoye(data: {
  rappelId: number;
  sequenceId: number;
  apprenantId: number;
  emailDestinataire: string;
  typeRappel: string;
  statut: "success" | "failed";
  messageErreur?: string;
  dateSequence: Date;
}): Promise<void> {
  const db = await getDb();
  if (!db) {
    console.warn("[LogsRappels] Base de données non disponible");
    return;
  }

  try {
    await db.insert(logsRappels).values({
      rappelId: data.rappelId,
      sequenceId: data.sequenceId,
      apprenantId: data.apprenantId,
      emailDestinataire: data.emailDestinataire,
      typeRappel: data.typeRappel,
      dateEnvoi: new Date(),
      statut: data.statut,
      messageErreur: data.messageErreur || null,
      dateSequence: data.dateSequence,
    } as InsertLogRappel);
  } catch (error) {
    console.error("[LogsRappels] Erreur lors de l'enregistrement du log:", error);
  }
}

/**
 * Vérifie si un rappel a déjà été envoyé à un apprenant pour une séquence donnée
 */
export async function rappelDejaEnvoye(
  rappelId: number,
  sequenceId: number,
  apprenantId: number
): Promise<boolean> {
  const db = await getDb();
  if (!db) {
    console.warn("[LogsRappels] Base de données non disponible");
    return false;
  }

  try {
    const logs = await db
      .select()
      .from(logsRappels)
      .where(
        and(
          eq(logsRappels.rappelId, rappelId),
          eq(logsRappels.sequenceId, sequenceId),
          eq(logsRappels.apprenantId, apprenantId),
          eq(logsRappels.statut, "success")
        )
      )
      .limit(1);

    return logs.length > 0;
  } catch (error) {
    console.error("[LogsRappels] Erreur lors de la vérification des doublons:", error);
    return false;
  }
}

/**
 * Récupère tous les logs de rappels pour une séquence donnée
 */
export async function getLogsRappelsBySequence(sequenceId: number): Promise<LogRappel[]> {
  const db = await getDb();
  if (!db) return [];

  try {
    return await db
      .select()
      .from(logsRappels)
      .where(eq(logsRappels.sequenceId, sequenceId))
      .orderBy(logsRappels.dateEnvoi);
  } catch (error) {
    console.error("[LogsRappels] Erreur lors de la récupération des logs:", error);
    return [];
  }
}

/**
 * Récupère tous les logs de rappels échoués récents (dernières 24h)
 */
export async function getLogsRappelsEchoues(): Promise<LogRappel[]> {
  const db = await getDb();
  if (!db) return [];

  try {
    const hier = new Date();
    hier.setDate(hier.getDate() - 1);

    return await db
      .select()
      .from(logsRappels)
      .where(
        and(
          eq(logsRappels.statut, "failed"),
          // Note: Drizzle ne supporte pas directement les comparaisons de dates
          // On récupère tous les échecs et on filtre en JS
        )
      )
      .orderBy(logsRappels.dateEnvoi);
  } catch (error) {
    console.error("[LogsRappels] Erreur lors de la récupération des échecs:", error);
    return [];
  }
}

/**
 * Compte le nombre de rappels envoyés avec succès pour une séquence
 */
export async function countRappelsEnvoyesSequence(sequenceId: number): Promise<number> {
  const db = await getDb();
  if (!db) return 0;

  try {
    const logs = await db
      .select()
      .from(logsRappels)
      .where(
        and(
          eq(logsRappels.sequenceId, sequenceId),
          eq(logsRappels.statut, "success")
        )
      );

    return logs.length;
  } catch (error) {
    console.error("[LogsRappels] Erreur lors du comptage:", error);
    return 0;
  }
}