import type { Pool } from "mysql2/promise";

/**
 * Vérifie si un utilisateur s'est inscrit pendant la période beta
 * (1 mois après le launch_date)
 */
export const isInBetaPeriod = async (
  db: Pool,
  userCreatedAt: Date,
): Promise<boolean> => {
  try {
    const [launchRows] = await db.execute(
      "SELECT config_value FROM app_config WHERE config_key = 'launch_date' LIMIT 1",
    );

    const launchValue = Array.isArray(launchRows)
      ? ((launchRows[0] as { config_value?: unknown } | undefined)
          ?.config_value ?? null)
      : null;

    if (typeof launchValue !== "string") {
      return false;
    }

    const launchDateMs = Date.parse(launchValue);
    if (!Number.isFinite(launchDateMs)) {
      return false;
    }

    const userCreatedAtMs = userCreatedAt.getTime();
    const oneMonthMs = 30 * 24 * 60 * 60 * 1000; // 30 jours

    return (
      userCreatedAtMs >= launchDateMs &&
      userCreatedAtMs <= launchDateMs + oneMonthMs
    );
  } catch (error) {
    console.error("Erreur lors de la vérification de la période beta:", error);
    return false;
  }
};

const getUserCreatedAt = async (db: Pool, userId: number): Promise<Date | null> => {
  const [userRows] = await db.execute(
    "SELECT created_at as createdAt FROM users WHERE id = ? LIMIT 1",
    [userId],
  );
  const createdAtValue = Array.isArray(userRows)
    ? ((userRows[0] as { createdAt?: unknown } | undefined)?.createdAt ?? null)
    : null;

  if (createdAtValue instanceof Date) {
    return Number.isFinite(createdAtValue.getTime()) ? createdAtValue : null;
  }
  if (typeof createdAtValue === "string") {
    const parsed = new Date(createdAtValue);
    return Number.isFinite(parsed.getTime()) ? parsed : null;
  }
  return null;
};

/**
 * Attribue automatiquement les avatars beta_testeur à un utilisateur
 */
export const grantBetaTesterAvatars = async (
  db: Pool,
  userId: number,
): Promise<void> => {
  try {
    // Récupérer tous les avatars beta_testeur
    const [avatarRows] = await db.execute(
      "SELECT id FROM avatars WHERE code LIKE 'beta-testeur%'",
    );

    if (!Array.isArray(avatarRows) || avatarRows.length === 0) {
      console.warn("Aucun avatar beta_testeur trouvé dans la base de données.");
      return;
    }

    // Débloquer tous les avatars beta_testeur pour cet utilisateur
    for (const row of avatarRows) {
      const avatarId = (row as { id?: number }).id;
      if (typeof avatarId === "number") {
        await db.execute(
          `INSERT IGNORE INTO user_avatars (user_id, avatar_id, source, metadata, unlocked_at)
           VALUES (?, ?, 'beta_tester', '{"reason": "inscription_periode_beta"}', NOW())`,
          [userId, avatarId],
        );
      }
    }

    console.log(
      `Avatars beta_testeur attribués à l'utilisateur ${userId} (${avatarRows.length} avatars)`,
    );
  } catch (error) {
    console.error(
      `Erreur lors de l'attribution des avatars beta_testeur à l'utilisateur ${userId}:`,
      error,
    );
  }
};

/**
 * Vérifie et attribue les avatars beta_testeur lors de l'inscription
 */
export const handleBetaTesterRegistration = async (
  db: Pool,
  userId: number,
): Promise<void> => {
  try {
    const userCreatedAt = await getUserCreatedAt(db, userId);
    if (!userCreatedAt) {
      return;
    }

    const isBeta = await isInBetaPeriod(db, userCreatedAt);

    if (isBeta) {
      await grantBetaTesterAvatars(db, userId);
    }
  } catch (error) {
    console.error(
      `Erreur lors de la vérification beta-testeur pour l'utilisateur ${userId}:`,
      error,
    );
  }
};