import datetime as dt
import json
from pathlib import Path


def weekday_de(d: dt.date) -> str:
    names = [
        "Montag",
        "Dienstag",
        "Mittwoch",
        "Donnerstag",
        "Freitag",
        "Samstag",
        "Sonntag",
    ]
    return names[d.weekday()]


def is_leap(year: int) -> bool:
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)


def alts(answer: str) -> list[str]:
    a = answer.strip()
    lower = a.lower()
    out = [lower]
    if a == "Ja":
        out.append("ja")
    if a == "Nein":
        out.append("nein")
    return sorted(set(out))


def build_allgemein() -> list[tuple[str, int, str, str, list[str]]]:
    data = [
        ("USA", "Washington, D.C.", "US-Dollar", "Nordamerika"),
        ("Kanada", "Ottawa", "Kanadischer Dollar", "Nordamerika"),
        ("Mexiko", "Mexiko-Stadt", "Mexikanischer Peso", "Nordamerika"),
        ("Brasilien", "Brasilia", "Brasilianischer Real", "Suedamerika"),
        ("Argentinien", "Buenos Aires", "Argentinischer Peso", "Suedamerika"),
        ("Chile", "Santiago", "Chilenischer Peso", "Suedamerika"),
        ("Kolumbien", "Bogota", "Kolumbianischer Peso", "Suedamerika"),
        ("Peru", "Lima", "Peruanischer Sol", "Suedamerika"),
        ("Vereinigtes Koenigreich", "London", "Pfund Sterling", "Europa"),
        ("Schweiz", "Bern", "Schweizer Franken", "Europa"),
        ("Schweden", "Stockholm", "Schwedische Krone", "Europa"),
        ("Norwegen", "Oslo", "Norwegische Krone", "Europa"),
        ("Daenemark", "Kopenhagen", "Daenische Krone", "Europa"),
        ("Polen", "Warschau", "Zloty", "Europa"),
        ("Tschechien", "Prag", "Tschechische Krone", "Europa"),
        ("Ungarn", "Budapest", "Forint", "Europa"),
        ("Rumaenien", "Bukarest", "Rumaenischer Leu", "Europa"),
        ("Bulgarien", "Sofia", "Lew", "Europa"),
        ("Serbien", "Belgrad", "Serbischer Dinar", "Europa"),
        ("Kroatien", "Zagreb", "Euro", "Europa"),
        ("Japan", "Tokio", "Yen", "Asien"),
        ("China", "Peking", "Renminbi", "Asien"),
        ("Indien", "Neu-Delhi", "Indische Rupie", "Asien"),
        ("Indonesien", "Jakarta", "Indonesische Rupiah", "Asien"),
        ("Thailand", "Bangkok", "Baht", "Asien"),
        ("Vietnam", "Hanoi", "Vietnamesischer Dong", "Asien"),
        ("Suedkorea", "Seoul", "Won", "Asien"),
        ("Philippinen", "Manila", "Philippinischer Peso", "Asien"),
        ("Malaysia", "Kuala Lumpur", "Ringgit", "Asien"),
        ("Singapur", "Singapur", "Singapur-Dollar", "Asien"),
        ("Australien", "Canberra", "Australischer Dollar", "Ozeanien"),
        ("Neuseeland", "Wellington", "Neuseeland-Dollar", "Ozeanien"),
        ("Suedafrika", "Pretoria", "Rand", "Afrika"),
        ("Aegypten", "Kairo", "Aegyptisches Pfund", "Afrika"),
        ("Marokko", "Rabat", "Marokkanischer Dirham", "Afrika"),
        ("Kenia", "Nairobi", "Kenia-Schilling", "Afrika"),
        ("Nigeria", "Abuja", "Naira", "Afrika"),
        ("Israel", "Jerusalem", "Neuer Schekel", "Asien"),
        ("Saudi-Arabien", "Riad", "Saudi-Riyal", "Asien"),
        ("Vereinigte Arabische Emirate", "Abu Dhabi", "VAE-Dirham", "Asien"),
    ]
    rows = []
    for country, capital, currency, continent in data:
        rows.append(
            (
                "Allgemein",
                1,
                f"Was ist die Hauptstadt von {country}?",
                capital,
                alts(capital),
            )
        )
        rows.append(
            (
                "Allgemein",
                2,
                f"Welche Waehrung wird in {country} verwendet?",
                currency,
                alts(currency),
            )
        )
        rows.append(
            (
                "Allgemein",
                3,
                f"Auf welchem Kontinent liegt {country}?",
                continent,
                alts(continent),
            )
        )
    return rows


