/**
 * Moteur de lecture RSS
 * Récupère les flux actifs, parse les articles, applique les règles d'automatisme,
 * et insère les nouveaux articles dans veille_items ou aap_items.
 *
 * Enrichissement automatique :
 * - AAP : région (toujours Auvergne-Rhône-Alpes) + département extrait du titre/description
 * - Veille : territoire, catégorie (Handicap/PA/Enfance/Précarité/Sanitaire/Autre), niveau
 *
 * Fusion multi-département :
 * - Les articles avec le même titre normalisé (sans nom de département) sont fusionnés
 *   en un seul enregistrement avec une liste JSON de territoires/départements.
 */
import { XMLParser } from "fast-xml-parser";
import * as crypto from "crypto";
import { getDb } from "./db";
import {
  rssFeeds,
  veilleItems,
  aapItems,
  type RssFeed,
} from "../drizzle/schema";
import { eq, sql } from "drizzle-orm";

// ─── Types internes ───────────────────────────────────────────────────────────

interface RssItem {
  title: string;
  description?: string;
  link?: string;
  pubDate?: string;
  guid?: string;
}

interface AutoRule {
  keyword: string;
  typeVeille?: "reglementaire" | "concurrentielle" | "technologique" | "generale";
  categorieAap?: "Handicap" | "PA" | "Enfance" | "Précarité" | "Sanitaire" | "Autre";
}

interface FetchResult {
  feedId: number;
  feedName: string;
  status: "ok" | "error";
  newItems: number;
  skippedItems: number;
  mergedItems: number;
  error?: string;
}

// ─── Dictionnaire des départements d'Auvergne-Rhône-Alpes ────────────────────
// IMPORTANT : les départements composés (Haute-Loire, Haute-Savoie, Puy-de-Dôme)
// doivent être AVANT leurs variantes simples (Loire, Savoie) pour éviter les faux positifs.

const AURA_DEPARTMENTS: Array<{ pattern: RegExp; name: string; num: string }> = [
  // Composés en premier
  { pattern: /haute-savoie|haute savoie|(?<!\d)74(?!\d)|\(74\)/i, name: "Haute-Savoie", num: "74" },
  { pattern: /haute-loire|haute loire|(?<!\d)43(?!\d)|\(43\)/i, name: "Haute-Loire", num: "43" },
  { pattern: /puy-de-d[oô]me|puy de d[oô]me|(?<!\d)63(?!\d)|\(63\)/i, name: "Puy-de-Dôme", num: "63" },
  // Simples ensuite
  { pattern: /\bain\b|(?<!\d)01(?!\d)|\(01\)/i, name: "Ain", num: "01" },
  { pattern: /\ballier\b|(?<!\d)03(?!\d)|\(03\)/i, name: "Allier", num: "03" },
  { pattern: /\bard[eè]che\b|(?<!\d)07(?!\d)|\(07\)/i, name: "Ardèche", num: "07" },
  { pattern: /\bcantal\b|(?<!\d)15(?!\d)|\(15\)/i, name: "Cantal", num: "15" },
  { pattern: /\bdr[oô]me\b|(?<!\d)26(?!\d)|\(26\)/i, name: "Drôme", num: "26" },
  { pattern: /\bis[eè]re\b|(?<!\d)38(?!\d)|\(38\)/i, name: "Isère", num: "38" },
  // Loire : exclure "Haute-Loire" déjà traité
  { pattern: /(?<!haute-)\bloire\b|(?<!\d)42(?!\d)|\(42\)/i, name: "Loire", num: "42" },
  { pattern: /\brhone\b|\brhône\b|(?<!\d)69(?!\d)|\(69\)|m[eé]tropole\s+de\s+lyon/i, name: "Rhône", num: "69" },
  // Savoie : exclure "Haute-Savoie" déjà traité
  { pattern: /\bsavoie\b(?!.*haute)|(?<!\d)73(?!\d)|\(73\)/i, name: "Savoie", num: "73" },
];

/**
 * Détecte le département dans un texte.
 * Retourne { name, num } ou null si non trouvé.
 */
export function detectDepartment(text: string): { name: string; num: string } | null {
  for (const dept of AURA_DEPARTMENTS) {
    if (dept.pattern.test(text)) {
      return { name: dept.name, num: dept.num };
    }
  }
  return null;
}

/**
 * Détecte si le texte mentionne la région Auvergne-Rhône-Alpes.
 */
