import { NextRequest, NextResponse } from "next/server";

export const runtime = "nodejs";

interface ActualiteitResultaat {
  gepubliceerdOp: string | null;
  isActueel: boolean | null;
  melding: string;
  bron: "codex-vlaanderen" | "manueel" | "fout";
}

// Patronen voor datum in Codex Vlaanderen HTML
const DATUM_PATRONEN = [
  // "Datum laatste wijziging: 01/01/2024"
  /[Dd]atum\s+(?:laatste\s+)?(?:aanpassing|wijziging|publicatie|bekendmaking)[:\s]+(\d{2}\/\d{2}\/\d{4})/,
  // "Geconsolideerde versie - 01/01/2024"
  /[Gg]econsolideerde\s+versie\s*[-–]\s*(\d{2}\/\d{2}\/\d{4})/,
  // <meta> tags
  /<meta[^>]+name=["'](?:date|dcterms.modified|last-modified)["'][^>]+content=["']([^"']+)["']/i,
  // JSON-LD datestamp
  /"dateModified"\s*:\s*"([^"]+)"/,
  // Belgisch Staatsblad / Justel: "Publicatiedatum: 01/01/2024"
  /[Pp]ublicatiedatum[:\s]+(\d{2}\/\d{2}\/\d{4})/,
  // ISO date in meta
  /content=["'](\d{4}-\d{2}-\d{2})["'][^>]*(?:name|property)=["'](?:date|modified)/i,
];

function parseDatum(html: string): string | null {
  for (const patroon of DATUM_PATRONEN) {
    const match = html.match(patroon);
    if (match?.[1]) {
      const raw = match[1];
      // Normaliseer dd/mm/yyyy naar yyyy-mm-dd
      if (/^\d{2}\/\d{2}\/\d{4}$/.test(raw)) {
        const [d, m, y] = raw.split("/");
        return `${y}-${m}-${d}`;
      }
      // ISO formaat, gebruik direct
      if (/^\d{4}-\d{2}-\d{2}/.test(raw)) {
        return raw.slice(0, 10);
      }
    }
  }
  return null;
}

export async function GET(req: NextRequest) {
  const url = req.nextUrl.searchParams.get("url");
  const oudeVersie = req.nextUrl.searchParams.get("versie"); // bv. "2024-01-01"

  if (!url) {
    return NextResponse.json<ActualiteitResultaat>({
      gepubliceerdOp: null,
      isActueel: null,
      melding: "Geen URL opgegeven",
      bron: "fout",
    }, { status: 400 });
  }

  // Whitelist: enkel officiële Belgische bronnen
  const toegestaan = [
    "codex.vlaanderen.be",
    "ejustice.just.fgov.be",
    "wallonie.be",
    "leefmilieu.brussels",
    "bru.be",
  ];
  let hostname: string;
  try {
    hostname = new URL(url).hostname;
  } catch {
    return NextResponse.json<ActualiteitResultaat>({
      gepubliceerdOp: null,
      isActueel: null,
      melding: "Ongeldige URL",
      bron: "fout",
    }, { status: 400 });
  }

  if (!toegestaan.some((t) => hostname.endsWith(t))) {
    return NextResponse.json<ActualiteitResultaat>({
      gepubliceerdOp: null,
      isActueel: null,
      melding: "Bron niet ondersteund voor automatische controle",
      bron: "manueel",
    });
  }

  try {
    const response = await fetch(url, {
      headers: {
        "User-Agent": "NotaryAI-ActualiteitsCheck/1.0",
        Accept: "text/html,application/xhtml+xml",
      },
      signal: AbortSignal.timeout(8000),
    });

    if (!response.ok) {
      return NextResponse.json<ActualiteitResultaat>({
        gepubliceerdOp: null,
        isActueel: null,
        melding: `Bron niet bereikbaar (HTTP ${response.status})`,
        bron: "fout",
      });
    }

    // Controleer Last-Modified header eerst
    let gevondenDatum: string | null = null;
    const lastModHeader = response.headers.get("last-modified");
    if (lastModHeader) {
      const d = new Date(lastModHeader);
      if (!isNaN(d.getTime())) {
        gevondenDatum = d.toISOString().slice(0, 10);
      }
    }

    // Scan de HTML-inhoud op datumpatronen
    if (!gevondenDatum) {
      // Lees enkel de eerste 50KB — datum staat altijd bovenaan
      const reader = response.body?.getReader();
      let html = "";
      let bytes = 0;
      if (reader) {
        while (bytes < 50_000) {
          const { done, value } = await reader.read();
          if (done) break;
          html += new TextDecoder().decode(value);
          bytes += value.byteLength;
        }
        reader.cancel();
      }
      gevondenDatum = parseDatum(html);
    }

    if (!gevondenDatum) {
      return NextResponse.json<ActualiteitResultaat>({
        gepubliceerdOp: null,
        isActueel: null,
        melding: "Datum niet gevonden in bron — controleer manueel",
        bron: "codex-vlaanderen",
      });
    }

    // Vergelijk met opgeslagen versie
    let isActueel: boolean | null = null;
    if (oudeVersie) {
      // Extraheer datum uit versiestring (bv. "geconsolideerd per 2024-01-01")
      const versieMatch = oudeVersie.match(/(\d{4}-\d{2}-\d{2})/);
      if (versieMatch) {
        isActueel = gevondenDatum <= versieMatch[1];
      }
    }

    return NextResponse.json<ActualiteitResultaat>({
      gepubliceerdOp: gevondenDatum,
      isActueel,
      melding: isActueel === false
        ? `Nieuwe versie gevonden: ${gevondenDatum} (uw versie: ${oudeVersie})`
        : isActueel === true
        ? "Tekst is actueel"
        : `Laatste publicatie: ${gevondenDatum}`,
      bron: hostname.includes("codex.vlaanderen.be") ? "codex-vlaanderen" : "codex-vlaanderen",
    });
  } catch (err) {
    const msg = err instanceof Error ? err.message : "Onbekende fout";
    return NextResponse.json<ActualiteitResultaat>({
      gepubliceerdOp: null,
      isActueel: null,
      melding: `Verbindingsfout: ${msg}`,
      bron: "fout",
    });
  }
}