def build_stadt() -> list[tuple[str, int, str, str, list[str]]]:
    data = [
        ("Tokio", "Japan", "Asien", True),
        ("Sydney", "Australien", "Ozeanien", False),
        ("Toronto", "Kanada", "Nordamerika", False),
        ("New York", "USA", "Nordamerika", False),
        ("Mexiko-Stadt", "Mexiko", "Nordamerika", True),
        ("Sao Paulo", "Brasilien", "Suedamerika", False),
        ("Buenos Aires", "Argentinien", "Suedamerika", True),
        ("Lima", "Peru", "Suedamerika", True),
        ("Santiago", "Chile", "Suedamerika", True),
        ("Bogota", "Kolumbien", "Suedamerika", True),
        ("Kairo", "Aegypten", "Afrika", True),
        ("Nairobi", "Kenia", "Afrika", True),
        ("Lagos", "Nigeria", "Afrika", False),
        ("Casablanca", "Marokko", "Afrika", False),
        ("Johannesburg", "Suedafrika", "Afrika", False),
        ("Paris", "Frankreich", "Europa", True),
        ("London", "Vereinigtes Koenigreich", "Europa", True),
        ("Madrid", "Spanien", "Europa", True),
        ("Rom", "Italien", "Europa", True),
        ("Berlin", "Deutschland", "Europa", True),
        ("Wien", "Oesterreich", "Europa", True),
        ("Prag", "Tschechien", "Europa", True),
        ("Warschau", "Polen", "Europa", True),
        ("Stockholm", "Schweden", "Europa", True),
        ("Oslo", "Norwegen", "Europa", True),
        ("Helsinki", "Finnland", "Europa", True),
        ("Athen", "Griechenland", "Europa", True),
        ("Ankara", "Tuerkei", "Asien", True),
        ("Lissabon", "Portugal", "Europa", True),
        ("Dublin", "Irland", "Europa", True),
        ("Bruessel", "Belgien", "Europa", True),
        ("Amsterdam", "Niederlande", "Europa", True),
        ("Kopenhagen", "Daenemark", "Europa", True),
        ("Budapest", "Ungarn", "Europa", True),
        ("Bukarest", "Rumaenien", "Europa", True),
        ("Sofia", "Bulgarien", "Europa", True),
        ("Belgrad", "Serbien", "Europa", True),
        ("Zagreb", "Kroatien", "Europa", True),
        ("Ljubljana", "Slowenien", "Europa", True),
        ("Riga", "Lettland", "Europa", True),
    ]
    rows = []
    for city, country, continent, is_capital in data:
        rows.append(
            (
                "Stadt",
                1,
                f"In welchem Land liegt die Stadt {city}?",
                country,
                alts(country),
            )
        )
        rows.append(
            (
                "Stadt",
                2,
                f"Auf welchem Kontinent liegt die Stadt {city}?",
                continent,
                alts(continent),
            )
        )
        answer = "Ja" if is_capital else "Nein"
        rows.append(
            (
                "Stadt",
                3,
                f"Ist {city} die Hauptstadt von {country}?",
                answer,
                alts(answer),
            )
        )
    return rows