function isRegional(text: string): boolean {
  return /auvergne.?rh.?ne.?alpes|aura\b|a\.r\.a\.|ars\s+auvergne/i.test(text);
}

// ─── Normalisation du titre pour la fusion ────────────────────────────────────

/**
 * Crée une clé de fusion en extrayant uniquement les mots significatifs du titre
 * (sans noms de départements, sans stop-words, en minuscules).
 * Cette clé est utilisée pour grouper les articles similaires.
 * Le titre original est conservé tel quel pour l'affichage.
 */
function buildMergeKey(title: string): string {
  let key = title.toLowerCase();

  // Supprimer les noms de départements AuRA (composites d'abord)
  const deptNames = [
    "haute-savoie", "haute savoie", "haute-loire", "haute loire",
    "puy-de-dôme", "puy-de-dome", "puy de dôme", "puy de dome",
    "ain", "allier", "ardèche", "ardeche", "cantal",
    "drôme", "drome", "isère", "isere", "loire",
    "rhône", "rhone", "savoie",
    "métropole de lyon", "metropole de lyon", "lyon",
    "allier",
  ];

  // Protéger "auvergne-rhône-alpes" et "rhône-alpes"
  key = key.replace(/auvergne.?rh.?ne.?alpes/gi, "__AURA__");
  key = key.replace(/rh.?ne.?alpes/gi, "__RHONEALPES__");

  for (const dept of deptNames) {
    // Supprimer avec prépositions courantes
    key = key.replace(new RegExp(`(dans\\s+l[ae']?\\s*|en\\s+|du\\s+|de\\s+la\\s+|de\\s+l[ae']?\\s*|et\\s+la\\s+|et\\s+le\\s+|,\\s*)${dept.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, "gi"), " ");
    key = key.replace(new RegExp(`\\b${dept.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, "gi"), " ");
  }

  // Supprimer les numéros de département
  key = key.replace(/\(\d{2}\)/g, " ");

  // Restaurer les placeholders
  key = key.replace(/__AURA__/g, "auvergne-rhone-alpes");
  key = key.replace(/__RHONEALPES__/g, "rhone-alpes");

  // Supprimer les stop-words et prépositions orphelines
  const stopWords = ["dans", "l'", "la", "le", "les", "l", "en", "du", "de", "des", "et", "un", "une", "pour", "au", "aux", "par", "sur", "avec", "sans", "ou", "ni"];
  for (const sw of stopWords) {
    key = key.replace(new RegExp(`\\b${sw}\\b`, "gi"), " ");
  }

  // Nettoyer et normaliser
  key = key
    .replace(/[^a-z0-9à-ÿ\s]/gi, " ")
    .replace(/\s+/g, " ")
    .trim();

  return key;
}

/**
 * Conserve le titre original mais nettoie les artefacts de normalisation
 * (utilisé uniquement pour l'affichage du titre dans la liste).
 */
function cleanTitleForDisplay(title: string): string {
  // Le titre original est conservé tel quel
  return title.trim();
}

// ─── Extraction automatique pour la Veille ───────────────────────────────────

type VeilleCategorie = "Handicap" | "PA" | "Enfance" | "Précarité" | "Sanitaire" | "Autre";
type VeilleNiveau = "departemental" | "regional" | "national";

/**
 * Déduit la catégorie d'un article de veille depuis son titre + description.
 */
export function detectVeilleCategorie(text: string): VeilleCategorie {
  const t = text.toLowerCase();

  if (/\bhandicap\b|im[eé]\b|esat\b|uema\b|ueea\b|autisme\b|polyhandicap\b|mdph\b|rqth\b|inclusion scolaire/i.test(t)) {
    return "Handicap";
  }
  if (/\bpersonnes?\s+âgées?\b|personnes?\s+agees?\b|ehpad\b|ssiad\b|sad\b|perte\s+d'autonomie\b|autonomie\b|domicile\b|\bcrt\b|centres?\s+de\s+ressources?\s+territoriaux/i.test(t)) {
    return "PA";
  }
  if (/\benfan[ct]\b|jeune[s]?\b|mineur[s]?\b|maternelle\b|élémentaire\b|scolaire\b|camsp\b|crip\b|protection\s+de\s+l'enfance\b/i.test(t)) {
    return "Enfance";
  }
  if (/\bprécarité\b|precarite\b|exclusion\b|sans-abri\b|\bsdf\b|emsp\b|équipe\s+mobile\s+santé\s+précarité\b|hébergement\b|pauvreté\b/i.test(t)) {
    return "Précarité";
  }
  if (/\bsoin[s]?\b|santé\b|sante\b|médical\b|médecin\b|infirmier\b|hôpital\b|hopital\b|clinique\b|vaccination\b|vaccin\b|épidémie\b|virus\b|infection\b|dépistage\b|prévention\b|\bars\b|msp\b|maison\s+de\s+santé\b/i.test(t)) {
    return "Sanitaire";
  }

  return "Autre";
}

/**
 * Déduit le niveau et le territoire d'un article de veille.
 */
export function detectVeilleNiveauTerritoire(text: string): { niveau: VeilleNiveau; territoire: string } {
  const dept = detectDepartment(text);
  if (dept) {
    return { niveau: "departemental", territoire: dept.name };
  }
  if (isRegional(text)) {
    return { niveau: "regional", territoire: "Auvergne-Rhône-Alpes" };
  }
  return { niveau: "national", territoire: "France" };
}

// ─── Extraction automatique pour les AAP ─────────────────────────────────────

export function detectAapGeo(text: string): { region: string; departement: string | null } {
  const dept = detectDepartment(text);
  return {
    region: "Auvergne-Rhône-Alpes",
    departement: dept ? `${dept.name} (${dept.num})` : null,
  };
}

// ─── Utilitaires ─────────────────────────────────────────────────────────────

function dedupHash(text: string): string {
  return crypto.createHash("sha256").update(text).digest("hex").substring(0, 64);
}

function parseDate(dateStr?: string): Date | null {
  if (!dateStr) return null;
  const d = new Date(dateStr);
  return isNaN(d.getTime()) ? null : d;
}

function stripHtml(html: string): string {
  return html
    .replace(/<[^>]*>/g, "")
    .replace(/&amp;/g, "&")
    .replace(/&lt;/g, "<")
    .replace(/&gt;/g, ">")
    .replace(/&quot;/g, '"')
    .replace(/&#39;/g, "'")
    .trim();
}

function applyAutoRules(title: string, description: string, rules: AutoRule[]): AutoRule | null {
  const text = (title + " " + description).toLowerCase();
  for (const rule of rules) {
    if (text.includes(rule.keyword.toLowerCase())) {
      return rule;
    }
  }
  return null;
}

/**
 * Ajoute un territoire à la liste JSON existante (sans doublon).
 * Retourne la nouvelle liste sérialisée.
 */
function addToTerritoiresList(existing: string | null, newTerritoire: string): string {
  let list: string[] = [];
  if (existing) {
    try { list = JSON.parse(existing); } catch { list = [existing]; }
  }
  if (!list.includes(newTerritoire)) {
    list.push(newTerritoire);
  }
  return JSON.stringify(list);
}

// ─── Parsing RSS/Atom ─────────────────────────────────────────────────────────

async function fetchAndParseRss(url: string): Promise<RssItem[]> {
  const response = await fetch(url, {
    headers: {
      "User-Agent": "Mozilla/5.0 (compatible; VeilleBot/1.0; +https://itinova.fr)",
      "Accept": "application/rss+xml, application/xml, text/xml, */*",
    },
    signal: AbortSignal.timeout(15000),
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status} ${response.statusText}`);
  }

  const xml = await response.text();
  const parser = new XMLParser({
    ignoreAttributes: false,
    attributeNamePrefix: "@_",
    textNodeName: "#text",
    parseAttributeValue: true,
    trimValues: true,
  });

  const parsed = parser.parse(xml);

  const channel = parsed?.rss?.channel;
  if (channel) {
    const items = Array.isArray(channel.item) ? channel.item : channel.item ? [channel.item] : [];
    return items.map((item: any) => ({
      title: String(item.title?.["#text"] ?? item.title ?? ""),
      description: String(item.description?.["#text"] ?? item.description ?? ""),
      link: String(item.link?.["#text"] ?? item.link ?? item.guid?.["#text"] ?? item.guid ?? ""),
      pubDate: String(item.pubDate ?? item["dc:date"] ?? ""),
      guid: String(item.guid?.["#text"] ?? item.guid ?? item.link ?? ""),
    }));
  }

  const feed = parsed?.feed;
  if (feed) {
    const entries = Array.isArray(feed.entry) ? feed.entry : feed.entry ? [feed.entry] : [];
    return entries.map((entry: any) => {
      const links = Array.isArray(entry.link) ? entry.link : entry.link ? [entry.link] : [];
      const altLink = links.find((l: any) => l["@_rel"] === "alternate") ?? links[0];
      return {
        title: String(entry.title?.["#text"] ?? entry.title ?? ""),
        description: String(entry.summary?.["#text"] ?? entry.summary ?? entry.content?.["#text"] ?? ""),
        link: String(altLink?.["@_href"] ?? ""),
        pubDate: String(entry.published ?? entry.updated ?? ""),
        guid: String(entry.id ?? altLink?.["@_href"] ?? ""),
      };
    });
  }

  throw new Error("Format RSS/Atom non reconnu");
}

// ─── Traitement d'un flux ─────────────────────────────────────────────────────

async function processFeed(feed: RssFeed): Promise<FetchResult> {
  const db = await getDb();
  if (!db) throw new Error("Database not available");

  const result: FetchResult = {
    feedId: feed.id,
    feedName: feed.name,
    status: "ok",
    newItems: 0,
    skippedItems: 0,
    mergedItems: 0,
  };

  try {
    const items = await fetchAndParseRss(feed.url);
    const rules: AutoRule[] = Array.isArray(feed.autoRules) ? feed.autoRules as AutoRule[] : [];

    for (const item of items) {
      const title = stripHtml(item.title || "");
      const description = stripHtml(item.description || "");
      const link = item.link || item.guid || "";
      const pubDate = parseDate(item.pubDate);
      const fullText = title + " " + description;

      if (!title) {
        result.skippedItems++;
        continue;
      }

      // ─── Clé de déduplication : basée sur le titre NORMALISÉ (sans département) ───
      const normalizedTitle = buildMergeKey(title);
      const dedupKey = dedupHash(normalizedTitle + "|" + (feed.feedType ?? ""));

      if (feed.feedType === "veille") {
        const matchedRule = applyAutoRules(title, description, rules);
        const typeVeille = (matchedRule?.typeVeille ?? feed.defaultTypeVeille ?? "generale") as
          "reglementaire" | "concurrentielle" | "technologique" | "generale";

        const categorie = detectVeilleCategorie(fullText);
        const { niveau, territoire } = detectVeilleNiveauTerritoire(fullText);

        try {
          // Essayer d'insérer
          await db.insert(veilleItems).values({
            dedupKey,
            titre: title,
            categorie,
            niveau,
            territoire,
            territoires: territoire !== "France" && territoire !== "Auvergne-Rhône-Alpes"
              ? [territoire]
              : [],
            resume: description || null,
            source: feed.name,
            lien: link || null,
            typeVeille,
            datePublication: pubDate,
          });
          result.newItems++;
        } catch (e: any) {
          if (e?.code === "ER_DUP_ENTRY" || e?.message?.includes("Duplicate entry")) {
            // Article existant → ajouter le territoire à la liste si c'est un nouveau département
            if (territoire !== "France" && territoire !== "Auvergne-Rhône-Alpes") {
              await db.execute(
                sql`UPDATE veille_items
                    SET territoires = JSON_ARRAY_APPEND(
                      COALESCE(territoires, JSON_ARRAY()),
                      '$',
                      ${territoire}
                    )
                    WHERE dedupKey = ${dedupKey}
                    AND NOT JSON_CONTAINS(COALESCE(territoires, JSON_ARRAY()), ${JSON.stringify(territoire)})`
              );
              result.mergedItems++;
            } else {
              result.skippedItems++;
            }
          } else {
            throw e;
          }
        }
      } else if (feed.feedType === "aap") {
        const matchedRule = applyAutoRules(title, description, rules);
        const categorie = (matchedRule?.categorieAap ?? feed.defaultCategorieAap ?? "Autre") as
          "Handicap" | "PA" | "Enfance" | "Précarité" | "Sanitaire" | "Autre";

        const { region, departement } = detectAapGeo(fullText);

        try {
          await db.insert(aapItems).values({
            dedupKey,
            titre: title,
            categorie,
            region,
            departement,
            departements: departement ? [departement] : [],
            lien: link || null,
            datePublication: pubDate,
          });
          result.newItems++;
        } catch (e: any) {
          if (e?.code === "ER_DUP_ENTRY" || e?.message?.includes("Duplicate entry")) {
            // Article existant → ajouter le département à la liste
            if (departement) {
              await db.execute(
                sql`UPDATE aap_items
                    SET departements = JSON_ARRAY_APPEND(
                      COALESCE(departements, JSON_ARRAY()),
                      '$',
                      ${departement}
                    )
                    WHERE dedupKey = ${dedupKey}
                    AND NOT JSON_CONTAINS(COALESCE(departements, JSON_ARRAY()), ${JSON.stringify(departement)})`
              );
              result.mergedItems++;
            } else {
              result.skippedItems++;
            }
          } else {
            throw e;
          }
        }
      }
    }

    await db.update(rssFeeds)
      .set({ lastFetchedAt: new Date(), lastFetchStatus: "ok", lastFetchError: null })
      .where(eq(rssFeeds.id, feed.id));

  } catch (e: any) {
    result.status = "error";
    result.error = e?.message ?? String(e);
    try {
      await db.update(rssFeeds)
        .set({ lastFetchedAt: new Date(), lastFetchStatus: "error", lastFetchError: result.error })
        .where(eq(rssFeeds.id, feed.id));
    } catch (_) { /* ignore */ }
  }

  return result;
}

// ─── Migration des articles existants ─────────────────────────────────────────

export interface MigrationSummary {
  veilleUpdated: number;
  veilleMerged: number;
  aapUpdated: number;
  aapMerged: number;
  executedAt: string;
}

/**
 * Met à jour et fusionne les articles déjà importés.
 * - Recalcule catégorie, niveau, territoire pour veille_items
 * - Recalcule région, département pour aap_items
 * - Fusionne les articles avec le même titre normalisé
 */
export async function migrateExistingItems(): Promise<MigrationSummary> {
  const db = await getDb();
  if (!db) throw new Error("Database not available");

  let veilleUpdated = 0;
  let veilleMerged = 0;
  let aapUpdated = 0;
  let aapMerged = 0;

  // ─── 1. Recalculer les champs enrichis pour veille_items ──────────────────
  const veilleRows = await db.select().from(veilleItems);

  // Grouper par titre normalisé
  const veilleGroups = new Map<string, (typeof veilleRows)[number][]>();
  for (const row of veilleRows) {
    const normalized = buildMergeKey(row.titre || "");
    const key = dedupHash(normalized + "|veille");
    if (!veilleGroups.has(key)) veilleGroups.set(key, []);
    veilleGroups.get(key)!.push(row);
  }

  for (const [, group] of Array.from(veilleGroups)) {
    if (group.length === 1) {
      // Article unique : mettre à jour les champs enrichis
      const row = group[0];
      const fullText = (row.titre || "") + " " + (row.resume || "");
      const newCategorie = detectVeilleCategorie(fullText);
      const { niveau: newNiveau, territoire: newTerritoire } = detectVeilleNiveauTerritoire(fullText);
      const normalizedTitle = buildMergeKey(row.titre || "");
      const newDedupKey = dedupHash(normalizedTitle + "|veille");

      await db.update(veilleItems)
        .set({
          categorie: newCategorie,
          niveau: newNiveau,
          territoire: newTerritoire,
          territoires: newTerritoire !== "France" && newTerritoire !== "Auvergne-Rhône-Alpes"
            ? [newTerritoire] : [],
          titre: row.titre,
          dedupKey: newDedupKey,
        })
        .where(eq(veilleItems.id, row.id));
      veilleUpdated++;
    } else {
      // Groupe : fusionner en gardant le premier, supprimer les autres
      const sorted = group.sort((a: (typeof veilleRows)[number], b: (typeof veilleRows)[number]) => a.id - b.id);
      const primary = sorted[0];
      const duplicates = sorted.slice(1);

      // Collecter tous les territoires
      const allTerritoires: string[] = [];
      for (const row of sorted) {
        const fullText = (row.titre || "") + " " + (row.resume || "");
        const { territoire } = detectVeilleNiveauTerritoire(fullText);
        if (territoire !== "France" && territoire !== "Auvergne-Rhône-Alpes" && !allTerritoires.includes(territoire)) {
          allTerritoires.push(territoire);
        }
      }

      const fullText = (primary.titre || "") + " " + (primary.resume || "");
      const newCategorie = detectVeilleCategorie(fullText);
      const normalizedTitle = buildMergeKey(primary.titre || "");
      const newDedupKey = dedupHash(normalizedTitle + "|veille");

      // Mettre à jour le principal
      await db.update(veilleItems)
        .set({
          categorie: newCategorie,
          niveau: allTerritoires.length > 1 ? "departemental" : "regional",
          territoire: allTerritoires.length > 0 ? allTerritoires[0] : "Auvergne-Rhône-Alpes",
          territoires: allTerritoires,
          titre: primary.titre,
          dedupKey: newDedupKey,
        })
        .where(eq(veilleItems.id, primary.id));

      // Supprimer les doublons
      for (const dup of duplicates) {
        await db.delete(veilleItems).where(eq(veilleItems.id, dup.id));
        veilleMerged++;
      }
      veilleUpdated++;
    }
  }

  // ─── 2. Recalculer les champs enrichis pour aap_items ────────────────────
  const aapRows = await db.select().from(aapItems);

  // Grouper par titre normalisé
  const aapGroups = new Map<string, (typeof aapRows)[number][]>();
  for (const row of aapRows) {
    const normalized = buildMergeKey(row.titre || "");
    const key = dedupHash(normalized + "|aap");
    if (!aapGroups.has(key)) aapGroups.set(key, []);
    aapGroups.get(key)!.push(row);
  }

  for (const [, group] of Array.from(aapGroups)) {
    if (group.length === 1) {
      const row = group[0];
      const { region: newRegion, departement: newDept } = detectAapGeo(row.titre || "");
      const normalizedTitle = buildMergeKey(row.titre || "");
      const newDedupKey = dedupHash(normalizedTitle + "|aap");

      await db.update(aapItems)
        .set({
          region: newRegion,
          departement: newDept,
          departements: newDept ? [newDept] : [],
          titre: row.titre,
          dedupKey: newDedupKey,
        })
        .where(eq(aapItems.id, row.id));
      aapUpdated++;
    } else {
      // Fusionner
      const sorted = group.sort((a: (typeof aapRows)[number], b: (typeof aapRows)[number]) => a.id - b.id);
      const primary = sorted[0];
      const duplicates = sorted.slice(1);

      const allDepts: string[] = [];
      for (const row of sorted) {
        const { departement } = detectAapGeo(row.titre || "");
        if (departement && !allDepts.includes(departement)) {
          allDepts.push(departement);
        }
      }

      const normalizedTitle = buildMergeKey(primary.titre || "");
      const newDedupKey = dedupHash(normalizedTitle + "|aap");

      await db.update(aapItems)
        .set({
          region: "Auvergne-Rhône-Alpes",
          departement: allDepts.length > 0 ? allDepts[0] : null,
          departements: allDepts,
          titre: primary.titre,
          dedupKey: newDedupKey,
        })
        .where(eq(aapItems.id, primary.id));

      for (const dup of duplicates) {
        await db.delete(aapItems).where(eq(aapItems.id, dup.id));
        aapMerged++;
      }
      aapUpdated++;
    }
  }

  console.log(`[Migration] Veille: ${veilleUpdated} mis à jour, ${veilleMerged} fusionnés. AAP: ${aapUpdated} mis à jour, ${aapMerged} fusionnés.`);

  return {
    veilleUpdated,
    veilleMerged,
    aapUpdated,
    aapMerged,
    executedAt: new Date().toISOString(),
  };
}

// ─── Point d'entrée principal ─────────────────────────────────────────────────

export interface RssFetchSummary {
  totalFeeds: number;
  successFeeds: number;
  errorFeeds: number;
  totalNewItems: number;
  totalSkippedItems: number;
  totalMergedItems: number;
  results: FetchResult[];
  executedAt: string;
}

export async function runRssFetch(): Promise<RssFetchSummary> {
  const db = await getDb();
  if (!db) throw new Error("Database not available");

  const feeds = await db.select().from(rssFeeds).where(eq(rssFeeds.isActive, true));
  const results: FetchResult[] = [];

  for (const feed of feeds) {
    console.log(`[RSS] Lecture du flux: ${feed.name} (${feed.url})`);
    const result = await processFeed(feed);
    results.push(result);
    console.log(`[RSS] ${feed.name}: ${result.newItems} nouveaux, ${result.mergedItems} fusionnés, ${result.skippedItems} doublons, statut: ${result.status}`);
  }

  const summary: RssFetchSummary = {
    totalFeeds: feeds.length,
    successFeeds: results.filter(r => r.status === "ok").length,
    errorFeeds: results.filter(r => r.status === "error").length,
    totalNewItems: results.reduce((acc, r) => acc + r.newItems, 0),
    totalSkippedItems: results.reduce((acc, r) => acc + r.skippedItems, 0),
    totalMergedItems: results.reduce((acc, r) => acc + r.mergedItems, 0),
    results,
    executedAt: new Date().toISOString(),
  };

  console.log(`[RSS] Terminé: ${summary.totalNewItems} nouveaux, ${summary.totalMergedItems} fusionnés, ${summary.errorFeeds} erreurs`);
  return summary;
}