def build_landkreis() -> list[tuple[str, int, str, str, list[str]]]:
    data = [
        ("B", "Berlin", "Berlin"),
        ("M", "Muenchen", "Bayern"),
        ("N", "Nuernberg", "Bayern"),
        ("A", "Augsburg", "Bayern"),
        ("R", "Regensburg", "Bayern"),
        ("WUE", "Wuerzburg", "Bayern"),
        ("ER", "Erlangen", "Bayern"),
        ("IN", "Ingolstadt", "Bayern"),
        ("PA", "Passau", "Bayern"),
        ("LA", "Landshut", "Bayern"),
        ("S", "Stuttgart", "Baden-Wuerttemberg"),
        ("KA", "Karlsruhe", "Baden-Wuerttemberg"),
        ("FR", "Freiburg im Breisgau", "Baden-Wuerttemberg"),
        ("UL", "Ulm", "Baden-Wuerttemberg"),
        ("TUE", "Tuebingen", "Baden-Wuerttemberg"),
        ("RT", "Reutlingen", "Baden-Wuerttemberg"),
        ("ES", "Esslingen", "Baden-Wuerttemberg"),
        ("HN", "Heilbronn", "Baden-Wuerttemberg"),
        ("HD", "Heidelberg", "Baden-Wuerttemberg"),
        ("MA", "Mannheim", "Baden-Wuerttemberg"),
        ("F", "Frankfurt am Main", "Hessen"),
        ("WI", "Wiesbaden", "Hessen"),
        ("DA", "Darmstadt", "Hessen"),
        ("OF", "Offenbach am Main", "Hessen"),
        ("GI", "Giessen", "Hessen"),
        ("KS", "Kassel", "Hessen"),
        ("H", "Hannover", "Niedersachsen"),
        ("BS", "Braunschweig", "Niedersachsen"),
        ("OS", "Osnabrueck", "Niedersachsen"),
        ("OL", "Oldenburg", "Niedersachsen"),
        ("HH", "Hamburg", "Hamburg"),
        ("HB", "Bremen", "Bremen"),
        ("HL", "Luebeck", "Schleswig-Holstein"),
        ("KI", "Kiel", "Schleswig-Holstein"),
        ("K", "Koeln", "Nordrhein-Westfalen"),
        ("D", "Duesseldorf", "Nordrhein-Westfalen"),
        ("DO", "Dortmund", "Nordrhein-Westfalen"),
        ("E", "Essen", "Nordrhein-Westfalen"),
        ("DU", "Duisburg", "Nordrhein-Westfalen"),
        ("BO", "Bochum", "Nordrhein-Westfalen"),
    ]
    rows = []
    for code, city, state in data:
        rows.append(
            (
                "Landkreis",
                1,
                f"Wofuer steht das Kfz-Kennzeichen {code}?",
                city,
                alts(city),
            )
        )
        rows.append(
            (
                "Landkreis",
                2,
                f"Welches Kfz-Kennzeichen gehoert zu {city}?",
                code,
                alts(code),
            )
        )
        rows.append(
            (
                "Landkreis",
                3,
                f"In welchem Bundesland liegt {city}?",
                state,
                alts(state),
            )
        )
    return rows


def build_lokal() -> list[tuple[str, int, str, str, list[str]]]:
    data = [
        ("Hausnummer", "Nummer eines Gebaeudes in einer Strasse", "Buergeramt", "Wohnsitz melden"),
        ("Postleitzahl", "fuenfstelliger Code fuer Orte in Deutschland", "Buergeramt", "Adressdaten aktualisieren"),
        ("Ortsteil", "kleinerer Teil einer Gemeinde", "Rathaus", "Ortsteilauskunft einholen"),
        ("Stadtteil", "benannter Teilbereich einer Stadt", "Rathaus", "Stadtteilinformationen erhalten"),
        ("Gemeinde", "kleinste kommunale Verwaltungseinheit", "Rathaus", "kommunale Auskunft erhalten"),
        ("Landkreis", "Zusammenschluss mehrerer Gemeinden", "Landratsamt", "Kreisauskunft erhalten"),
        ("Rathaus", "Sitz der Stadtverwaltung", "Rathaus", "allgemeinen Antrag abgeben"),
        ("Buergeramt", "kommunale Anlaufstelle fuer Melde- und Ausweisfragen", "Buergeramt", "Personalausweis beantragen"),
        ("Einwohnermeldeamt", "Amt fuer Meldeangelegenheiten", "Einwohnermeldeamt", "Wohnsitz ummelden"),
        ("Standesamt", "Amt fuer Personenstandsurkunden", "Standesamt", "Geburtsurkunde beantragen"),
        ("Bauamt", "Amt fuer Bauantraege und Bauordnung", "Bauamt", "Baugenehmigung beantragen"),
        ("Ordnungsamt", "Amt fuer Sicherheit und Ordnung", "Ordnungsamt", "Fundanzeige abgeben"),
        ("Gewerbeamt", "Amt fuer Gewerbean-, um- und abmeldung", "Gewerbeamt", "Gewerbe anmelden"),
        ("Zulassungsstelle", "Amt fuer Kfz-Zulassung", "Kfz-Zulassungsstelle", "Auto zulassen"),
        ("Grundbuchamt", "Amt fuer Eintraege zu Grundstuecken", "Amtsgericht", "Grundbuchauszug anfordern"),
        ("Katasteramt", "Amt fuer Flurstuecke und Vermessung", "Katasteramt", "Flurkarte beantragen"),
        ("Finanzamt", "Amt fuer Steuerangelegenheiten", "Finanzamt", "Steueridentifikationsfrage klaeren"),
        ("Volkshochschule", "oeffentliche Einrichtung fuer Weiterbildung", "Volkshochschule", "Kurs buchen"),
        ("Haltestelle", "Ort zum Ein- und Aussteigen im Nahverkehr", "Verkehrsbetrieb", "Fahrplan erfragen"),
        ("Fussgaengerzone", "verkehrsberuhigter Bereich fuer Fussgaenger", "Ordnungsamt", "Sondernutzung anmelden"),
        ("Satzung", "kommunale Rechtsvorschrift", "Rathaus", "Satzung einsehen"),
        ("Baugenehmigung", "behoerdliche Erlaubnis fuer Bauvorhaben", "Bauamt", "Bauprojekt anmelden"),
        ("Meldebescheinigung", "Nachweis ueber den gemeldeten Wohnsitz", "Einwohnermeldeamt", "Meldebescheinigung anfordern"),
        ("Wohnsitzanmeldung", "Meldung eines neuen Haupt- oder Nebenwohnsitzes", "Einwohnermeldeamt", "neuen Wohnsitz anmelden"),
        ("Ummeldung", "Aenderung des Wohnsitzes innerhalb einer Kommune", "Einwohnermeldeamt", "Adresse ummelden"),
        ("Abmeldung", "Abmeldung des Wohnsitzes bei Wegzug", "Einwohnermeldeamt", "Wohnsitz abmelden"),
        ("Personalausweis", "amtlicher Identitaetsnachweis", "Buergeramt", "Personalausweis erneuern"),
        ("Reisepass", "amtliches Dokument fuer Auslandsreisen", "Buergeramt", "Reisepass beantragen"),
        ("Geburtsurkunde", "Urkunde zur Geburt einer Person", "Standesamt", "Geburtsurkunde neu ausstellen"),
        ("Heiratsurkunde", "Urkunde ueber eine Eheschliessung", "Standesamt", "Heiratsurkunde beantragen"),
        ("Sterbeurkunde", "Urkunde ueber einen Sterbefall", "Standesamt", "Sterbeurkunde beantragen"),
        ("Wahlamt", "kommunale Stelle fuer Wahlorganisation", "Wahlamt", "Wahlschein beantragen"),
        ("Briefwahl", "Wahlteilnahme per Post", "Wahlamt", "Briefwahlunterlagen anfordern"),
        ("Notruf 112", "Notrufnummer fuer Feuerwehr und Rettungsdienst", "Leitstelle", "medizinischen Notfall melden"),
        ("Polizei 110", "Notrufnummer fuer die Polizei", "Leitstelle Polizei", "Straftat melden"),
        ("Muellabfuhr", "regelmaessige Abholung von Haushaltsabfaellen", "Entsorgungsbetrieb", "Abholtermin erfragen"),
        ("Sperrmuell", "gesonderte Entsorgung grosser Haushaltsgegenstaende", "Entsorgungsbetrieb", "Sperrmuell anmelden"),
        ("Wertstoffhof", "Sammelstelle fuer verwertbare Abfaelle", "Entsorgungsbetrieb", "Elektroschrott abgeben"),
        ("Gemeindeordnung", "Rechtsgrundlage der kommunalen Selbstverwaltung", "Rathaus", "kommunale Rechtsgrundlage einsehen"),
        ("Anwohnerparkausweis", "Parkerlaubnis fuer Bewohner eines Quartiers", "Ordnungsamt", "Anwohnerparkausweis beantragen"),
    ]
    rows = []
    for term, definition, office, process in data:
        rows.append(
            (
                "Lokal",
                1,
                f"Wie nennt man: {definition}?",
                term,
                alts(term),
            )
        )
        rows.append(
            (
                "Lokal",
                2,
                f"Welche Stelle ist zustaendig fuer: {process}?",
                office,
                alts(office),
            )
        )
        rows.append(
            (
                "Lokal",
                3,
                f"Welches Amt ist typischerweise fuer den Bereich {term} zustaendig?",
                office,
                alts(office),
            )
        )
    return rows


def build_weihnachten() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(2020, 2060))
    rows = []
    for y in years:
        d24 = dt.date(y, 12, 24)
        d25 = dt.date(y, 12, 25)
        d26 = dt.date(y, 12, 26)
        a24 = weekday_de(d24)
        a25 = weekday_de(d25)
        a26 = weekday_de(d26)
        rows.append(
            (
                "Weihnachten",
                1,
                f"Auf welchen Wochentag faellt Heiligabend im Jahr {y}?",
                a24,
                alts(a24),
            )
        )
        rows.append(
            (
                "Weihnachten",
                2,
                f"Auf welchen Wochentag faellt der 1. Weihnachtsfeiertag im Jahr {y}?",
                a25,
                alts(a25),
            )
        )
        rows.append(
            (
                "Weihnachten",
                3,
                f"Auf welchen Wochentag faellt der 2. Weihnachtsfeiertag im Jahr {y}?",
                a26,
                alts(a26),
            )
        )
    return rows


def build_xmas() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(1980, 2020))
    rows = []
    for y in years:
        d25 = dt.date(y, 12, 25)
        d26 = dt.date(y, 12, 26)
        wd25 = weekday_de(d25)
        wd26 = weekday_de(d26)
        daynum = d25.timetuple().tm_yday
        rows.append(
            (
                "XMAS",
                1,
                f"XMAS: Auf welchen Wochentag fiel der Christmas Day (25.12.) im Jahr {y}?",
                wd25,
                alts(wd25),
            )
        )
        rows.append(
            (
                "XMAS",
                2,
                f"XMAS: Auf welchen Wochentag fiel der Boxing Day (26.12.) im Jahr {y}?",
                wd26,
                alts(wd26),
            )
        )
        rows.append(
            (
                "XMAS",
                3,
                f"XMAS: Der wievielte Kalendertag war der 25.12. im Jahr {y}?",
                str(daynum),
                [str(daynum)],
            )
        )
    return rows


def build_winter() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(2020, 2060))
    rows = []
    for y in years:
        feb_days = "29" if is_leap(y) else "28"
        leap_text = "Ja" if is_leap(y) else "Nein"
        dec1 = weekday_de(dt.date(y, 12, 1))
        rows.append(
            (
                "Winter",
                1,
                f"Wie viele Tage hat der Februar im Jahr {y}?",
                feb_days,
                [feb_days],
            )
        )
        rows.append(
            (
                "Winter",
                2,
                f"Ist das Jahr {y} ein Schaltjahr?",
                leap_text,
                alts(leap_text),
            )
        )
        rows.append(
            (
                "Winter",
                3,
                f"Auf welchen Wochentag faellt der meteorologische Winterbeginn (1.12.) im Jahr {y}?",
                dec1,
                alts(dec1),
            )
        )
    return rows


def build_silvester() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(2020, 2060))
    rows = []
    for y in years:
        dec31 = dt.date(y, 12, 31)
        jan1_next = dt.date(y + 1, 1, 1)
        wd_dec31 = weekday_de(dec31)
        days_year = "366" if is_leap(y) else "365"
        wd_next = weekday_de(jan1_next)
        rows.append(
            (
                "Silvester",
                1,
                f"Auf welchen Wochentag faellt Silvester (31.12.) im Jahr {y}?",
                wd_dec31,
                alts(wd_dec31),
            )
        )
        rows.append(
            (
                "Silvester",
                2,
                f"Wie viele Tage hat das Jahr {y} bis inklusive Silvester?",
                days_year,
                [days_year],
            )
        )
        rows.append(
            (
                "Silvester",
                3,
                f"Auf welchen Wochentag faellt der Tag nach Silvester des Jahres {y}?",
                wd_next,
                alts(wd_next),
            )
        )
    return rows


def build_neujahr() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(1980, 2020))
    rows = []
    for y in years:
        jan1 = dt.date(y, 1, 1)
        jan2 = dt.date(y, 1, 2)
        wd_jan1 = weekday_de(jan1)
        wd_jan2 = weekday_de(jan2)
        days_total = "366" if is_leap(y) else "365"
        rows.append(
            (
                "Neujahr",
                1,
                f"Auf welchen Wochentag faellt Neujahr (1.1.) im Jahr {y}?",
                wd_jan1,
                alts(wd_jan1),
            )
        )
        rows.append(
            (
                "Neujahr",
                2,
                f"Wie viele Tage hat das Kalenderjahr {y} insgesamt?",
                days_total,
                [days_total],
            )
        )
        rows.append(
            (
                "Neujahr",
                3,
                f"Auf welchen Wochentag faellt der 2. Januar im Jahr {y}?",
                wd_jan2,
                alts(wd_jan2),
            )
        )
    return rows


def build_jahreswechsel() -> list[tuple[str, int, str, str, list[str]]]:
    years = list(range(2020, 2060))
    rows = []
    for y in years:
        dec31 = dt.date(y, 12, 31)
        jan1 = dt.date(y, 1, 1)
        iso_week_dec31 = str(dec31.isocalendar().week)
        iso_week_jan1 = str(jan1.isocalendar().week)
        iso_year_dec31 = str(dec31.isocalendar().year)
        rows.append(
            (
                "Jahreswechsel",
                1,
                f"Welche ISO-Kalenderwoche hat der 31.12.{y}?",
                iso_week_dec31,
                [iso_week_dec31],
            )
        )
        rows.append(
            (
                "Jahreswechsel",
                2,
                f"Welche ISO-Kalenderwoche hat der 01.01.{y}?",
                iso_week_jan1,
                [iso_week_jan1],
            )
        )
        rows.append(
            (
                "Jahreswechsel",
                3,
                f"Zu welchem ISO-Jahr gehoert der 31.12.{y}?",
                iso_year_dec31,
                [iso_year_dec31],
            )
        )
    return rows


def validate(rows: list[tuple[str, int, str, str, list[str]]]) -> None:
    expected_categories = [
        "Allgemein",
        "Stadt",
        "Landkreis",
        "Lokal",
        "Weihnachten",
        "XMAS",
        "Winter",
        "Silvester",
        "Neujahr",
        "Jahreswechsel",
    ]
    counts: dict[tuple[str, int], int] = {}
    questions_seen: set[str] = set()

    for cat, diff, q, _a, _alts in rows:
        key = (cat, diff)
        counts[key] = counts.get(key, 0) + 1
        q_norm = q.strip().lower()
        if q_norm in questions_seen:
            raise ValueError(f"Doppelte Frage gefunden: {q}")
        questions_seen.add(q_norm)

    for cat in expected_categories:
        for diff in (1, 2, 3):
            got = counts.get((cat, diff), 0)
            if got != 40:
                raise ValueError(f"Falsche Anzahl fuer {cat} diff {diff}: {got} statt 40")

    if len(rows) != 1200:
        raise ValueError(f"Gesamtanzahl ist {len(rows)} statt 1200")


def write_sql(rows: list[tuple[str, int, str, str, list[str]]], out_path: Path) -> None:
    lines: list[str] = []
    lines.append("-- 1200 unique real quiz questions")
    lines.append("-- 10 Kategorien x 3 Schwierigkeitsstufen x 40 Fragen")
    lines.append("START TRANSACTION;")
    lines.append("")
    lines.append("CREATE TABLE IF NOT EXISTS quiz_questions (")
    lines.append("  id BIGINT NOT NULL AUTO_INCREMENT,")
    lines.append("  question TEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,")
    lines.append("  answers_json LONGTEXT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL,")
    lines.append("  category VARCHAR(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL,")
    lines.append("  difficulty TINYINT NULL,")
    lines.append("  is_active TINYINT(1) NOT NULL DEFAULT 1,")
    lines.append("  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,")
    lines.append("  PRIMARY KEY (id),")
    lines.append("  KEY idx_active (is_active),")
    lines.append("  KEY idx_category (category),")
    lines.append("  KEY idx_diff (difficulty)")
    lines.append(") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;")
    lines.append("")
    lines.append("DELETE FROM quiz_questions;")
    lines.append("")
    lines.append("INSERT INTO quiz_questions (question, answers_json, category, difficulty, is_active, created_at) VALUES")

    values = []
    for cat, diff, q, answer, alt_list in rows:
        answers_json = json.dumps({"correct": answer, "alts": alt_list}, ensure_ascii=False)
        q_sql = q.replace("'", "''")
        cat_sql = cat.replace("'", "''")
        aj_sql = answers_json.replace("'", "''")
        values.append(f"('{q_sql}', '{aj_sql}', '{cat_sql}', {diff}, 1, NOW())")

    lines.append(",\n".join(values) + ";")
    lines.append("")
    lines.append("COMMIT;")
    out_path.write_text("\n".join(lines), encoding="utf-8")


def main() -> None:
    rows = []
    rows.extend(build_allgemein())
    rows.extend(build_stadt())
    rows.extend(build_landkreis())
    rows.extend(build_lokal())
    rows.extend(build_weihnachten())
    rows.extend(build_xmas())
    rows.extend(build_winter())
    rows.extend(build_silvester())
    rows.extend(build_neujahr())
    rows.extend(build_jahreswechsel())

    validate(rows)

    root = Path(__file__).resolve().parents[1]
    out = root / "migrations" / "2026-04-20_seed_quiz_questions_1200_unique.sql"
    write_sql(rows, out)
    print(f"Wrote {out} with {len(rows)} rows.")


if __name__ == "__main__":
    main()