from __future__ import annotations

import argparse
from contextlib import contextmanager
from difflib import SequenceMatcher
from email.parser import BytesParser
from email.policy import default as email_policy
import hashlib
import html
import hmac
import io
import json
import os
import random
import re
import secrets
import shutil
import sqlite3
import subprocess
import threading
import time
import zipfile
from cryptography.fernet import Fernet, InvalidToken
from datetime import datetime, timedelta, timezone
from html.parser import HTMLParser
from http import HTTPStatus
from http.cookies import SimpleCookie
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from typing import Any, Iterator
from urllib.error import HTTPError, URLError
from urllib.parse import parse_qs, quote, unquote, urlparse
from urllib.request import Request, urlopen


BASE_DIR = Path(__file__).resolve().parent
DATA_DIR = BASE_DIR / "data"
PUBLIC_DIR = BASE_DIR / "public"
GENERATED_DIR = BASE_DIR / "generated"
UPLOAD_DIR = BASE_DIR / "uploads"
TEMPLATE_DIR = BASE_DIR / "TEMPLATE89"
AMP_TEMPLATE_DIR = BASE_DIR / "AMPALL"
DB_PATH = DATA_DIR / "adminseo.sqlite3"
SCHEMA_PATH = BASE_DIR / "schema.sql"
AMP_VALIDATOR_SCRIPT = BASE_DIR / "tools" / "validate-amp.cjs"
SESSION_COOKIE = "adminseo_session"
SESSION_DAYS = 7
PASSWORD_ITERATIONS = 260_000
MAX_FORM_BODY_BYTES = int(os.environ.get("ADMINSEO_MAX_FORM_BYTES", str(2 * 1024 * 1024)))
MAX_UPLOAD_BODY_BYTES = int(os.environ.get("ADMINSEO_MAX_UPLOAD_BYTES", str(32 * 1024 * 1024)))
FORCE_SECURE_COOKIE = os.environ.get("ADMINSEO_SECURE_COOKIE", "").strip().lower() in {"1", "true", "yes", "on"}
LOGIN_ATTEMPT_WINDOW_SECONDS = 15 * 60
LOGIN_MAX_FAILURES = 6
LOGIN_FAILURES: dict[str, list[float]] = {}
LOGIN_FAILURES_LOCK = threading.Lock()
DEFAULT_USERNAME = os.environ.get("ADMINSEO_USERNAME", "admin")
DEFAULT_PASSWORD = os.environ.get("ADMINSEO_PASSWORD", "adminseo89")
SECONDARY_USERNAME = os.environ.get("ADMINSEO_SECOND_USERNAME", "admin2")
SECONDARY_PASSWORD = os.environ.get("ADMINSEO_SECOND_PASSWORD", "admin2seo89")
RANDOM_TEMPLATE_KEY = "__random__"
RANDOM_AMP_TEMPLATE_KEY = "__random_amp__"
OPENAI_API_BASE_URL = "https://api.openai.com/v1"
DEFAULT_OPENAI_MODEL = "gpt-5.6-terra"
OPENAI_MODEL_GROUPS = (
    (
        "GPT-5.6 - Rekomendasi terbaru",
        (
            ("gpt-5.6-terra", "GPT-5.6 Terra", "Tinggi", "Seimbang", "Landing page produksi dan batch"),
            ("gpt-5.6-sol", "GPT-5.6 Sol", "Maksimum", "Lebih lambat", "Konten premium dan pekerjaan kompleks"),
            ("gpt-5.6-luna", "GPT-5.6 Luna", "Baik", "Sangat cepat", "Batch volume tinggi dan hemat"),
        ),
    ),
    (
        "GPT-5.5 dan GPT-5.4",
        (
            ("gpt-5.5", "GPT-5.5", "Sangat tinggi", "Sedang", "Konten profesional"),
            ("gpt-5.5-pro", "GPT-5.5 Pro", "Maksimum", "Lebih lambat", "Pekerjaan presisi tinggi"),
            ("gpt-5.4", "GPT-5.4", "Sangat tinggi", "Sedang", "Konten profesional generasi sebelumnya"),
            ("gpt-5.4-pro", "GPT-5.4 Pro", "Maksimum", "Lebih lambat", "Pekerjaan kompleks generasi sebelumnya"),
            ("gpt-5.4-mini", "GPT-5.4 Mini", "Tinggi", "Cepat", "Batch berkualitas dengan biaya lebih ringan"),
            ("gpt-5.4-nano", "GPT-5.4 Nano", "Dasar", "Sangat cepat", "Draft sederhana dan volume besar"),
        ),
    ),
    (
        "Model kompatibel lainnya",
        (
            ("gpt-5.2", "GPT-5.2", "Tinggi", "Sedang", "Model frontier sebelumnya"),
            ("gpt-5.2-pro", "GPT-5.2 Pro", "Sangat tinggi", "Lebih lambat", "Model presisi sebelumnya"),
            ("gpt-5.1", "GPT-5.1", "Tinggi", "Sedang", "Reasoning dan konten umum"),
            ("gpt-5", "GPT-5", "Tinggi", "Sedang", "Reasoning dan konten umum"),
            ("gpt-5-pro", "GPT-5 Pro", "Sangat tinggi", "Lebih lambat", "Reasoning lebih mendalam"),
            ("gpt-5-mini", "GPT-5 Mini", "Baik", "Cepat", "Tugas terarah dan batch"),
            ("gpt-5-nano", "GPT-5 Nano", "Dasar", "Sangat cepat", "Ekstraksi dan draft singkat"),
            ("gpt-4.1", "GPT-4.1", "Baik", "Cepat", "Model non-reasoning untuk instruksi presisi"),
            ("gpt-4.1-mini", "GPT-4.1 Mini", "Baik", "Sangat cepat", "Konten ringan dan terarah"),
            ("gpt-4o", "GPT-4o", "Baik", "Cepat", "Model multimodal umum"),
            ("gpt-4o-mini", "GPT-4o Mini", "Dasar", "Sangat cepat", "Konten sederhana dan hemat"),
        ),
    ),
)
CONTENT_ANGLES = [
    "solusi praktis untuk kebutuhan harian",
    "pilihan cepat untuk pengunjung yang butuh informasi jelas",
    "halaman penawaran yang fokus pada kepercayaan",
    "konten ringan untuk memperkuat keputusan pembeli",
    "pengalaman online yang rapi dan mudah dipahami",
    "presentasi brand yang lebih profesional",
    "jalur konversi sederhana dari kunjungan ke aksi",
    "referensi lengkap untuk calon pelanggan Indonesia",
    "landing page cepat dengan struktur SEO matang",
    "halaman promosi yang siap dipakai lintas perangkat",
]
WORKFLOW_SEPARATORS = ["|", ">", ":", "-", "x"]
WORKFLOW_AMP_WORDS = ["lament", "deus", "rosea", "orbit", "metro", "nusa", "ceria", "prime", "akses", "nova"]
NICHE_HINTS = [
    (("burger", "food", "resto", "restaurant", "restaurante", "restaurantes", "pizza", "pizz", "cafe", "bar"), "kuliner, restoran, menu favorit, layanan pesan, dan pengalaman makan"),
    (("disco", "pub", "club", "music", "concert", "konser", "festival"), "hiburan malam, musik, acara komunitas, venue, dan suasana kunjungan"),
    (("abogado", "abogados", "law", "legal", "garcia", "pulido"), "layanan hukum, konsultasi, dokumen legal, dan kebutuhan klien"),
    (("store", "shop", "market", "asian", "fashion", "moda", "butik"), "produk pilihan, kategori belanja, gaya hidup, dan kebutuhan harian"),
    (("hotel", "villa", "travel", "tour", "wisata"), "akomodasi, perjalanan, fasilitas, lokasi, dan rencana kunjungan"),
]
INDONESIAN_PERSONAS = [
    ("Andi Pratama", "Jakarta", "Saya suka karena informasinya langsung jelas. Tampilan halaman terasa ringan dan tombol aksinya mudah ditemukan."),
    ("Dewi Lestari", "Bandung", "Kontennya rapi, tidak bertele-tele, dan membantu saya memahami penawaran sebelum mengambil keputusan."),
    ("Rizky Maulana", "Surabaya", "Halamannya cepat dibuka di HP. Bagian artikel dan FAQ membuat saya lebih yakin untuk lanjut."),
    ("Sinta Rahma", "Yogyakarta", "Gambar utama dan penjelasan produknya terasa pas. Saya bisa membandingkan manfaatnya tanpa bingung."),
    ("Bima Saputra", "Medan", "Struktur informasinya enak dibaca. Review pengguna dan CTA membuat halaman terasa lebih terpercaya."),
    ("Nadia Putri", "Semarang", "Saya tertarik karena headline-nya relevan dan penjelasan awalnya langsung menjawab kebutuhan saya."),
    ("Fajar Nugroho", "Makassar", "Landing page-nya terlihat profesional. Dari judul sampai FAQ semuanya terasa konsisten."),
    ("Maya Kirana", "Denpasar", "Bagian review memberi gambaran nyata dari sisi pengguna. Ini membantu saya lebih cepat percaya."),
    ("Teguh Santoso", "Palembang", "Navigasinya sederhana dan kontennya jelas. Saya langsung tahu harus klik ke mana."),
    ("Laras Ayu", "Balikpapan", "Suka dengan kombinasi gambar, artikel, dan tombol aksinya. Rasanya tidak kaku."),
]
MEDIA_ROLES = {
    "logo_media_id": "Logo",
    "icon_media_id": "Icon",
    "main_media_id": "Gambar Utama",
}
ALLOWED_IMAGE_TYPES = {
    "image/jpeg": ".jpg",
    "image/png": ".png",
    "image/webp": ".webp",
    "image/gif": ".gif",
    "image/svg+xml": ".svg",
    "image/x-icon": ".ico",
}


FALLBACK_TEMPLATES = {
    "clean-saas": {
        "name": "Clean SaaS",
        "accent": "#2563eb",
        "hero": "Landing page modern untuk produk digital, jasa, dan funnel penjualan.",
        "source": "built-in",
    },
    "local-service": {
        "name": "Local Service",
        "accent": "#0f766e",
        "hero": "Landing page terpercaya untuk bisnis lokal, jasa profesional, dan booking.",
        "source": "built-in",
    },
    "affiliate-offer": {
        "name": "Affiliate Offer",
        "accent": "#b45309",
        "hero": "Landing page cepat untuk review produk, offer, dan campaign affiliate.",
        "source": "built-in",
    },
}

REQUIRED_LANDING_FIELDS = {
    "template_key": "Template Menu",
    "seo_title": "SEO Title",
    "meta_description": "Meta Description",
    "keywords": "Keywords",
    "cta_url": "URL CTA",
}

AI_LANDING_CONTENT_SCHEMA = {
    "type": "object",
    "additionalProperties": False,
    "properties": {
        "seo_title": {"type": "string"},
        "meta_description": {"type": "string"},
        "keywords": {
            "type": "array",
            "items": {"type": "string"},
            "minItems": 5,
            "maxItems": 8,
        },
        "hero_heading": {"type": "string"},
        "hero_subheading": {"type": "string"},
        "cta_label": {"type": "string"},
        "article_sections": {
            "type": "array",
            "minItems": 5,
            "maxItems": 5,
            "items": {
                "type": "object",
                "additionalProperties": False,
                "properties": {
                    "heading": {"type": "string"},
                    "body": {"type": "string"},
                },
                "required": ["heading", "body"],
            },
        },
        "faqs": {
            "type": "array",
            "minItems": 5,
            "maxItems": 5,
            "items": {
                "type": "object",
                "additionalProperties": False,
                "properties": {
                    "question": {"type": "string"},
                    "answer": {"type": "string"},
                },
                "required": ["question", "answer"],
            },
        },
        "reviews": {
            "type": "array",
            "minItems": 5,
            "maxItems": 5,
            "items": {
                "type": "object",
                "additionalProperties": False,
                "properties": {
                    "name": {"type": "string"},
                    "city": {"type": "string"},
                    "rating": {"type": "integer"},
                    "body": {"type": "string"},
                },
                "required": ["name", "city", "rating", "body"],
            },
        },
    },
    "required": [
        "seo_title",
        "meta_description",
        "keywords",
        "hero_heading",
        "hero_subheading",
        "cta_label",
        "article_sections",
        "faqs",
        "reviews",
    ],
}


def utc_now() -> str:
    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()


@contextmanager
def db() -> Iterator[sqlite3.Connection]:
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    connection = sqlite3.connect(DB_PATH)
    connection.row_factory = sqlite3.Row
    try:
        yield connection
        connection.commit()
    except Exception:
        connection.rollback()
        raise
    finally:
        connection.close()


def init_db() -> None:
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    with db() as connection:
        connection.executescript(SCHEMA_PATH.read_text(encoding="utf-8"))
        ensure_default_users(connection)
        ensure_project_columns(connection)
        ensure_user_scope(connection)
        cleanup_sessions(connection)
        connection.execute("PRAGMA optimize")
    migrate_generated_storage()
    refresh_domain_txt()


def ensure_project_columns(connection: sqlite3.Connection) -> None:
    existing_columns = {
        row["name"]
        for row in connection.execute("PRAGMA table_info(projects)").fetchall()
    }
    migrations = {
        "amp_template_key": "ALTER TABLE projects ADD COLUMN amp_template_key TEXT NOT NULL DEFAULT '__random_amp__'",
        "article_body": "ALTER TABLE projects ADD COLUMN article_body TEXT NOT NULL DEFAULT ''",
        "use_ai_content": "ALTER TABLE projects ADD COLUMN use_ai_content INTEGER NOT NULL DEFAULT 0",
        "ai_content_mode": "ALTER TABLE projects ADD COLUMN ai_content_mode TEXT NOT NULL DEFAULT 'rewrite'",
        "ai_instructions": "ALTER TABLE projects ADD COLUMN ai_instructions TEXT NOT NULL DEFAULT ''",
        "ai_content_json": "ALTER TABLE projects ADD COLUMN ai_content_json TEXT NOT NULL DEFAULT '{}'",
        "ai_generated_at": "ALTER TABLE projects ADD COLUMN ai_generated_at TEXT",
        "amp_url": "ALTER TABLE projects ADD COLUMN amp_url TEXT NOT NULL DEFAULT ''",
        "alternate_links": "ALTER TABLE projects ADD COLUMN alternate_links TEXT NOT NULL DEFAULT ''",
        "generate_faq": "ALTER TABLE projects ADD COLUMN generate_faq INTEGER NOT NULL DEFAULT 1",
        "generate_reviews": "ALTER TABLE projects ADD COLUMN generate_reviews INTEGER NOT NULL DEFAULT 1",
        "audit_before_save": "ALTER TABLE projects ADD COLUMN audit_before_save INTEGER NOT NULL DEFAULT 1",
        "logo_media_id": "ALTER TABLE projects ADD COLUMN logo_media_id INTEGER",
        "icon_media_id": "ALTER TABLE projects ADD COLUMN icon_media_id INTEGER",
        "main_media_id": "ALTER TABLE projects ADD COLUMN main_media_id INTEGER",
        "last_template_key": "ALTER TABLE projects ADD COLUMN last_template_key TEXT NOT NULL DEFAULT ''",
        "last_amp_template_key": "ALTER TABLE projects ADD COLUMN last_amp_template_key TEXT NOT NULL DEFAULT ''",
        "publication_status": "ALTER TABLE projects ADD COLUMN publication_status TEXT NOT NULL DEFAULT 'draft'",
        "finishing_report": "ALTER TABLE projects ADD COLUMN finishing_report TEXT NOT NULL DEFAULT '{}'",
        "finishing_checked_at": "ALTER TABLE projects ADD COLUMN finishing_checked_at TEXT",
        "approved_at": "ALTER TABLE projects ADD COLUMN approved_at TEXT",
    }
    for column, statement in migrations.items():
        if column not in existing_columns:
            connection.execute(statement)
    connection.execute(
        """
        UPDATE projects
        SET publication_status = 'pending'
        WHERE last_generated_at IS NOT NULL
          AND publication_status = 'draft'
        """
    )
    connection.execute(
        """
        CREATE INDEX IF NOT EXISTS idx_projects_publication_status_generated
        ON projects(publication_status, last_generated_at)
        """
    )


def hash_password(password: str, salt: str | None = None) -> str:
    salt = salt or secrets.token_hex(16)
    digest = hashlib.pbkdf2_hmac(
        "sha256",
        password.encode("utf-8"),
        bytes.fromhex(salt),
        PASSWORD_ITERATIONS,
    ).hex()
    return f"pbkdf2_sha256${PASSWORD_ITERATIONS}${salt}${digest}"


def verify_password(password: str, stored_hash: str) -> bool:
    try:
        algorithm, iterations, salt, expected = stored_hash.split("$", 3)
        if algorithm != "pbkdf2_sha256":
            return False
        digest = hashlib.pbkdf2_hmac(
            "sha256",
            password.encode("utf-8"),
            bytes.fromhex(salt),
            int(iterations),
        ).hex()
        return hmac.compare_digest(digest, expected)
    except (ValueError, TypeError):
        return False


def ensure_default_users(connection: sqlite3.Connection) -> None:
    now = utc_now()
    for username, password in (
        (DEFAULT_USERNAME, DEFAULT_PASSWORD),
        (SECONDARY_USERNAME, SECONDARY_PASSWORD),
    ):
        existing = connection.execute(
            "SELECT id FROM users WHERE username = ?",
            (username,),
        ).fetchone()
        if existing:
            continue
        connection.execute(
            """
            INSERT INTO users (username, password_hash, created_at, updated_at)
            VALUES (?, ?, ?, ?)
            """,
            (username, hash_password(password), now, now),
        )


def rebuild_projects_for_user_scope(connection: sqlite3.Connection) -> None:
    connection.execute("DROP TABLE IF EXISTS projects_scoped")
    connection.execute(
        """
        CREATE TABLE projects_scoped (
          id INTEGER PRIMARY KEY,
          user_id INTEGER NOT NULL,
          domain_url TEXT NOT NULL,
          hostname TEXT NOT NULL,
          slug TEXT NOT NULL,
          template_key TEXT NOT NULL DEFAULT 'clean-saas',
          amp_template_key TEXT NOT NULL DEFAULT '__random_amp__',
          seo_title TEXT NOT NULL,
          meta_description TEXT NOT NULL DEFAULT '',
          keywords TEXT NOT NULL DEFAULT '',
          hero_heading TEXT NOT NULL DEFAULT '',
          hero_subheading TEXT NOT NULL DEFAULT '',
          article_body TEXT NOT NULL DEFAULT '',
          cta_label TEXT NOT NULL DEFAULT 'Mulai Sekarang',
          cta_url TEXT NOT NULL DEFAULT '',
          use_ai_content INTEGER NOT NULL DEFAULT 0,
          ai_content_mode TEXT NOT NULL DEFAULT 'rewrite',
          ai_instructions TEXT NOT NULL DEFAULT '',
          ai_content_json TEXT NOT NULL DEFAULT '{}',
          ai_generated_at TEXT,
          amp_url TEXT NOT NULL DEFAULT '',
          alternate_links TEXT NOT NULL DEFAULT '',
          generate_faq INTEGER NOT NULL DEFAULT 1,
          generate_reviews INTEGER NOT NULL DEFAULT 1,
          audit_before_save INTEGER NOT NULL DEFAULT 1,
          logo_media_id INTEGER,
          icon_media_id INTEGER,
          main_media_id INTEGER,
          title_included INTEGER NOT NULL DEFAULT 1,
          generated_path TEXT,
          generated_urls TEXT NOT NULL DEFAULT '[]',
          last_template_key TEXT NOT NULL DEFAULT '',
          last_amp_template_key TEXT NOT NULL DEFAULT '',
          publication_status TEXT NOT NULL DEFAULT 'draft',
          finishing_report TEXT NOT NULL DEFAULT '{}',
          finishing_checked_at TEXT,
          approved_at TEXT,
          last_generated_at TEXT,
          created_at TEXT NOT NULL,
          updated_at TEXT NOT NULL,
          UNIQUE(user_id, domain_url),
          FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
        )
        """
    )
    columns = [row["name"] for row in connection.execute("PRAGMA table_info(projects)")]
    column_list = ", ".join(columns)
    connection.execute(
        f"INSERT INTO projects_scoped ({column_list}) SELECT {column_list} FROM projects"
    )
    connection.execute("DROP TABLE projects")
    connection.execute("ALTER TABLE projects_scoped RENAME TO projects")


def rebuild_media_groups_for_user_scope(connection: sqlite3.Connection) -> None:
    connection.execute("DROP TABLE IF EXISTS media_groups_scoped")
    connection.execute(
        """
        CREATE TABLE media_groups_scoped (
          id INTEGER PRIMARY KEY,
          user_id INTEGER NOT NULL,
          name TEXT NOT NULL,
          logo_media_id INTEGER NOT NULL,
          icon_media_id INTEGER NOT NULL,
          main_media_id INTEGER NOT NULL,
          created_at TEXT NOT NULL,
          updated_at TEXT NOT NULL,
          UNIQUE(user_id, name),
          FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
          FOREIGN KEY (logo_media_id) REFERENCES media_assets(id),
          FOREIGN KEY (icon_media_id) REFERENCES media_assets(id),
          FOREIGN KEY (main_media_id) REFERENCES media_assets(id)
        )
        """
    )
    columns = [row["name"] for row in connection.execute("PRAGMA table_info(media_groups)")]
    column_list = ", ".join(columns)
    connection.execute(
        f"INSERT INTO media_groups_scoped ({column_list}) SELECT {column_list} FROM media_groups"
    )
    connection.execute("DROP TABLE media_groups")
    connection.execute("ALTER TABLE media_groups_scoped RENAME TO media_groups")


def ensure_user_scope(connection: sqlite3.Connection) -> None:
    owner = connection.execute(
        "SELECT id FROM users WHERE username = ?",
        (DEFAULT_USERNAME,),
    ).fetchone() or connection.execute("SELECT id FROM users ORDER BY id LIMIT 1").fetchone()
    if not owner:
        raise RuntimeError("Akun pemilik default tidak tersedia.")
    owner_id = int(owner["id"])

    for table in ("projects", "media_assets", "media_groups"):
        columns = {row["name"] for row in connection.execute(f"PRAGMA table_info({table})")}
        if "user_id" not in columns:
            connection.execute(f"ALTER TABLE {table} ADD COLUMN user_id INTEGER")
        connection.execute(f"UPDATE {table} SET user_id = ? WHERE user_id IS NULL", (owner_id,))

    project_sql = str(connection.execute(
        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'projects'"
    ).fetchone()["sql"] or "")
    if "unique(user_id,domain_url)" not in re.sub(r"\s+", "", project_sql.lower()):
        rebuild_projects_for_user_scope(connection)

    group_sql = str(connection.execute(
        "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'media_groups'"
    ).fetchone()["sql"] or "")
    if "unique(user_id,name)" not in re.sub(r"\s+", "", group_sql.lower()):
        rebuild_media_groups_for_user_scope(connection)

    connection.executescript(
        """
        CREATE INDEX IF NOT EXISTS idx_projects_updated_at ON projects(updated_at);
        CREATE INDEX IF NOT EXISTS idx_projects_user_updated_at ON projects(user_id, updated_at);
        CREATE INDEX IF NOT EXISTS idx_projects_publication_status_generated
          ON projects(publication_status, last_generated_at);
        CREATE INDEX IF NOT EXISTS idx_generation_logs_project_id ON generation_logs(project_id);
        CREATE INDEX IF NOT EXISTS idx_media_assets_created_at ON media_assets(created_at);
        CREATE INDEX IF NOT EXISTS idx_media_assets_user_created_at ON media_assets(user_id, created_at);
        CREATE INDEX IF NOT EXISTS idx_media_groups_updated_at ON media_groups(updated_at);
        CREATE INDEX IF NOT EXISTS idx_media_groups_user_updated_at ON media_groups(user_id, updated_at);
        """
    )


def cleanup_sessions(connection: sqlite3.Connection) -> None:
    connection.execute(
        "DELETE FROM sessions WHERE expires_at <= ?",
        (utc_now(),),
    )


def discover_template89() -> dict[str, dict[str, Any]]:
    templates: dict[str, dict[str, Any]] = {}
    if not TEMPLATE_DIR.exists():
        return templates

    for directory in sorted(TEMPLATE_DIR.iterdir(), key=lambda item: item.name.lower()):
        if not directory.is_dir():
            continue
        index_file = directory / "index.html"
        if not index_file.is_file():
            continue
        templates[directory.name] = {
            "name": directory.name,
            "source": "TEMPLATE89",
            "path": str(directory),
            "hero": f"Template landing page dari folder {directory.name}.",
            "accent": "#45d9ff",
        }
    return templates


def looks_like_amp_source(index_file: Path) -> bool:
    try:
        source = index_file.read_text(encoding="utf-8", errors="ignore")
    except OSError:
        return False
    html_tag = re.search(r"<html\b([^>]*)>", source, flags=re.I)
    return bool(
        html_tag
        and re.search(r"(?:^|\s)(?:amp|⚡)(?:\s|=|$)", html_tag.group(1), flags=re.I)
        and re.search(r"<script\b[^>]*src\s*=\s*(?:[\"'])?https://cdn\.ampproject\.org/v0\.js", source, flags=re.I)
        and re.search(r"<style\b[^>]*amp-boilerplate", source, flags=re.I)
        and re.search(r"<style\b[^>]*amp-custom", source, flags=re.I)
    )


def discover_ampall() -> dict[str, dict[str, Any]]:
    templates: dict[str, dict[str, Any]] = {}
    if not AMP_TEMPLATE_DIR.exists():
        return templates

    index_files = sorted(
        AMP_TEMPLATE_DIR.rglob("index.html"),
        key=lambda item: item.relative_to(AMP_TEMPLATE_DIR).as_posix().lower(),
    )
    for index_file in index_files:
        if not looks_like_amp_source(index_file):
            continue
        directory = index_file.parent
        template_key = directory.relative_to(AMP_TEMPLATE_DIR).as_posix()
        templates[template_key] = {
            "name": template_key,
            "source": "AMPALL",
            "path": str(directory),
            "hero": f"Template AMP dari folder {template_key}.",
            "accent": "#8b5cf6",
        }
    return templates


def available_templates() -> dict[str, dict[str, Any]]:
    template89 = discover_template89()
    return template89 if template89 else FALLBACK_TEMPLATES


def template_menu_options() -> dict[str, dict[str, Any]]:
    templates = available_templates()
    if not templates:
        return {}
    return {
        RANDOM_TEMPLATE_KEY: {
            "name": "Random dari TEMPLATE89",
            "source": "system",
            "hero": "Generator akan memilih salah satu template valid secara acak.",
            "accent": "#42f5b6",
        },
        **templates,
    }


def selected_template_path(template_key: str) -> tuple[str | None, Path | None]:
    templates = available_templates()
    template_keys = list(templates.keys())
    if not template_keys:
        return None, None

    if template_key == RANDOM_TEMPLATE_KEY:
        selected_key = random.choice(template_keys)
    elif template_key in templates:
        selected_key = template_key
    else:
        selected_key = random.choice(template_keys)

    path_value = templates[selected_key].get("path")
    return selected_key, Path(path_value) if path_value else None


def amp_template_menu_options() -> dict[str, dict[str, Any]]:
    templates = discover_ampall()
    if not templates:
        return {}
    return {
        RANDOM_AMP_TEMPLATE_KEY: {
            "name": "Random dari AMPALL",
            "source": "system",
            "hero": "Generator akan memilih salah satu template AMP valid secara acak.",
            "accent": "#a78bfa",
        },
        **templates,
    }


def selected_amp_template_path(amp_template_key: str) -> tuple[str | None, Path | None]:
    templates = discover_ampall()
    template_keys = list(templates.keys())
    if not template_keys:
        return None, None

    if amp_template_key == RANDOM_AMP_TEMPLATE_KEY:
        selected_key = random.choice(template_keys)
    elif amp_template_key in templates:
        selected_key = amp_template_key
    else:
        selected_key = random.choice(template_keys)

    path_value = templates[selected_key].get("path")
    return selected_key, Path(path_value) if path_value else None


def safe_int(value: Any) -> int | None:
    try:
        if value in {None, ""}:
            return None
        return int(value)
    except (TypeError, ValueError):
        return None


def media_url(media_id: int | None, user_id: int | None = None) -> str:
    if not media_id:
        return ""
    with db() as connection:
        if user_id is None:
            row = connection.execute(
                "SELECT public_url FROM media_assets WHERE id = ?",
                (media_id,),
            ).fetchone()
        else:
            row = connection.execute(
                "SELECT public_url FROM media_assets WHERE id = ? AND user_id = ?",
                (media_id, user_id),
            ).fetchone()
    return row["public_url"] if row else ""


def media_record(media_id: int | None, user_id: int | None = None) -> sqlite3.Row | None:
    if not media_id:
        return None
    with db() as connection:
        if user_id is None:
            return connection.execute(
                "SELECT * FROM media_assets WHERE id = ?",
                (media_id,),
            ).fetchone()
        return connection.execute(
            "SELECT * FROM media_assets WHERE id = ? AND user_id = ?",
            (media_id, user_id),
        ).fetchone()


def media_to_dict(row: sqlite3.Row) -> dict[str, Any]:
    return {
        "id": row["id"],
        "original_name": row["original_name"],
        "stored_name": row["stored_name"],
        "url": row["public_url"],
        "content_type": row["content_type"],
        "file_size": row["file_size"],
        "created_at": row["created_at"],
    }


def media_group_to_dict(row: sqlite3.Row) -> dict[str, Any]:
    user_id = int(row["user_id"])
    return {
        "id": row["id"],
        "name": row["name"],
        "logo_media_id": row["logo_media_id"],
        "icon_media_id": row["icon_media_id"],
        "main_media_id": row["main_media_id"],
        "media": {
            "logo": media_url(row["logo_media_id"], user_id),
            "icon": media_url(row["icon_media_id"], user_id),
            "main": media_url(row["main_media_id"], user_id),
        },
        "created_at": row["created_at"],
        "updated_at": row["updated_at"],
    }


def list_media(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            "SELECT * FROM media_assets WHERE user_id = ? ORDER BY created_at DESC, id DESC",
            (user_id,),
        ).fetchall()
    return [media_to_dict(row) for row in rows]


def list_media_groups(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            "SELECT * FROM media_groups WHERE user_id = ? ORDER BY updated_at DESC, id DESC",
            (user_id,),
        ).fetchall()
    return [media_group_to_dict(row) for row in rows]


def load_media_group(group_id: int | None, user_id: int) -> dict[str, Any] | None:
    if not group_id:
        return None
    with db() as connection:
        row = connection.execute(
            "SELECT * FROM media_groups WHERE id = ? AND user_id = ?",
            (group_id, user_id),
        ).fetchone()
    return media_group_to_dict(row) if row else None


def save_media_group(payload: dict[str, Any], user_id: int) -> dict[str, Any]:
    name = str(payload.get("name") or "").strip()
    if not name:
        raise ValueError("Nama Media Group wajib diisi.")
    logo_media_id = safe_int(payload.get("logo_media_id"))
    icon_media_id = safe_int(payload.get("icon_media_id"))
    main_media_id = safe_int(payload.get("main_media_id"))
    required = {
        "Logo": logo_media_id,
        "Icon": icon_media_id,
        "Gambar Utama": main_media_id,
    }
    missing = [label for label, media_id in required.items() if not media_record(media_id, user_id)]
    if missing:
        raise ValueError(f"Lengkapi Media Group: {', '.join(missing)}.")

    now = utc_now()
    group_id = safe_int(payload.get("id"))
    with db() as connection:
        if group_id:
            existing = connection.execute(
                "SELECT id FROM media_groups WHERE id = ? AND user_id = ?",
                (group_id, user_id),
            ).fetchone()
            if not existing:
                raise ValueError("Media Group tidak ditemukan.")
            connection.execute(
                """
                UPDATE media_groups
                SET name = ?, logo_media_id = ?, icon_media_id = ?,
                    main_media_id = ?, updated_at = ?
                WHERE id = ? AND user_id = ?
                """,
                (name, logo_media_id, icon_media_id, main_media_id, now, group_id, user_id),
            )
            saved_id = group_id
        else:
            connection.execute(
                """
                INSERT INTO media_groups (
                    user_id, name, logo_media_id, icon_media_id, main_media_id,
                    created_at, updated_at
                )
                VALUES (?, ?, ?, ?, ?, ?, ?)
                ON CONFLICT(user_id, name) DO UPDATE SET
                    logo_media_id = excluded.logo_media_id,
                    icon_media_id = excluded.icon_media_id,
                    main_media_id = excluded.main_media_id,
                    updated_at = excluded.updated_at
                """,
                (user_id, name, logo_media_id, icon_media_id, main_media_id, now, now),
            )
            saved_id = int(connection.execute(
                "SELECT id FROM media_groups WHERE name = ? AND user_id = ?",
                (name, user_id),
            ).fetchone()["id"])

    group = load_media_group(saved_id, user_id)
    if not group:
        raise ValueError("Media Group gagal disimpan.")
    return group


def sanitize_filename(filename: str, content_type: str) -> str:
    suffix = Path(filename).suffix.lower()
    if suffix not in {".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".ico"}:
        suffix = ALLOWED_IMAGE_TYPES.get(content_type, ".img")
    stem = re.sub(r"[^a-zA-Z0-9_-]+", "-", Path(filename).stem).strip("-").lower() or "media"
    return f"{stem}-{secrets.token_hex(5)}{suffix}"


def parse_multipart_upload(body: bytes, content_type: str) -> list[dict[str, Any]]:
    message = BytesParser(policy=email_policy).parsebytes(
        b"Content-Type: " + content_type.encode("utf-8") + b"\r\nMIME-Version: 1.0\r\n\r\n" + body
    )
    files: list[dict[str, Any]] = []
    for part in message.iter_parts():
        if part.get_content_disposition() != "form-data":
            continue
        filename = part.get_filename()
        if not filename:
            continue
        part_content_type = part.get_content_type()
        if part_content_type not in ALLOWED_IMAGE_TYPES:
            raise ValueError("Format gambar tidak didukung. Gunakan JPG, PNG, WEBP, GIF, SVG, atau ICO.")
        payload = part.get_payload(decode=True) or b""
        if not payload:
            raise ValueError("File gambar kosong.")
        if len(payload) > 8 * 1024 * 1024:
            raise ValueError("Ukuran gambar maksimal 8 MB.")
        files.append({
            "filename": filename,
            "content_type": part_content_type,
            "payload": payload,
        })
    if not files:
        raise ValueError("Pilih minimal satu gambar untuk diupload.")
    return files


def save_uploaded_media(files: list[dict[str, Any]], user_id: int) -> list[dict[str, Any]]:
    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
    saved: list[dict[str, Any]] = []
    now = utc_now()
    with db() as connection:
        for item in files:
            stored_name = sanitize_filename(item["filename"], item["content_type"])
            file_path = UPLOAD_DIR / stored_name
            file_path.write_bytes(item["payload"])
            public_url = f"/uploads/{quote(stored_name)}"
            cursor = connection.execute(
                """
                INSERT INTO media_assets (
                    user_id, original_name, stored_name, file_path, public_url,
                    content_type, file_size, created_at
                )
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    user_id,
                    item["filename"],
                    stored_name,
                    str(file_path),
                    public_url,
                    item["content_type"],
                    len(item["payload"]),
                    now,
                ),
            )
            row = connection.execute(
                "SELECT * FROM media_assets WHERE id = ?",
                (cursor.lastrowid,),
            ).fetchone()
            saved.append(media_to_dict(row))
    return saved


def delete_media_asset(media_id: int | None, user_id: int) -> dict[str, Any]:
    row = media_record(media_id, user_id)
    if not row:
        raise ValueError("Media tidak ditemukan.")

    media = media_to_dict(row)
    media_path = Path(row["file_path"]).resolve()
    upload_root = UPLOAD_DIR.resolve()
    now = utc_now()
    with db() as connection:
        connection.execute(
            """
            UPDATE projects
            SET logo_media_id = CASE WHEN logo_media_id = ? THEN NULL ELSE logo_media_id END,
                icon_media_id = CASE WHEN icon_media_id = ? THEN NULL ELSE icon_media_id END,
                main_media_id = CASE WHEN main_media_id = ? THEN NULL ELSE main_media_id END,
                updated_at = ?
            WHERE user_id = ?
              AND (logo_media_id = ? OR icon_media_id = ? OR main_media_id = ?)
            """,
            (media_id, media_id, media_id, now, user_id, media_id, media_id, media_id),
        )
        connection.execute(
            """
            DELETE FROM media_groups
            WHERE user_id = ?
              AND (logo_media_id = ? OR icon_media_id = ? OR main_media_id = ?)
            """,
            (user_id, media_id, media_id, media_id),
        )
        connection.execute("DELETE FROM media_assets WHERE id = ? AND user_id = ?", (media_id, user_id))

    if media_path.exists() and upload_root in media_path.parents:
        media_path.unlink()
    return media


def token_hash(token: str) -> str:
    return hashlib.sha256(token.encode("utf-8")).hexdigest()


def authenticate(username: str, password: str) -> sqlite3.Row | None:
    with db() as connection:
        row = connection.execute(
            "SELECT * FROM users WHERE username = ?",
            (username.strip(),),
        ).fetchone()
    if row and verify_password(password, row["password_hash"]):
        return row
    return None


def login_is_rate_limited(client_key: str) -> bool:
    cutoff = time.monotonic() - LOGIN_ATTEMPT_WINDOW_SECONDS
    with LOGIN_FAILURES_LOCK:
        recent = [stamp for stamp in LOGIN_FAILURES.get(client_key, []) if stamp >= cutoff]
        if recent:
            LOGIN_FAILURES[client_key] = recent
        else:
            LOGIN_FAILURES.pop(client_key, None)
        return len(recent) >= LOGIN_MAX_FAILURES


def record_login_failure(client_key: str) -> None:
    now = time.monotonic()
    cutoff = now - LOGIN_ATTEMPT_WINDOW_SECONDS
    with LOGIN_FAILURES_LOCK:
        recent = [stamp for stamp in LOGIN_FAILURES.get(client_key, []) if stamp >= cutoff]
        recent.append(now)
        LOGIN_FAILURES[client_key] = recent[-LOGIN_MAX_FAILURES:]


def clear_login_failures(client_key: str) -> None:
    with LOGIN_FAILURES_LOCK:
        LOGIN_FAILURES.pop(client_key, None)


def ai_secret_cipher() -> Fernet:
    configured_key = os.environ.get("ADMINSEO_SECRET_KEY", "").strip()
    if configured_key:
        key = configured_key.encode("ascii")
    else:
        key_path = DATA_DIR / ".ai-secret.key"
        if key_path.is_file():
            key = key_path.read_bytes().strip()
        else:
            key_path.parent.mkdir(parents=True, exist_ok=True)
            key = Fernet.generate_key()
            key_path.write_bytes(key)
            try:
                key_path.chmod(0o600)
            except OSError:
                pass
    try:
        return Fernet(key)
    except (ValueError, TypeError) as exc:
        raise RuntimeError("ADMINSEO_SECRET_KEY tidak valid.") from exc


def encrypt_api_key(api_key: str) -> str:
    return ai_secret_cipher().encrypt(api_key.encode("utf-8")).decode("ascii")


def decrypt_api_key(encrypted_value: str) -> str:
    try:
        return ai_secret_cipher().decrypt(encrypted_value.encode("ascii")).decode("utf-8")
    except (InvalidToken, ValueError, UnicodeError) as exc:
        raise ValueError("API key tersimpan tidak dapat dibaca. Masukkan ulang API key.") from exc


def ai_connection_row(user_id: int) -> sqlite3.Row | None:
    with db() as connection:
        return connection.execute(
            "SELECT * FROM ai_connections WHERE user_id = ?",
            (user_id,),
        ).fetchone()


def public_ai_connection(user_id: int) -> dict[str, Any]:
    row = ai_connection_row(user_id)
    if not row:
        return {
            "configured": False,
            "provider": "openai",
            "api_base_url": OPENAI_API_BASE_URL,
            "model": DEFAULT_OPENAI_MODEL,
            "key_hint": "",
            "connection_status": "not_configured",
            "last_tested_at": None,
            "last_error": "",
        }
    return {
        "configured": True,
        "provider": row["provider"],
        "api_base_url": row["api_base_url"],
        "model": row["model"],
        "key_hint": f"••••{row['key_last_four']}" if row["key_last_four"] else "Tersimpan",
        "connection_status": row["connection_status"],
        "last_tested_at": row["last_tested_at"],
        "last_error": row["last_error"],
    }


def save_ai_connection(user_id: int, payload: dict[str, Any]) -> dict[str, Any]:
    provider = str(payload.get("provider") or "openai").strip().lower()
    if provider != "openai":
        raise ValueError("Provider yang tersedia saat ini adalah OpenAI.")
    model = str(payload.get("model") or DEFAULT_OPENAI_MODEL).strip()
    if not re.fullmatch(r"[A-Za-z0-9._:-]{2,100}", model):
        raise ValueError("Nama model OpenAI tidak valid.")

    existing = ai_connection_row(user_id)
    api_key = str(payload.get("api_key") or "").strip()
    if api_key:
        if not api_key.startswith("sk-") or len(api_key) < 20 or len(api_key) > 512:
            raise ValueError("Format API key OpenAI tidak valid.")
        encrypted_key = encrypt_api_key(api_key)
        key_last_four = api_key[-4:]
    elif existing:
        encrypted_key = str(existing["api_key_encrypted"])
        key_last_four = str(existing["key_last_four"])
    else:
        raise ValueError("API key OpenAI wajib diisi.")

    now = utc_now()
    with db() as connection:
        connection.execute(
            """
            INSERT INTO ai_connections (
                user_id, provider, api_base_url, model, api_key_encrypted,
                key_last_four, connection_status, last_tested_at, last_error,
                created_at, updated_at
            )
            VALUES (?, ?, ?, ?, ?, ?, 'saved', NULL, '', ?, ?)
            ON CONFLICT(user_id) DO UPDATE SET
                provider = excluded.provider,
                api_base_url = excluded.api_base_url,
                model = excluded.model,
                api_key_encrypted = excluded.api_key_encrypted,
                key_last_four = excluded.key_last_four,
                connection_status = 'saved',
                last_error = '',
                updated_at = excluded.updated_at
            """,
            (
                user_id,
                provider,
                OPENAI_API_BASE_URL,
                model,
                encrypted_key,
                key_last_four,
                now,
                now,
            ),
        )
    return public_ai_connection(user_id)


def update_ai_connection_status(user_id: int, status: str, error: str = "") -> None:
    now = utc_now()
    with db() as connection:
        connection.execute(
            """
            UPDATE ai_connections
            SET connection_status = ?, last_tested_at = ?, last_error = ?, updated_at = ?
            WHERE user_id = ?
            """,
            (status, now, error[:500], now, user_id),
        )


def openai_error_message(exc: HTTPError) -> str:
    try:
        payload = json.loads(exc.read().decode("utf-8", errors="replace"))
        message = str(payload.get("error", {}).get("message") or "").strip()
        if message:
            return message
    except (json.JSONDecodeError, AttributeError, TypeError):
        pass
    return f"OpenAI API merespons HTTP {exc.code}."


def test_ai_connection(user_id: int, payload: dict[str, Any] | None = None) -> dict[str, Any]:
    if payload:
        save_ai_connection(user_id, payload)
    row = ai_connection_row(user_id)
    if not row:
        raise ValueError("Simpan API key OpenAI terlebih dahulu.")
    api_key = decrypt_api_key(str(row["api_key_encrypted"]))
    model = str(row["model"])
    endpoint = f"{OPENAI_API_BASE_URL}/models/{quote(model, safe='')}"
    request = Request(
        endpoint,
        headers={
            "Authorization": f"Bearer {api_key}",
            "Accept": "application/json",
            "User-Agent": "AdminSEO/1.0",
            "X-Client-Request-Id": secrets.token_hex(16),
        },
        method="GET",
    )
    try:
        with urlopen(request, timeout=20) as response:
            result = json.loads(response.read().decode("utf-8"))
        if str(result.get("id") or "") != model:
            raise ValueError("OpenAI API terhubung, tetapi model tidak cocok.")
    except HTTPError as exc:
        message = openai_error_message(exc)
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(f"Koneksi OpenAI gagal: {message}") from exc
    except URLError as exc:
        message = "Tidak dapat menjangkau OpenAI API. Periksa koneksi internet atau firewall."
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(message) from exc
    except (TimeoutError, json.JSONDecodeError) as exc:
        message = "Respons OpenAI API tidak dapat diproses atau melewati batas waktu."
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(message) from exc

    update_ai_connection_status(user_id, "connected")
    return {
        "connection": public_ai_connection(user_id),
        "message": f"Terhubung ke OpenAI dengan model {model}.",
    }


def delete_ai_connection(user_id: int) -> None:
    with db() as connection:
        connection.execute("DELETE FROM ai_connections WHERE user_id = ?", (user_id,))


def ai_content_brand(project: dict[str, Any]) -> str:
    keywords = [
        item.strip()
        for item in str(project.get("keywords") or "").split(",")
        if item.strip()
    ]
    if keywords:
        return keywords[0][:40]
    hostname = str(project.get("hostname") or "Brand")
    return domain_title(hostname)[:40]


def ai_response_output_text(result: dict[str, Any]) -> str:
    direct = str(result.get("output_text") or "").strip()
    if direct:
        return direct
    for item in result.get("output") or []:
        if not isinstance(item, dict) or item.get("type") != "message":
            continue
        for content in item.get("content") or []:
            if isinstance(content, dict) and content.get("type") == "output_text":
                text = str(content.get("text") or "").strip()
                if text:
                    return text
    return ""


def sanitize_ai_landing_content(payload: dict[str, Any]) -> dict[str, Any]:
    def required_text(key: str, limit: int) -> str:
        value = re.sub(r"\s+", " ", str(payload.get(key) or "")).strip()
        if not value:
            raise ValueError(f"AI tidak menghasilkan {key}.")
        return value[:limit]

    keywords = [
        re.sub(r"\s+", " ", str(item or "")).strip()[:60]
        for item in payload.get("keywords") or []
        if str(item or "").strip()
    ]
    keywords = list(dict.fromkeys(keywords))[:8]
    if len(keywords) < 5:
        raise ValueError("AI wajib menghasilkan minimal 5 keyword unik.")

    sections = []
    for item in payload.get("article_sections") or []:
        if not isinstance(item, dict):
            continue
        heading = re.sub(r"\s+", " ", str(item.get("heading") or "")).strip()[:100]
        body = re.sub(r"\s+", " ", str(item.get("body") or "")).strip()
        if heading and len(body) >= 120:
            sections.append({"heading": heading, "body": body})
    if len(sections) != 5:
        raise ValueError("AI wajib menghasilkan tepat 5 bagian artikel yang lengkap.")

    faqs = []
    for item in payload.get("faqs") or []:
        if not isinstance(item, dict):
            continue
        question = re.sub(r"\s+", " ", str(item.get("question") or "")).strip()[:180]
        answer = re.sub(r"\s+", " ", str(item.get("answer") or "")).strip()
        if question and answer:
            faqs.append({"question": question, "answer": answer})
    if len(faqs) != 5:
        raise ValueError("AI wajib menghasilkan tepat 5 FAQ.")

    reviews = []
    for item in payload.get("reviews") or []:
        if not isinstance(item, dict):
            continue
        name = re.sub(r"\s+", " ", str(item.get("name") or "")).strip()[:60]
        city = re.sub(r"\s+", " ", str(item.get("city") or "")).strip()[:60]
        body = re.sub(r"\s+", " ", str(item.get("body") or "")).strip()
        rating = max(4, min(5, safe_int(item.get("rating")) or 5))
        if name and city and body:
            reviews.append({
                "name": name,
                "city": city,
                "rating": str(rating),
                "body": body,
            })
    if len(reviews) != 5:
        raise ValueError("AI wajib menghasilkan tepat 5 review persona Indonesia.")

    return {
        "seo_title": required_text("seo_title", 120),
        "meta_description": required_text("meta_description", 180),
        "keywords": keywords,
        "hero_heading": required_text("hero_heading", 120),
        "hero_subheading": required_text("hero_subheading", 220),
        "cta_label": required_text("cta_label", 60),
        "article_sections": sections,
        "faqs": faqs,
        "reviews": reviews,
    }


def content_shingles(value: str, size: int = 5) -> set[tuple[str, ...]]:
    tokens = re.findall(r"[a-z0-9]+", value.lower())
    if not tokens:
        return set()
    if len(tokens) < size:
        return {tuple(tokens)}
    return {tuple(tokens[index:index + size]) for index in range(len(tokens) - size + 1)}


def ai_content_duplicate_report(
    user_id: int,
    project_id: int | None,
    content: dict[str, Any],
) -> dict[str, Any]:
    article = " ".join(
        str(item.get("body") or "")
        for item in content.get("article_sections") or []
        if isinstance(item, dict)
    )
    article_shingles = content_shingles(article)
    title = str(content.get("seo_title") or "")
    best = {"score": 0.0, "title_score": 0.0, "article_score": 0.0, "domain": ""}
    with db() as connection:
        if project_id:
            rows = connection.execute(
                """
                SELECT hostname, seo_title, article_body
                FROM projects
                WHERE user_id = ? AND id != ? AND article_body != ''
                ORDER BY updated_at DESC LIMIT 50
                """,
                (user_id, project_id),
            ).fetchall()
        else:
            rows = connection.execute(
                """
                SELECT hostname, seo_title, article_body
                FROM projects
                WHERE user_id = ? AND article_body != ''
                ORDER BY updated_at DESC LIMIT 50
                """,
                (user_id,),
            ).fetchall()

    for row in rows:
        previous_shingles = content_shingles(str(row["article_body"] or ""))
        union = article_shingles | previous_shingles
        article_score = len(article_shingles & previous_shingles) / len(union) if union else 0.0
        title_score = SequenceMatcher(
            None,
            re.sub(r"\s+", " ", title.lower()).strip(),
            re.sub(r"\s+", " ", str(row["seo_title"] or "").lower()).strip(),
        ).ratio()
        score = max(article_score, title_score if title_score >= 0.96 else (article_score + title_score) / 2)
        if score > best["score"]:
            best = {
                "score": round(score, 4),
                "title_score": round(title_score, 4),
                "article_score": round(article_score, 4),
                "domain": str(row["hostname"] or ""),
            }
    best["passed"] = best["score"] < 0.82
    return best


def generate_ai_landing_content(
    project: dict[str, Any],
    user_id: int,
) -> tuple[dict[str, Any], dict[str, Any]]:
    row = ai_connection_row(user_id)
    if not row:
        raise ValueError("Koneksi AI belum tersedia. Buka AI MENU > Konek API terlebih dahulu.")
    api_key = decrypt_api_key(str(row["api_key_encrypted"]))
    model = str(row["model"])
    hostname = str(project.get("hostname") or "")
    brand = ai_content_brand(project)
    mode = str(project.get("ai_content_mode") or "rewrite")
    instructions = str(project.get("ai_instructions") or "").strip()[:2000]
    with db() as connection:
        previous_titles = [
            str(item["seo_title"])
            for item in connection.execute(
                """
                SELECT seo_title FROM projects
                WHERE user_id = ? AND id != ? AND seo_title != ''
                ORDER BY updated_at DESC LIMIT 20
                """,
                (user_id, safe_int(project.get("id")) or -1),
            ).fetchall()
        ]

    context = {
        "domain": hostname,
        "domain_url": str(project.get("domain_url") or ""),
        "brand": brand,
        "niche": infer_workflow_niche(hostname),
        "content_mode": mode,
        "manual_guidance": {
            "seo_title": str(project.get("seo_title") or ""),
            "meta_description": str(project.get("meta_description") or ""),
            "keywords": str(project.get("keywords") or ""),
            "hero_heading": str(project.get("hero_heading") or ""),
            "hero_subheading": str(project.get("hero_subheading") or ""),
            "article_body": str(project.get("article_body") or "")[:2500],
        },
        "special_instructions": instructions,
        "titles_to_avoid": previous_titles,
    }
    developer_instructions = (
        "Anda adalah editor SEO Indonesia untuk landing page. Buat konten baru, natural, "
        "informatif, dan berbeda secara substantif untuk domain yang diberikan. Gunakan hanya "
        "brand dan domain dari input; jangan menyebut brand, domain, produk, atau teks bawaan "
        "template lain. Hindari keyword stuffing, klaim palsu, kalimat generik, dan pengulangan. "
        "SEO title harus ringkas, meta description menarik, artikel terdiri dari tepat 5 bagian "
        "dengan masing-masing isi minimal 90 kata. Buat tepat 5 FAQ dan 5 review persona Indonesia "
        "yang berbeda nama serta kota. Review harus terdengar manusiawi dan tidak membuat klaim "
        "transaksi yang tidak dapat diverifikasi. Jika mode rewrite, tulis ulang semua bidang dari "
        "nol sambil memakai input manual hanya sebagai arahan. Jika mode fill, pertahankan maksud "
        "input manual tetapi tetap perbaiki kualitas dan keunikannya."
    )
    text_config: dict[str, Any] = {
        "format": {
            "type": "json_schema",
            "name": "adminseo_landing_content",
            "strict": True,
            "schema": AI_LANDING_CONTENT_SCHEMA,
        },
    }
    if model.startswith("gpt-5"):
        text_config["verbosity"] = "medium"
    request_payload = {
        "model": model,
        "instructions": developer_instructions,
        "input": json.dumps(context, ensure_ascii=False),
        "text": text_config,
        "max_output_tokens": 7000,
        "store": False,
    }
    request = Request(
        f"{OPENAI_API_BASE_URL}/responses",
        data=json.dumps(request_payload, ensure_ascii=False).encode("utf-8"),
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
            "Accept": "application/json",
            "User-Agent": "AdminSEO/1.0",
            "X-Client-Request-Id": secrets.token_hex(16),
        },
        method="POST",
    )
    try:
        with urlopen(request, timeout=120) as response:
            result = json.loads(response.read().decode("utf-8"))
    except HTTPError as exc:
        message = openai_error_message(exc)
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(f"Generate konten AI gagal: {message}") from exc
    except URLError as exc:
        message = "Tidak dapat menjangkau OpenAI API saat membuat konten."
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(message) from exc
    except (TimeoutError, json.JSONDecodeError) as exc:
        message = "Respons konten AI tidak dapat diproses atau melewati batas waktu."
        update_ai_connection_status(user_id, "error", message)
        raise ValueError(message) from exc

    if result.get("status") in {"failed", "incomplete", "cancelled"}:
        error_message = str((result.get("error") or {}).get("message") or "Respons AI tidak selesai.")
        update_ai_connection_status(user_id, "error", error_message)
        raise ValueError(error_message)
    output_text = ai_response_output_text(result)
    if not output_text:
        raise ValueError("OpenAI tidak mengembalikan teks konten.")
    try:
        content = sanitize_ai_landing_content(json.loads(output_text))
    except json.JSONDecodeError as exc:
        raise ValueError("Format konten dari OpenAI tidak valid.") from exc

    duplicate_report = ai_content_duplicate_report(
        user_id,
        safe_int(project.get("id")),
        content,
    )
    if not duplicate_report["passed"]:
        raise ValueError(
            "Konten AI ditolak karena terlalu mirip dengan "
            f"{duplicate_report['domain']} ({duplicate_report['score']:.0%}). Generate ulang."
        )
    update_ai_connection_status(user_id, "connected")
    report = {
        "source": "openai",
        "model": model,
        "response_id": str(result.get("id") or ""),
        "generated_at": utc_now(),
        "duplicate_audit": duplicate_report,
        "usage": result.get("usage") if isinstance(result.get("usage"), dict) else {},
    }
    return content, report


def apply_ai_content_to_project(project: dict[str, Any]) -> dict[str, Any]:
    user_id = int(project["user_id"])
    content, report = generate_ai_landing_content(project, user_id)
    article_body = "\n\n".join(
        f"{item['heading']}\n{item['body']}"
        for item in content["article_sections"]
    )
    stored_payload = {"content": content, "report": report}
    with db() as connection:
        connection.execute(
            """
            UPDATE projects
            SET seo_title = ?,
                meta_description = ?,
                keywords = ?,
                hero_heading = ?,
                hero_subheading = ?,
                article_body = ?,
                cta_label = ?,
                ai_content_json = ?,
                ai_generated_at = ?,
                updated_at = ?
            WHERE id = ? AND user_id = ?
            """,
            (
                content["seo_title"],
                content["meta_description"],
                ", ".join(content["keywords"]),
                content["hero_heading"],
                content["hero_subheading"],
                article_body,
                content["cta_label"],
                json.dumps(stored_payload, ensure_ascii=False),
                report["generated_at"],
                report["generated_at"],
                project["id"],
                user_id,
            ),
        )
    refreshed = load_project(int(project["id"]), user_id)
    if not refreshed:
        raise ValueError("Project AI gagal diperbarui.")
    return refreshed


def load_seo_flow_schema(user_id: int) -> dict[str, Any]:
    with db() as connection:
        row = connection.execute(
            "SELECT source_text, updated_at FROM seo_flow_schemas WHERE user_id = ?",
            (user_id,),
        ).fetchone()
    return {
        "source_text": str(row["source_text"]) if row else "",
        "updated_at": row["updated_at"] if row else None,
    }


def save_seo_flow_schema(user_id: int, source_text: str) -> dict[str, Any]:
    normalized = source_text.replace("\r\n", "\n").strip()
    if len(normalized) > 100_000:
        raise ValueError("Data skema maksimal 100.000 karakter.")
    now = utc_now()
    with db() as connection:
        connection.execute(
            """
            INSERT INTO seo_flow_schemas (user_id, source_text, created_at, updated_at)
            VALUES (?, ?, ?, ?)
            ON CONFLICT(user_id) DO UPDATE SET
                source_text = excluded.source_text,
                updated_at = excluded.updated_at
            """,
            (user_id, normalized, now, now),
        )
    return {"source_text": normalized, "updated_at": now}


def delete_seo_flow_schema(user_id: int) -> None:
    with db() as connection:
        connection.execute("DELETE FROM seo_flow_schemas WHERE user_id = ?", (user_id,))


def normalize_seo_flow_node(value: str) -> str:
    cleaned = value.strip().strip("\"'").rstrip(";,").strip()
    if not cleaned:
        return ""
    parsed = urlparse(cleaned if re.match(r"^https?://", cleaned, re.I) else f"https://{cleaned}")
    if not parsed.hostname:
        return re.sub(r"^https?://", "", cleaned, flags=re.I).rstrip("/")
    path = "" if parsed.path == "/" else parsed.path.rstrip("/")
    query = f"?{parsed.query}" if parsed.query else ""
    return f"{parsed.hostname.lower()}{path}{query}"


def parse_seo_flow_source(source_text: str) -> list[dict[str, str]]:
    edges: list[dict[str, str]] = []
    seen: set[tuple[str, str, str]] = set()
    phrase_pattern = re.compile(
        r"^(.+?)\s+(301|302|307|308)\s+(?:ke|to|menuju|->|=>)\s+(.+)$",
        re.I,
    )
    arrow_pattern = re.compile(r"^(.+?)\s*(?:->|=>)\s*(.+)$")

    for raw_line in source_text.splitlines():
        line = raw_line.strip()
        if not line or line.startswith("#"):
            continue
        source = ""
        target = ""
        status = "301"
        phrase = phrase_pattern.match(line)
        if phrase:
            source, status, target = phrase.groups()
        else:
            arrow = arrow_pattern.match(line)
            if arrow:
                source, target = arrow.groups()
            else:
                columns = [
                    item.strip().strip("\"'")
                    for item in re.split(r"[,;\t]", line)
                    if item.strip().strip("\"'")
                ]
                if len(columns) >= 3 and columns[1] in {"301", "302", "307", "308"}:
                    source, status, target = columns[:3]
                elif len(columns) >= 2:
                    source, target = columns[:2]

        source = normalize_seo_flow_node(source)
        target = normalize_seo_flow_node(target)
        key = (source, status, target)
        if (
            not source
            or not target
            or source == target
            or re.search(r"\s", source)
            or re.search(r"\s", target)
            or key in seen
        ):
            continue
        seen.add(key)
        edges.append({"source": source, "status": status, "target": target})
    return edges


def xlsx_inline_cell(reference: str, value: str, style: int = 0) -> str:
    safe_value = html.escape(str(value), quote=False)
    style_attribute = f' s="{style}"' if style else ""
    return (
        f'<c r="{reference}"{style_attribute} t="inlineStr">'
        f"<is><t>{safe_value}</t></is></c>"
    )


def xlsx_number_cell(
    reference: str,
    value: int,
    style: int = 0,
    formula: str | None = None,
) -> str:
    style_attribute = f' s="{style}"' if style else ""
    formula_xml = f"<f>{html.escape(formula, quote=False)}</f>" if formula else ""
    return f'<c r="{reference}"{style_attribute}>{formula_xml}<v>{int(value)}</v></c>'


def export_seo_flow_xlsx(user_id: int) -> bytes:
    schema = load_seo_flow_schema(user_id)
    edges = parse_seo_flow_source(str(schema.get("source_text") or ""))
    if not edges:
        raise ValueError("Belum ada skema redirect yang dapat diekspor.")

    generated_at = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
    data_rows = [
        '<row r="1" ht="30">'
        + xlsx_inline_cell("A1", "Alur Skema SEO", 1)
        + "</row>",
        '<row r="2">'
        + xlsx_inline_cell("A2", f"Dibuat: {generated_at}", 5)
        + "</row>",
        '<row r="4" ht="24">'
        + "".join(
            xlsx_inline_cell(f"{column}4", label, 2)
            for column, label in zip(
                "ABCDE",
                ("No", "Source Domain", "Status Redirect", "Target Domain", "Jenis"),
            )
        )
        + "</row>",
    ]
    for index, edge in enumerate(edges, start=1):
        row_number = index + 4
        redirect_type = "Permanen" if edge["status"] in {"301", "308"} else "Sementara"
        data_rows.append(
            f'<row r="{row_number}">'
            + xlsx_number_cell(f"A{row_number}", index, 4)
            + xlsx_inline_cell(f"B{row_number}", edge["source"], 3)
            + xlsx_inline_cell(f"C{row_number}", edge["status"], 4)
            + xlsx_inline_cell(f"D{row_number}", edge["target"], 3)
            + xlsx_inline_cell(f"E{row_number}", redirect_type, 3)
            + "</row>"
        )

    last_row = len(edges) + 4
    redirect_count = len(edges)
    permanent_count = sum(edge["status"] in {"301", "308"} for edge in edges)
    temporary_count = redirect_count - permanent_count
    source_count = len({edge["source"] for edge in edges})
    target_count = len({edge["target"] for edge in edges})
    summary_metrics = [
        (
            "Total Redirect",
            f"COUNTA('Redirect Map'!B5:B{last_row})",
            redirect_count,
        ),
        (
            "Redirect Permanen",
            f'COUNTIF(\'Redirect Map\'!C5:C{last_row},"301")+COUNTIF(\'Redirect Map\'!C5:C{last_row},"308")',
            permanent_count,
        ),
        (
            "Redirect Sementara",
            f'COUNTIF(\'Redirect Map\'!C5:C{last_row},"302")+COUNTIF(\'Redirect Map\'!C5:C{last_row},"307")',
            temporary_count,
        ),
        (
            "Sumber Unik",
            f"SUMPRODUCT(1/COUNTIF('Redirect Map'!B5:B{last_row},'Redirect Map'!B5:B{last_row}))",
            source_count,
        ),
        (
            "Target Unik",
            f"SUMPRODUCT(1/COUNTIF('Redirect Map'!D5:D{last_row},'Redirect Map'!D5:D{last_row}))",
            target_count,
        ),
    ]
    summary_rows = [
        '<row r="1" ht="30">' + xlsx_inline_cell("A1", "Ringkasan Skema", 1) + "</row>",
        '<row r="3" ht="24">'
        + xlsx_inline_cell("A3", "Metrik", 2)
        + xlsx_inline_cell("B3", "Nilai", 2)
        + "</row>",
    ]
    for row_number, (label, formula, cached_value) in enumerate(summary_metrics, start=4):
        summary_rows.append(
            f'<row r="{row_number}">'
            + xlsx_inline_cell(f"A{row_number}", label, 3)
            + xlsx_number_cell(f"B{row_number}", cached_value, 4, formula)
            + "</row>"
        )

    redirect_sheet = f"""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
  <sheetViews><sheetView workbookViewId="0"><pane ySplit="4" topLeftCell="A5" activePane="bottomLeft" state="frozen"/></sheetView></sheetViews>
  <cols>
    <col min="1" max="1" width="8" customWidth="1"/>
    <col min="2" max="2" width="38" customWidth="1"/>
    <col min="3" max="3" width="18" customWidth="1"/>
    <col min="4" max="4" width="38" customWidth="1"/>
    <col min="5" max="5" width="16" customWidth="1"/>
  </cols>
  <sheetData>{''.join(data_rows)}</sheetData>
  <autoFilter ref="A4:E{last_row}"/>
  <mergeCells count="2"><mergeCell ref="A1:E1"/><mergeCell ref="A2:E2"/></mergeCells>
</worksheet>"""
    summary_sheet = f"""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
  <sheetViews><sheetView workbookViewId="0"/></sheetViews>
  <cols><col min="1" max="1" width="28" customWidth="1"/><col min="2" max="2" width="16" customWidth="1"/></cols>
  <sheetData>{''.join(summary_rows)}</sheetData>
  <mergeCells count="1"><mergeCell ref="A1:B1"/></mergeCells>
</worksheet>"""
    styles = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
  <fonts count="4">
    <font><sz val="11"/><color theme="1"/><name val="Calibri"/><family val="2"/></font>
    <font><b/><sz val="16"/><color rgb="FFFFFFFF"/><name val="Calibri"/></font>
    <font><b/><sz val="11"/><color rgb="FF07111F"/><name val="Calibri"/></font>
    <font><sz val="10"/><color rgb="FF607D94"/><name val="Calibri"/></font>
  </fonts>
  <fills count="4">
    <fill><patternFill patternType="none"/></fill>
    <fill><patternFill patternType="gray125"/></fill>
    <fill><patternFill patternType="solid"><fgColor rgb="FF0B2038"/><bgColor indexed="64"/></patternFill></fill>
    <fill><patternFill patternType="solid"><fgColor rgb="FF45D9FF"/><bgColor indexed="64"/></patternFill></fill>
  </fills>
  <borders count="2">
    <border><left/><right/><top/><bottom/><diagonal/></border>
    <border><left style="thin"><color rgb="FFD5E7F2"/></left><right style="thin"><color rgb="FFD5E7F2"/></right><top style="thin"><color rgb="FFD5E7F2"/></top><bottom style="thin"><color rgb="FFD5E7F2"/></bottom><diagonal/></border>
  </borders>
  <cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>
  <cellXfs count="6">
    <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
    <xf numFmtId="0" fontId="1" fillId="2" borderId="0" xfId="0" applyFont="1" applyFill="1"><alignment vertical="center"/></xf>
    <xf numFmtId="0" fontId="2" fillId="3" borderId="1" xfId="0" applyFont="1" applyFill="1" applyBorder="1"><alignment vertical="center"/></xf>
    <xf numFmtId="0" fontId="0" fillId="0" borderId="1" xfId="0" applyBorder="1"><alignment vertical="center"/></xf>
    <xf numFmtId="0" fontId="0" fillId="0" borderId="1" xfId="0" applyBorder="1"><alignment horizontal="center" vertical="center"/></xf>
    <xf numFmtId="0" fontId="3" fillId="0" borderId="0" xfId="0" applyFont="1"/>
  </cellXfs>
  <cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>
</styleSheet>"""
    content_types = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
  <Default Extension="xml" ContentType="application/xml"/>
  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
  <Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
  <Override PartName="/xl/worksheets/sheet2.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
  <Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
  <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
  <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
</Types>"""
    root_rels = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
</Relationships>"""
    workbook = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
  <sheets><sheet name="Redirect Map" sheetId="1" r:id="rId1"/><sheet name="Ringkasan" sheetId="2" r:id="rId2"/></sheets>
  <calcPr calcId="191029" calcMode="auto" fullCalcOnLoad="1" forceFullCalc="1"/>
</workbook>"""
    workbook_rels = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet2.xml"/>
  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
</Relationships>"""
    core_properties = f"""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <dc:title>Alur Skema SEO</dc:title><dc:creator>AdminSEO</dc:creator>
  <dcterms:created xsi:type="dcterms:W3CDTF">{datetime.now(timezone.utc).isoformat()}</dcterms:created>
</cp:coreProperties>"""
    app_properties = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
  <Application>AdminSEO</Application><TitlesOfParts><vt:vector size="2" baseType="lpstr"><vt:lpstr>Redirect Map</vt:lpstr><vt:lpstr>Ringkasan</vt:lpstr></vt:vector></TitlesOfParts>
</Properties>"""

    output = io.BytesIO()
    with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as archive:
        archive.writestr("[Content_Types].xml", content_types)
        archive.writestr("_rels/.rels", root_rels)
        archive.writestr("docProps/core.xml", core_properties)
        archive.writestr("docProps/app.xml", app_properties)
        archive.writestr("xl/workbook.xml", workbook)
        archive.writestr("xl/_rels/workbook.xml.rels", workbook_rels)
        archive.writestr("xl/styles.xml", styles)
        archive.writestr("xl/worksheets/sheet1.xml", redirect_sheet)
        archive.writestr("xl/worksheets/sheet2.xml", summary_sheet)
    return output.getvalue()


def create_user_account(username: str, password: str) -> dict[str, Any]:
    normalized_username = username.strip().lower()
    if not re.fullmatch(r"[a-z0-9._-]{3,32}", normalized_username):
        raise ValueError("Username harus 3-32 karakter dan hanya boleh berisi huruf, angka, titik, garis bawah, atau tanda hubung.")
    if len(password) < 8:
        raise ValueError("Password minimal 8 karakter.")
    if len(password) > 128:
        raise ValueError("Password maksimal 128 karakter.")

    now = utc_now()
    with db() as connection:
        existing = connection.execute(
            "SELECT id FROM users WHERE LOWER(username) = LOWER(?)",
            (normalized_username,),
        ).fetchone()
        if existing:
            raise ValueError("Username sudah digunakan.")
        cursor = connection.execute(
            """
            INSERT INTO users (username, password_hash, created_at, updated_at)
            VALUES (?, ?, ?, ?)
            """,
            (normalized_username, hash_password(password), now, now),
        )
        user_id = int(cursor.lastrowid)
    generated_user_dir(user_id).mkdir(parents=True, exist_ok=True)
    refresh_domain_txt(user_id)
    return {"id": user_id, "username": normalized_username}


def change_user_password(
    user_id: int,
    current_password: str,
    new_password: str,
    confirmation: str,
) -> None:
    if len(new_password) < 12:
        raise ValueError("Password baru minimal 12 karakter untuk penggunaan online.")
    if len(new_password) > 128:
        raise ValueError("Password baru maksimal 128 karakter.")
    if new_password != confirmation:
        raise ValueError("Konfirmasi password baru tidak sama.")
    if new_password == current_password:
        raise ValueError("Password baru harus berbeda dari password saat ini.")
    with db() as connection:
        user = connection.execute(
            "SELECT password_hash FROM users WHERE id = ?",
            (user_id,),
        ).fetchone()
        if not user or not verify_password(current_password, str(user["password_hash"])):
            raise ValueError("Password saat ini tidak benar.")
        connection.execute(
            "UPDATE users SET password_hash = ?, updated_at = ? WHERE id = ?",
            (hash_password(new_password), utc_now(), user_id),
        )
        connection.execute("DELETE FROM sessions WHERE user_id = ?", (user_id,))


def create_session(user_id: int) -> tuple[str, str]:
    token = secrets.token_urlsafe(40)
    expires_at = (datetime.now(timezone.utc) + timedelta(days=SESSION_DAYS)).replace(microsecond=0).isoformat()
    now = utc_now()
    with db() as connection:
        cleanup_sessions(connection)
        connection.execute(
            """
            INSERT INTO sessions (user_id, token_hash, expires_at, created_at)
            VALUES (?, ?, ?, ?)
            """,
            (user_id, token_hash(token), expires_at, now),
        )
    return token, expires_at


def destroy_session(token: str | None) -> None:
    if not token:
        return
    with db() as connection:
        connection.execute(
            "DELETE FROM sessions WHERE token_hash = ?",
            (token_hash(token),),
        )


def normalize_domain(value: str) -> tuple[str, str]:
    raw = value.strip()
    if not raw:
        raise ValueError("URL domain wajib diisi.")

    candidate = raw if re.match(r"^https?://", raw, re.I) else f"https://{raw}"
    parsed = urlparse(candidate)
    hostname = (parsed.hostname or "").lower().strip(".")
    if not hostname or "." not in hostname:
        raise ValueError("Masukkan domain valid, contoh: example.com")

    scheme = parsed.scheme.lower() if parsed.scheme.lower() in {"http", "https"} else "https"
    base_url = f"{scheme}://{hostname}"
    if parsed.port:
        base_url += f":{parsed.port}"
    return base_url, hostname


def slug_from_domain(hostname: str) -> str:
    slug = re.sub(r"[^a-z0-9]+", "-", hostname.lower()).strip("-")
    return slug or "landing-page"


def row_to_dict(row: sqlite3.Row) -> dict[str, Any]:
    output = dict(row)
    user_id = safe_int(output.get("user_id"))
    output["generated_urls"] = json.loads(output.get("generated_urls") or "[]")
    output["use_ai_content"] = bool(output.get("use_ai_content"))
    try:
        output["ai_content_json"] = json.loads(output.get("ai_content_json") or "{}")
    except json.JSONDecodeError:
        output["ai_content_json"] = {}
    try:
        output["finishing_report"] = json.loads(output.get("finishing_report") or "{}")
    except json.JSONDecodeError:
        output["finishing_report"] = {}
    output["media"] = {
        "logo": media_url(output.get("logo_media_id"), user_id),
        "icon": media_url(output.get("icon_media_id"), user_id),
        "main": media_url(output.get("main_media_id"), user_id),
    }
    return output


def load_project(project_id: int, user_id: int) -> dict[str, Any] | None:
    with db() as connection:
        row = connection.execute(
            "SELECT * FROM projects WHERE id = ? AND user_id = ?",
            (project_id, user_id),
        ).fetchone()
    return row_to_dict(row) if row else None


def save_project(payload: dict[str, Any], user_id: int) -> dict[str, Any]:
    domain_url, hostname = normalize_domain(str(payload.get("domain_url", "")))
    templates = template_menu_options()
    template_key = str(payload.get("template_key") or RANDOM_TEMPLATE_KEY)
    if template_key not in templates:
        template_key = RANDOM_TEMPLATE_KEY if RANDOM_TEMPLATE_KEY in templates else next(iter(templates), "clean-saas")
    amp_templates = amp_template_menu_options()
    amp_template_key = str(payload.get("amp_template_key") or RANDOM_AMP_TEMPLATE_KEY)
    if amp_template_key not in amp_templates:
        amp_template_key = RANDOM_AMP_TEMPLATE_KEY if RANDOM_AMP_TEMPLATE_KEY in amp_templates else next(iter(amp_templates), RANDOM_AMP_TEMPLATE_KEY)

    seo_title = str(payload.get("seo_title") or "").strip()[:120]
    amp_url = normalize_url_or_empty(str(payload.get("amp_url") or ""))
    if amp_url and not valid_public_url(amp_url):
        raise ValueError("AMP URL wajib berupa URL http/https yang valid.")
    title_included = 1 if payload.get("title_included") in {True, "true", "1", 1, "on"} else 0
    use_ai_content = 1 if payload.get("use_ai_content") in {True, "true", "1", 1, "on"} else 0
    ai_content_mode = str(payload.get("ai_content_mode") or "rewrite").strip().lower()
    if ai_content_mode not in {"rewrite", "fill"}:
        ai_content_mode = "rewrite"
    now = utc_now()

    values = {
        "user_id": user_id,
        "domain_url": domain_url,
        "hostname": hostname,
        "slug": slug_from_domain(hostname),
        "template_key": template_key,
        "amp_template_key": amp_template_key,
        "seo_title": seo_title,
        "meta_description": str(payload.get("meta_description") or "").strip()[:180],
        "keywords": str(payload.get("keywords") or "").strip()[:255],
        "hero_heading": str(payload.get("hero_heading") or "").strip()[:120],
        "hero_subheading": str(payload.get("hero_subheading") or "").strip()[:220],
        "article_body": str(payload.get("article_body") or "").strip(),
        "cta_label": str(payload.get("cta_label") or "").strip()[:60],
        "cta_url": str(payload.get("cta_url") or "").strip()[:255],
        "use_ai_content": use_ai_content,
        "ai_content_mode": ai_content_mode,
        "ai_instructions": str(payload.get("ai_instructions") or "").strip()[:2000],
        "amp_url": amp_url[:255],
        "alternate_links": str(payload.get("alternate_links") or "").strip(),
        "generate_faq": 1 if payload.get("generate_faq", True) in {True, "true", "1", 1, "on"} else 0,
        "generate_reviews": 1 if payload.get("generate_reviews", True) in {True, "true", "1", 1, "on"} else 0,
        "audit_before_save": 1 if payload.get("audit_before_save", True) in {True, "true", "1", 1, "on"} else 0,
        "logo_media_id": safe_int(payload.get("logo_media_id")),
        "icon_media_id": safe_int(payload.get("icon_media_id")),
        "main_media_id": safe_int(payload.get("main_media_id")),
        "title_included": title_included,
        "updated_at": now,
    }
    for media_field, media_label in MEDIA_ROLES.items():
        media_id = safe_int(values.get(media_field))
        if media_id and not media_record(media_id, user_id):
            raise ValueError(f"{media_label} tidak tersedia pada akun ini.")

    project_id = payload.get("id")
    with db() as connection:
        if project_id:
            existing = connection.execute(
                "SELECT id FROM projects WHERE id = ? AND user_id = ?",
                (project_id, user_id),
            ).fetchone()
            if not existing:
                raise ValueError("Project tidak ditemukan.")
            connection.execute(
                """
                UPDATE projects
                SET domain_url = :domain_url,
                    hostname = :hostname,
                    slug = :slug,
                    template_key = :template_key,
                    amp_template_key = :amp_template_key,
                    seo_title = :seo_title,
                    meta_description = :meta_description,
                    keywords = :keywords,
                    hero_heading = :hero_heading,
                    hero_subheading = :hero_subheading,
                    article_body = :article_body,
                    cta_label = :cta_label,
                    cta_url = :cta_url,
                    use_ai_content = :use_ai_content,
                    ai_content_mode = :ai_content_mode,
                    ai_instructions = :ai_instructions,
                    amp_url = :amp_url,
                    alternate_links = :alternate_links,
                    generate_faq = :generate_faq,
                    generate_reviews = :generate_reviews,
                    audit_before_save = :audit_before_save,
                    logo_media_id = :logo_media_id,
                    icon_media_id = :icon_media_id,
                    main_media_id = :main_media_id,
                    title_included = :title_included,
                    updated_at = :updated_at
                WHERE id = :id AND user_id = :user_id
                """,
                {**values, "id": int(project_id)},
            )
            saved_id = int(project_id)
        else:
            connection.execute(
                """
                INSERT INTO projects (
                    user_id, domain_url, hostname, slug, template_key, amp_template_key, seo_title,
                    meta_description, keywords, hero_heading, hero_subheading,
                    article_body, cta_label, cta_url, use_ai_content,
                    ai_content_mode, ai_instructions, logo_media_id,
                    amp_url, alternate_links, generate_faq, generate_reviews,
                    audit_before_save, icon_media_id, main_media_id, title_included,
                    created_at, updated_at
                )
                VALUES (
                    :user_id, :domain_url, :hostname, :slug, :template_key, :amp_template_key, :seo_title,
                    :meta_description, :keywords, :hero_heading, :hero_subheading,
                    :article_body, :cta_label, :cta_url, :use_ai_content,
                    :ai_content_mode, :ai_instructions, :logo_media_id,
                    :amp_url, :alternate_links, :generate_faq, :generate_reviews,
                    :audit_before_save, :icon_media_id, :main_media_id, :title_included,
                    :created_at, :updated_at
                )
                ON CONFLICT(user_id, domain_url) DO UPDATE SET
                    hostname = excluded.hostname,
                    slug = excluded.slug,
                    template_key = excluded.template_key,
                    amp_template_key = excluded.amp_template_key,
                    seo_title = excluded.seo_title,
                    meta_description = excluded.meta_description,
                    keywords = excluded.keywords,
                    hero_heading = excluded.hero_heading,
                    hero_subheading = excluded.hero_subheading,
                    article_body = excluded.article_body,
                    cta_label = excluded.cta_label,
                    cta_url = excluded.cta_url,
                    use_ai_content = excluded.use_ai_content,
                    ai_content_mode = excluded.ai_content_mode,
                    ai_instructions = excluded.ai_instructions,
                    amp_url = excluded.amp_url,
                    alternate_links = excluded.alternate_links,
                    generate_faq = excluded.generate_faq,
                    generate_reviews = excluded.generate_reviews,
                    audit_before_save = excluded.audit_before_save,
                    logo_media_id = excluded.logo_media_id,
                    icon_media_id = excluded.icon_media_id,
                    main_media_id = excluded.main_media_id,
                    title_included = excluded.title_included,
                    updated_at = excluded.updated_at
                """,
                {**values, "created_at": now},
            )
            saved_id = int(connection.execute(
                "SELECT id FROM projects WHERE domain_url = ? AND user_id = ?",
                (domain_url, user_id),
            ).fetchone()["id"])

    project = load_project(saved_id, user_id)
    if not project:
        raise ValueError("Project gagal disimpan.")
    return project


def list_projects(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            "SELECT * FROM projects WHERE user_id = ? ORDER BY updated_at DESC, id DESC",
            (user_id,),
        ).fetchall()
    return [row_to_dict(row) for row in rows]


def generated_projects(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            """
            SELECT * FROM projects
            WHERE user_id = ?
              AND last_generated_at IS NOT NULL
              AND publication_status = 'approved'
            ORDER BY last_generated_at DESC, id DESC
            """,
            (user_id,),
        ).fetchall()
    return [row_to_dict(row) for row in rows]


def pending_finishing_projects(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            """
            SELECT * FROM projects
            WHERE user_id = ?
              AND last_generated_at IS NOT NULL
              AND publication_status = 'pending'
            ORDER BY last_generated_at DESC, id DESC
            """,
            (user_id,),
        ).fetchall()
    projects = [row_to_dict(row) for row in rows]
    return [ensure_finishing_report(project) for project in projects]


def generation_history(user_id: int) -> list[dict[str, Any]]:
    with db() as connection:
        rows = connection.execute(
            """
            SELECT
              generation_logs.id,
              generation_logs.action,
              generation_logs.created_at,
              projects.id AS project_id,
              projects.hostname,
              projects.domain_url,
              projects.generated_path,
              projects.generated_urls,
              projects.publication_status
            FROM generation_logs
            JOIN projects ON projects.id = generation_logs.project_id
            WHERE projects.user_id = ?
            ORDER BY generation_logs.created_at DESC, generation_logs.id DESC
            LIMIT 200
            """,
            (user_id,),
        ).fetchall()
    history = []
    for row in rows:
        item = dict(row)
        item["generated_urls"] = json.loads(item.get("generated_urls") or "[]")
        history.append(item)
    return history


def domain_title(hostname: str) -> str:
    base = re.sub(r"^www\.", "", hostname, flags=re.I)
    name = re.sub(r"[^a-zA-Z0-9]+", " ", base.rsplit(".", 1)[0]).strip()
    return " ".join(part.capitalize() for part in name.split()) or hostname


def parse_domain_lines(value: Any) -> list[str]:
    if isinstance(value, list):
        raw_items = [str(item) for item in value]
    else:
        raw_items = re.split(r"[\r\n,]+", str(value or ""))
    domains: list[str] = []
    seen: set[str] = set()
    for item in raw_items:
        cleaned = item.strip()
        if not cleaned:
            continue
        domain_url, hostname = normalize_domain(cleaned)
        if domain_url in seen:
            continue
        seen.add(domain_url)
        domains.append(cleaned)
    return domains[:10]


def clean_domain_folder_name(value: str) -> str:
    cleaned = str(value or "").strip().strip("[]")
    if not cleaned:
        return ""
    return normalize_domain(cleaned)[1]


def parse_workflow_title_lines(value: Any) -> dict[str, str]:
    lines = [line.strip() for line in str(value or "").splitlines() if line.strip()]
    titles: dict[str, str] = {}
    pending_domain = ""
    for line in lines:
        if "|" in line:
            domain_part, title = [part.strip() for part in line.split("|", 1)]
            if domain_part and title:
                titles[clean_domain_folder_name(domain_part)] = title
            continue
        domain_match = re.match(r"^Domain\s*:\s*(.+)$", line, flags=re.I)
        if domain_match:
            pending_domain = clean_domain_folder_name(domain_match.group(1))
            continue
        title_match = re.match(r"^Title\s*:\s*(.*)$", line, flags=re.I)
        if title_match and pending_domain:
            title = title_match.group(1).strip()
            if title:
                titles[pending_domain] = title
            pending_domain = ""
    return titles


def workflow_domains(value: Any) -> list[str]:
    domains = []
    seen = set()
    for item in re.split(r"[\r\n,]+", str(value or "")):
        cleaned = item.strip().strip("[]")
        if not cleaned:
            continue
        domain_url, hostname = normalize_domain(cleaned)
        if hostname in seen:
            continue
        seen.add(hostname)
        domains.append(domain_url)
    return domains[:10]


def workflow_brand(value: Any) -> str:
    brand = re.sub(r"\s+", " ", str(value or "WAK89").strip()).upper()
    return brand[:32] or "WAK89"


def brand_asset_slug(value: Any) -> str:
    slug = re.sub(r"[^a-z0-9]+", "-", str(value or "brand").strip().lower()).strip("-")
    return slug[:48] or "brand"


def infer_workflow_niche(hostname: str) -> str:
    normalized = re.sub(r"^www\.", "", hostname.lower())
    tokens = [token for token in re.split(r"[^a-z0-9]+", normalized.rsplit(".", 1)[0]) if token]
    joined = " ".join(tokens)
    for hints, niche in NICHE_HINTS:
        if any(hint in joined for hint in hints):
            return niche
    readable = " ".join(token.capitalize() for token in tokens) or hostname
    return f"identitas {readable}, kebutuhan pengunjung, layanan lokal, dan informasi praktis yang relevan"


def workflow_title(hostname: str, supplied_title: str, brand: str, index: int) -> tuple[str, str, str]:
    if supplied_title.strip():
        return supplied_title.strip(), "USER TITLE", infer_workflow_niche(hostname)
    niche = infer_workflow_niche(hostname)
    domain_name = domain_title(hostname)
    separator = WORKFLOW_SEPARATORS[index % len(WORKFLOW_SEPARATORS)]
    modifiers = [
        f"Login Panduan {domain_name} dengan Referensi Praktis",
        f"Situs Alternatif {domain_name} untuk Pilihan yang Lebih Terarah",
        f"Link {domain_name} dan Info Pilihan yang Mudah Dipahami",
        f"Situs Login {domain_name} untuk Kebutuhan Pembaca Indonesia",
        f"Daftar Referensi {domain_name} dengan Sudut Niche yang Jelas",
    ]
    return f"{brand} {separator} {modifiers[index % len(modifiers)]}", "DOMAIN NICHE", niche


def workflow_description(title: str, niche: str, brand: str, index: int) -> str:
    variants = [
        f"{brand} merangkum {niche} melalui pembahasan natural yang membantu pembaca mengenali pilihan terbaik tanpa alur yang membingungkan.",
        f"Temukan bersama {brand} ulasan tentang {niche} dengan sudut baca yang jelas, praktis, dan dekat dengan kebutuhan pengunjung.",
        f"Melalui {brand}, pembaca dapat memahami {niche} lewat detail pilihan, manfaat, dan pertimbangan penting sebelum mengambil keputusan.",
        f"{brand} menghadirkan referensi {niche} yang nyaman dibaca, berbeda untuk tiap domain, dan tetap mengikuti topik utama halaman.",
    ]
    description = variants[index % len(variants)]
    return description[:170]


def workflow_amp_url(domain_url: str, words: str, index: int) -> str:
    parsed = urlparse(domain_url)
    candidates = [word.strip().lower() for word in re.split(r"[\s,]+", words or "") if word.strip()]
    candidates = [re.sub(r"[^a-z0-9-]+", "", word) for word in candidates]
    candidates = [word for word in candidates if word] or WORKFLOW_AMP_WORDS
    word = candidates[index % len(candidates)]
    return f"{parsed.scheme}://{word}.{parsed.hostname}/"


def workflow_image_urls(domain_url: str, brand: str) -> list[str]:
    base = domain_url.rstrip("/")
    brand_slug = brand_asset_slug(brand)
    return [
        f"{base}/img/gambar-{brand_slug}.jpg",
        f"{base}/img/logo-{brand_slug}.webp",
        f"{base}/img/icon.png",
    ]


def workflow_article_sections(title: str, niche: str, brand: str, domain_url: str, index: int) -> list[dict[str, str]]:
    hostname = urlparse(domain_url).hostname or domain_url
    domain_label = domain_title(hostname)
    openings = [
        f"Selamat datang di ruang baca {domain_label}, tempat {brand} mengangkat {niche} dengan alur yang langsung menyentuh kebutuhan pengunjung.",
        f"Datangnya {brand} sebagai referensi {domain_label} membuat pembahasan {niche} terasa lebih terarah dan tidak berhenti pada slogan.",
        f"{brand} menghadirkan referensi {domain_label} untuk pembaca yang ingin memahami {niche} dari sisi praktis sebelum menentukan pilihan.",
    ]
    section_topics = [
        ("Arah Utama dan Karakter Niche", openings[index % len(openings)] + f" Topik {title} dijaga tetap fokus agar pembaca menangkap konteks utama sejak awal, termasuk pilihan yang relevan, cara menilai kualitas, dan hal kecil yang sering menentukan kenyamanan."),
        ("Pilihan yang Layak Diperhatikan", f"Dalam niche ini, pembaca biasanya mencari perbandingan yang konkret. {brand} Login ditempatkan sebagai titik masuk natural untuk melihat pilihan, menimbang kebutuhan, dan memahami apakah {domain_label} lebih cocok untuk rencana cepat, kebutuhan rutin, atau keputusan yang butuh pertimbangan."),
        ("Detail Praktis untuk Pengunjung", f"Pembahasan {domain_label} perlu menyentuh detail nyata: kategori yang tersedia, suasana layanan, kualitas informasi, hingga cara pengguna mempersiapkan langkah berikutnya. Bagian ini menjaga narasi tetap dekat dengan kebutuhan orang Indonesia yang ingin membaca cepat tetapi tetap mendapat isi."),
        ("Cara Membandingkan Sebelum Memilih", f"Pengunjung tidak selalu membutuhkan janji besar. Mereka lebih terbantu oleh penjelasan tentang perbedaan opsi, tanda yang perlu dicek, dan alasan sebuah pilihan terasa masuk akal. {brand} Daftar hadir secara halus sebagai anchor bagi pembaca yang ingin lanjut tanpa memaksa alur baca."),
        ("Kesimpulan yang Siap Dipakai", f"Pada akhirnya, {title} harus memberi kesan utuh: topik jelas, manfaat mudah ditangkap, dan setiap bagian mendukung niat pencarian yang sama. Dengan struktur ini, {domain_label} memiliki konten yang tidak tercampur domain lain dan tetap menjaga {brand} sebagai keyword utama secara natural."),
    ]
    return [{"heading": heading, "body": body} for heading, body in section_topics]


def workflow_faqs(title: str, niche: str, brand: str, hostname: str) -> list[dict[str, str]]:
    domain_label = domain_title(hostname)
    return [
        {
            "question": f"Apa yang perlu diperhatikan saat membaca referensi {domain_label}?",
            "answer": f"Perhatikan kecocokan topik dengan kebutuhan utama, detail praktis yang diberikan, dan apakah pembahasan {niche} terasa konsisten. {brand} membantu menyusun alur agar pembaca tidak berpindah ke topik yang tidak relevan.",
        },
        {
            "question": f"Bagaimana cara menilai pilihan dalam topik {title}?",
            "answer": "Mulailah dari kebutuhan paling dekat, lalu bandingkan manfaat, konteks penggunaan, dan detail yang benar-benar bisa dipakai. Hindari memilih hanya karena judul terlihat ramai.",
        },
        {
            "question": f"Apakah {domain_label} cocok untuk pembaca Indonesia?",
            "answer": f"Cocok jika pembaca membutuhkan penjelasan yang ringan tetapi tetap spesifik. Bahasa dan sudut pembahasan diarahkan agar {brand} terasa natural untuk pembaca Indonesia.",
        },
        {
            "question": "Kapan informasi seperti ini paling berguna?",
            "answer": "Informasi ini berguna saat pembaca ingin mengenali pilihan sebelum mengambil tindakan. Bagian detail, perbandingan, dan review membantu memperkecil keraguan.",
        },
        {
            "question": "Apa manfaat membaca FAQ sebelum lanjut?",
            "answer": "FAQ membantu menangkap poin penting tanpa membaca ulang seluruh bagian. Pertanyaan dibuat mengikuti niche halaman, bukan pola umum yang sama untuk semua domain.",
        },
    ]


def workflow_reviews(hostname: str) -> list[dict[str, str]]:
    offset = sum(ord(char) for char in hostname) % len(INDONESIAN_PERSONAS)
    selected = [INDONESIAN_PERSONAS[(offset + index) % len(INDONESIAN_PERSONAS)] for index in range(5)]
    reviews = []
    for index, (name, city, body) in enumerate(selected):
        rating = "4" if index == 1 else "5"
        extra = [
            "Saya terbantu karena pembahasannya langsung masuk ke kebutuhan utama dan tidak terasa berpindah-pindah topik.",
            "Ada sedikit bagian yang menurut saya bisa dibuat lebih pendek, tetapi arah informasinya tetap jelas dan mudah diikuti.",
            "Detail praktisnya berguna, terutama saat ingin membandingkan pilihan tanpa membaca penjelasan yang terlalu umum.",
            "Isi halamannya terasa lengkap karena ada artikel, FAQ, dan sudut review yang saling mendukung.",
            "Gaya penyajiannya enak dibaca, tidak kaku, dan masih relevan dengan topik yang saya cari.",
        ][index]
        reviews.append({"name": name, "city": city, "rating": rating, "body": f"{body} {extra}"})
    return reviews


def workflow_content_file(
    domain_url: str,
    amp_url: str,
    image_urls: list[str],
    title: str,
    description: str,
    sections: list[dict[str, str]],
    faqs: list[dict[str, str]],
    reviews: list[dict[str, str]],
) -> str:
    article = "\n\n".join(f"{section['heading']}\n{section['body']}" for section in sections)
    faq_text = "\n".join(f"{item['question']}\n{item['answer']}" for item in faqs)
    review_text = "\n".join(
        f"{item['name']} - {item['city']} - {item['rating']}/5\n\"{item['body']}\""
        for item in reviews
    )
    return f"""URL UTAMA :
{domain_url}
URL AMP dan rel alternate indonesia & english : 
{amp_url}
URL GAMBAR :
{image_urls[0]}
{image_urls[1]}
{image_urls[2]}
Titel :
{title}
Deskripsi :
{description}
Kontent :
{article}

FAQ (Pertanyaan yang Sering Diajukan)
{faq_text}
5 Review Pengguna (Persona)
{review_text}
"""


def workflow_audit(
    content: str,
    domain_url: str,
    amp_url: str,
    image_urls: list[str],
    title: str,
    description: str,
    brand: str,
    sections: list[dict[str, str]],
    faqs: list[dict[str, str]],
    reviews: list[dict[str, str]],
) -> list[str]:
    issues = []
    if domain_url not in content:
        issues.append("URL UTAMA")
    if amp_url not in content:
        issues.append("URL AMP")
    if not all(url in content for url in image_urls):
        issues.append("URL GAMBAR")
    if brand.lower() not in title.lower():
        issues.append("title brand")
    if brand.lower() not in description.lower():
        issues.append("deskripsi brand")
    if len(sections) != 5:
        issues.append("5 bagian artikel")
    if len(faqs) != 5:
        issues.append("5 FAQ")
    if len(reviews) != 5 or not any(item["rating"] == "4" for item in reviews):
        issues.append("5 review + rating 4")
    if "[" in content or "]" in content:
        issues.append("tanda kurung siku")
    return issues


def workflow_payload_rows(payload: dict[str, Any]) -> list[dict[str, Any]]:
    raw_rows = payload.get("rows")
    if isinstance(raw_rows, list):
        rows = []
        for row in raw_rows[:10]:
            if not isinstance(row, dict):
                continue
            domain = str(row.get("domain_url") or row.get("domain") or "").strip()
            if not domain:
                continue
            rows.append({
                "domain_url": domain,
                "title": str(row.get("title") or "").strip(),
                "template_key": str(row.get("template_key") or "").strip(),
                "amp_template_key": str(row.get("amp_template_key") or "").strip(),
                "media_group_id": row.get("media_group_id"),
            })
        return rows

    title_map = parse_workflow_title_lines(payload.get("titles") or "")
    rows = []
    for domain_url in workflow_domains(payload.get("domains") or ""):
        _domain_url, hostname = normalize_domain(domain_url)
        rows.append({
            "domain_url": domain_url,
            "title": title_map.get(hostname, ""),
            "template_key": str(payload.get("template_key") or "").strip(),
            "amp_template_key": str(payload.get("amp_template_key") or "").strip(),
            "media_group_id": payload.get("media_group_id"),
        })
    return rows


def amp_theme(template_key: str | None) -> dict[str, str]:
    themes = [
        {"accent": "#087f8c", "accent_dark": "#07505a", "surface": "#ffffff", "background": "#eef8f8", "ink": "#102b32", "muted": "#496970"},
        {"accent": "#1d4ed8", "accent_dark": "#173b8f", "surface": "#ffffff", "background": "#eff6ff", "ink": "#172554", "muted": "#53658c"},
        {"accent": "#b42318", "accent_dark": "#7a271a", "surface": "#ffffff", "background": "#fff4f1", "ink": "#3f1d18", "muted": "#78534d"},
        {"accent": "#047857", "accent_dark": "#065f46", "surface": "#ffffff", "background": "#ecfdf5", "ink": "#12382c", "muted": "#4d7065"},
        {"accent": "#a15c00", "accent_dark": "#754200", "surface": "#ffffff", "background": "#fff9e8", "ink": "#3d2b10", "muted": "#746141"},
    ]
    digest = hashlib.sha256(str(template_key or "adminseo-amp").encode("utf-8")).digest()
    return themes[digest[0] % len(themes)]


def workflow_amp_html(project: dict[str, Any], content: str, template_key: str | None = None) -> str:
    return workflow_amp_landing_html(
        project,
        str(project.get("article_body") or content),
        generated_faqs(project),
        generated_reviews(project),
        template_key,
    )


def workflow_amp_landing_html(
    project: dict[str, Any],
    article_body: str,
    faqs: list[dict[str, str]],
    reviews: list[dict[str, str]],
    template_key: str | None = None,
) -> str:
    title_text = str(project.get("seo_title") or project.get("hostname") or "Landing Page")
    description_text = str(project.get("meta_description") or project.get("hero_subheading") or title_text)
    title = html.escape(title_text)
    description = html.escape(description_text, quote=True)
    canonical_url = str(project.get("domain_url") or "").rstrip("/") + "/"
    canonical = html.escape(canonical_url, quote=True)
    cta_url = html.escape(normalize_url_or_empty(str(project.get("cta_url") or project["domain_url"])), quote=True)
    cta_label = html.escape(project.get("cta_label") or "Login Sekarang")
    theme = amp_theme(template_key)
    media_assets = project_media_assets(project)

    def media_src(role: str) -> str:
        media = media_assets.get(role)
        if not media:
            return ""
        source = Path(media["file_path"])
        suffix = source.suffix or ALLOWED_IMAGE_TYPES.get(media["content_type"], ".img")
        return html.escape(f"../adminseo-media/{quote(role + suffix)}", quote=True)

    main_src = media_src("main")
    logo_src = media_src("logo")
    icon_src = media_src("icon")
    paragraphs = [
        paragraph.strip()
        for paragraph in re.split(r"\n{2,}", str(article_body or ""))
        if paragraph.strip()
    ][:8]
    article_markup = "\n".join(f"      <p>{html.escape(paragraph)}</p>" for paragraph in paragraphs)
    faq_markup = "\n".join(
        f"""
      <section class="faq-item">
        <h3>{html.escape(item["question"])}</h3>
        <p>{html.escape(item["answer"])}</p>
      </section>"""
        for item in faqs[:5]
    )
    review_markup = "\n".join(
        f"""
      <section class="review-item">
        <strong>{html.escape(item["name"])} - {html.escape(item["city"])} - {html.escape(item["rating"])}/5</strong>
        <p>{html.escape(item["body"])}</p>
      </section>"""
        for item in reviews[:5]
    )
    image_markup = (
        f'<amp-img class="hero-img" src="{main_src}" width="900" height="520" layout="responsive" alt="{title}"></amp-img>'
        if main_src
        else ""
    )
    logo_markup = (
        f'<amp-img class="brand-logo" src="{logo_src}" width="180" height="60" layout="intrinsic" alt="Logo {html.escape(project_brand(project), quote=True)}"></amp-img>'
        if logo_src
        else f'<strong class="brand-name">{html.escape(project_brand(project))}</strong>'
    )
    icon_markup = f'<link rel="icon" href="{icon_src}">' if icon_src else ""
    alternate_markup = "\n".join(
        f'  <link rel="alternate" hreflang="{html.escape(language, quote=True)}" href="{html.escape(url, quote=True)}">'
        for language, url in parse_alternate_links(str(project.get("alternate_links") or ""))
        if valid_public_url(url)
    )
    schema = {
        "@context": "https://schema.org",
        "@type": "WebPage",
        "name": title_text,
        "description": description_text,
        "url": canonical_url,
        "inLanguage": "id-ID",
        "mainEntity": [
            {
                "@type": "Question",
                "name": item["question"],
                "acceptedAnswer": {"@type": "Answer", "text": item["answer"]},
            }
            for item in faqs[:5]
        ],
    }
    schema_json = json.dumps(schema, ensure_ascii=False).replace("</", "<\\/")
    template_name = html.escape(str(template_key or "adminseo-valid-amp"), quote=True)
    custom_css = """*{box-sizing:border-box}body{font-family:Arial,sans-serif;margin:0;color:__INK__;background:__BACKGROUND__}a{color:inherit}.site-head{border-bottom:1px solid rgba(0,0,0,.09);background:__SURFACE__}.head-wrap,main,.site-footer{width:100%;max-width:980px;margin:0 auto;padding-left:18px;padding-right:18px}.head-wrap{min-height:78px;display:flex;align-items:center;justify-content:space-between;gap:18px}.brand-logo{max-width:180px}.brand-name{font-size:22px;color:__ACCENT_DARK__}.head-link{font-weight:700;text-decoration:none;color:__ACCENT__}main{padding-top:30px;padding-bottom:46px}.hero{padding:30px 0 22px}.eyebrow{color:__ACCENT__;font-weight:700;text-transform:uppercase;letter-spacing:0}h1{font-size:40px;line-height:1.08;margin:8px 0 14px}h2{font-size:26px;margin-top:34px}h3{font-size:18px;margin:0 0 8px}p{line-height:1.75;color:__MUTED__}.cta{display:inline-block;margin:12px 0 20px;padding:13px 18px;border-radius:8px;background:__ACCENT_DARK__;color:#fff;text-decoration:none;font-weight:700}.hero-img{border-radius:8px;margin-top:18px;background:#d8e7f4}.panel,.faq-item,.review-item{background:__SURFACE__;border:1px solid rgba(0,0,0,.1);border-radius:8px}.panel{padding:18px;margin:12px 0}.faq-item,.review-item{padding:16px;margin:10px 0}.review-item strong{display:block;color:__ACCENT__}.site-footer{padding-top:24px;padding-bottom:30px;border-top:1px solid rgba(0,0,0,.09);color:__MUTED__}@media(max-width:600px){h1{font-size:32px}.head-wrap{min-height:68px}}"""
    for token, color in (
        ("__INK__", theme["ink"]),
        ("__BACKGROUND__", theme["background"]),
        ("__SURFACE__", theme["surface"]),
        ("__ACCENT_DARK__", theme["accent_dark"]),
        ("__ACCENT__", theme["accent"]),
        ("__MUTED__", theme["muted"]),
    ):
        custom_css = custom_css.replace(token, color)
    amp_boilerplate = """<style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style><noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>"""
    return f"""<!doctype html>
<html amp lang="id">
<head>
  <meta charset="utf-8">
  <title>{title}</title>
  <meta name="description" content="{description}">
  <meta name="robots" content="index,follow">
  <meta name="generator" content="AdminSEO AMPALL {template_name}">
  <link rel="canonical" href="{canonical}">
  {icon_markup}
{alternate_markup}
  <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">
  {amp_boilerplate}
  <script async src="https://cdn.ampproject.org/v0.js"></script>
  <script type="application/ld+json">{schema_json}</script>
  <style amp-custom>{custom_css}</style>
</head>
<body>
  <header class="site-head">
    <div class="head-wrap">
      <a href="{cta_url}" aria-label="{html.escape(project_brand(project), quote=True)}">{logo_markup}</a>
      <a class="head-link" href="{cta_url}">{cta_label}</a>
    </div>
  </header>
  <main>
    <section class="hero">
      <p class="eyebrow">AMP Landing Page</p>
      <h1>{title}</h1>
      <p>{description}</p>
      <a class="cta" href="{cta_url}">{cta_label}</a>
      {image_markup}
    </section>
    <section class="panel">
      <h2>Konten Utama</h2>
{article_markup}
    </section>
    <section>
      <h2>FAQ</h2>
{faq_markup}
    </section>
    <section>
      <h2>Review Pengguna Indonesia</h2>
{review_markup}
    </section>
  </main>
  <footer class="site-footer">&copy; {datetime.now().year} {html.escape(project_brand(project))}. Informasi untuk {html.escape(str(project.get('hostname') or 'website'))}.</footer>
</body>
</html>
"""


def run_workflow_starter(payload: dict[str, Any], user_id: int) -> dict[str, Any]:
    rows = workflow_payload_rows(payload)
    if not rows:
        raise ValueError("Masukkan minimal satu domain untuk Auto Workflow.")
    brand = workflow_brand(payload.get("brand"))
    amp_words = str(payload.get("amp_words") or "")

    defaults = dict(payload)
    apply_media_group(defaults, safe_int(payload.get("media_group_id")), user_id)
    generated = []
    errors = []
    cpanel_lines = []

    for index, row in enumerate(rows):
        domain_url = str(row.get("domain_url") or "").strip()
        try:
            _domain_url, hostname = normalize_domain(domain_url)
            domain_url = _domain_url
            row_defaults = dict(defaults)
            apply_media_group(row_defaults, safe_int(row.get("media_group_id")), user_id)
            template_key = str(row.get("template_key") or payload.get("template_key") or RANDOM_TEMPLATE_KEY).strip()
            amp_template_key = str(row.get("amp_template_key") or payload.get("amp_template_key") or RANDOM_AMP_TEMPLATE_KEY).strip()
            title, title_source, niche = workflow_title(hostname, str(row.get("title") or ""), brand, index)
            description = workflow_description(title, niche, brand, index)
            amp_url = workflow_amp_url(domain_url, amp_words, index)
            image_urls = workflow_image_urls(domain_url, brand)
            sections = workflow_article_sections(title, niche, brand, domain_url, index)
            faqs = workflow_faqs(title, niche, brand, hostname)
            reviews = workflow_reviews(hostname)
            content = workflow_content_file(domain_url, amp_url, image_urls, title, description, sections, faqs, reviews)
            issues = workflow_audit(content, domain_url, amp_url, image_urls, title, description, brand, sections, faqs, reviews)
            if issues:
                raise ValueError("Audit workflow gagal: " + ", ".join(issues))

            article_body = "\n\n".join(f"{section['heading']}\n{section['body']}" for section in sections)
            project_payload = batch_project_payload(domain_url, {
                **row_defaults,
                "template_key": template_key,
                "amp_template_key": amp_template_key,
                "seo_title": title,
                "meta_description": description,
                "keywords": f"{brand}, {brand} Login, {brand} Daftar, {domain_title(hostname)}",
                "hero_heading": title,
                "hero_subheading": description,
                "article_body": article_body,
                "cta_label": str(payload.get("cta_label") or f"Login {brand}"),
                "cta_url": str(payload.get("cta_url") or domain_url),
                "amp_url": amp_url,
                "alternate_links": f"id|{domain_url}/\nen|{domain_url}/en/",
                "generate_faq": True,
                "generate_reviews": True,
                "audit_before_save": True,
            }, index)
            project_payload.update({
                "template_key": template_key,
                "amp_template_key": amp_template_key,
                "seo_title": title,
                "meta_description": description,
                "hero_heading": title,
                "hero_subheading": description,
                "article_body": article_body,
                "keywords": f"{brand}, {brand} Login, {brand} Daftar, {domain_title(hostname)}",
                "cta_label": str(payload.get("cta_label") or f"Login {brand}"),
                "cta_url": str(payload.get("cta_url") or domain_url),
                "amp_url": amp_url,
                "alternate_links": f"id|{domain_url}/\nen|{domain_url}/en/",
            })
            project = save_project(project_payload, user_id)
            paths = generated_paths(project)
            paths["folder"].mkdir(parents=True, exist_ok=True)
            result = write_generated_file(project, "all", require_media=False)
            project = result["project"] or project
            if bool(project.get("use_ai_content")):
                ai_payload = project.get("ai_content_json")
                ai_content = ai_payload.get("content") if isinstance(ai_payload, dict) else {}
                title = str(project.get("seo_title") or title)
                description = str(project.get("meta_description") or description)
                sections = [
                    {
                        "heading": str(item.get("heading") or ""),
                        "body": str(item.get("body") or ""),
                    }
                    for item in ai_content.get("article_sections") or []
                    if isinstance(item, dict)
                ]
                faqs = generated_faqs(project)
                reviews = generated_reviews(project)
                title_source = "OPENAI"
                content = workflow_content_file(
                    domain_url,
                    amp_url,
                    image_urls,
                    title,
                    description,
                    sections,
                    faqs,
                    reviews,
                )
                issues = workflow_audit(
                    content,
                    domain_url,
                    amp_url,
                    image_urls,
                    title,
                    description,
                    brand,
                    sections,
                    faqs,
                    reviews,
                )
                if issues:
                    raise ValueError("Audit konten AI gagal: " + ", ".join(issues))
            files = list(result["files"])
            template = result["template"]
            amp_template = result.get("amp_template")
            paths["folder"].joinpath("content").write_text(content, encoding="utf-8")
            if "content" not in files:
                files.append("content")
            urls = []
            for name in files:
                url = f"/generated/{quote(project['slug'])}/{quote(name)}"
                if url not in urls:
                    urls.append(url)
            now = utc_now()
            with db() as connection:
                connection.execute(
                    """
                    UPDATE projects
                    SET last_generated_at = ?,
                        generated_path = ?,
                        generated_urls = ?,
                        updated_at = ?
                    WHERE id = ? AND user_id = ?
                    """,
                    (now, str(paths["folder"]), json.dumps(urls), now, project["id"], user_id),
                )
                connection.execute(
                    "INSERT INTO generation_logs (project_id, action, created_at) VALUES (?, ?, ?)",
                    (project["id"], "workflow", now),
                )
            cpanel_lines.extend([hostname, urlparse(amp_url).hostname or amp_url])
            generated.append({
                "domain": hostname,
                "title_source": title_source,
                "title": title,
                "description": description,
                "article": "5 bagian",
                "faq": "5",
                "review": "5",
                "status": "MENUNGGU FINISHING",
                "folder": str(paths["folder"]),
                "urls": urls,
                "template": template or project.get("template_key") or template_key,
                "amp_template": amp_template or project.get("amp_template_key") or amp_template_key,
            })
        except ValueError as exc:
            errors.append({"domain": domain_url, "error": str(exc), "status": "CONTENT GAGAL"})

    refresh_domain_txt(user_id)
    return {
        "generated": generated,
        "errors": errors,
        "domain_txt": "/generated/domain.txt",
    }


def batch_project_payload(domain_value: str, defaults: dict[str, Any], index: int = 0) -> dict[str, Any]:
    domain_url, hostname = normalize_domain(domain_value)
    title_base = domain_title(hostname)
    angle = CONTENT_ANGLES[index % len(CONTENT_ANGLES)]
    keywords = str(defaults.get("keywords") or f"{title_base}, landing page, layanan online").strip()
    primary_keyword = split_keywords({"keywords": keywords})[0] if keywords else title_base
    seo_title = str(defaults.get("seo_title") or "").strip()
    if seo_title:
        seo_title = f"{title_base} - {seo_title}" if title_base.lower() not in seo_title.lower() else f"{seo_title} ({index + 1})"
    else:
        seo_title = f"{title_base} - {angle.capitalize()}"
    meta_description = str(defaults.get("meta_description") or "").strip()
    if meta_description:
        meta_description = f"{title_base}: {meta_description}"
    else:
        meta_description = f"{title_base} menghadirkan {angle} dengan fokus {primary_keyword}, konten unik, review pengguna, FAQ, dan struktur SEO siap publish."
    hero_heading = str(defaults.get("hero_heading") or "").strip()
    if hero_heading:
        hero_heading = f"{title_base} - {hero_heading}" if title_base.lower() not in hero_heading.lower() else f"{hero_heading} #{index + 1}"
    else:
        hero_heading = f"{title_base}: {angle.capitalize()}"
    hero_subheading = str(defaults.get("hero_subheading") or "").strip()
    if hero_subheading:
        hero_subheading = f"{hero_subheading} Halaman ini dibuat khusus untuk {hostname} dengan sudut konten: {angle}."
    else:
        hero_subheading = f"Landing page ini dibuat khusus untuk {hostname}, memakai media pilihan, template acak atau terpilih, serta artikel yang berbeda untuk tiap domain."
    article_body = str(defaults.get("article_body") or "").strip()
    if article_body:
        article_body = f"{article_body}\n\nCatatan khusus {hostname}: halaman ini memakai angle {angle}, sehingga susunan artikel, FAQ, dan review tetap dibedakan dari domain lain dalam batch."
    return {
        "domain_url": domain_url,
        "template_key": defaults.get("template_key") or RANDOM_TEMPLATE_KEY,
        "amp_template_key": defaults.get("amp_template_key") or RANDOM_AMP_TEMPLATE_KEY,
        "seo_title": seo_title,
        "meta_description": meta_description,
        "keywords": keywords,
        "hero_heading": hero_heading,
        "hero_subheading": hero_subheading,
        "article_body": article_body,
        "cta_label": str(defaults.get("cta_label") or "Buka Sekarang").strip(),
        "cta_url": str(defaults.get("cta_url") or domain_url).strip(),
        "use_ai_content": defaults.get("use_ai_content", False),
        "ai_content_mode": str(defaults.get("ai_content_mode") or "rewrite"),
        "ai_instructions": str(defaults.get("ai_instructions") or ""),
        "amp_url": str(defaults.get("amp_url") or "").strip(),
        "alternate_links": str(defaults.get("alternate_links") or "").strip(),
        "generate_faq": defaults.get("generate_faq", True),
        "generate_reviews": defaults.get("generate_reviews", True),
        "audit_before_save": defaults.get("audit_before_save", True),
        "logo_media_id": defaults.get("logo_media_id"),
        "icon_media_id": defaults.get("icon_media_id"),
        "main_media_id": defaults.get("main_media_id"),
        "title_included": defaults.get("title_included", True),
    }


def row_value(row: dict[str, Any], defaults: dict[str, Any], key: str) -> Any:
    value = row.get(key)
    if value is None or value == "":
        return defaults.get(key)
    return value


def batch_rows(payload: dict[str, Any]) -> list[dict[str, Any]]:
    rows = payload.get("rows")
    if isinstance(rows, list):
        return [row for row in rows[:10] if isinstance(row, dict)]
    return [{"domain_url": domain} for domain in parse_domain_lines(payload.get("domains") or payload.get("domain_url") or "")]


def apply_media_group(defaults: dict[str, Any], group_id: int | None, user_id: int) -> None:
    if not group_id:
        return
    group = load_media_group(group_id, user_id)
    if not group:
        raise ValueError("Media Group tidak ditemukan.")
    defaults["logo_media_id"] = group["logo_media_id"]
    defaults["icon_media_id"] = group["icon_media_id"]
    defaults["main_media_id"] = group["main_media_id"]


def validate_media_payload(payload: dict[str, Any], user_id: int) -> None:
    missing = []
    for key, label in MEDIA_ROLES.items():
        if not media_record(safe_int(payload.get(key)), user_id):
            missing.append(label)
    if missing:
        raise ValueError(f"Pilih media wajib: {', '.join(missing)}.")


def batch_row_project_payload(row: dict[str, Any], defaults: dict[str, Any], index: int, user_id: int) -> dict[str, Any]:
    domain_value = str(row.get("domain_url") or row.get("domain") or "").strip()
    if not domain_value:
        raise ValueError("Domain pada baris generator wajib diisi.")

    row_defaults = dict(defaults)
    for key in (
        "template_key",
        "amp_template_key",
        "seo_title",
        "meta_description",
        "keywords",
        "hero_heading",
        "hero_subheading",
        "article_body",
        "cta_label",
        "cta_url",
        "amp_url",
        "alternate_links",
        "logo_media_id",
        "icon_media_id",
        "main_media_id",
    ):
        value = row_value(row, defaults, key)
        if value is not None:
            row_defaults[key] = value
    for key in ("generate_faq", "generate_reviews", "audit_before_save", "title_included"):
        if key in row:
            row_defaults[key] = row.get(key)

    apply_media_group(row_defaults, safe_int(row.get("media_group_id")), user_id)
    project_payload = batch_project_payload(domain_value, row_defaults, index)
    validate_media_payload(project_payload, user_id)
    return project_payload


def batch_generate(payload: dict[str, Any], user_id: int) -> dict[str, Any]:
    rows = batch_rows(payload)
    if not rows:
        raise ValueError("Masukkan minimal satu domain.")

    generated = []
    errors = []
    seen_domains: set[str] = set()
    for index, row in enumerate(rows):
        domain_value = str(row.get("domain_url") or row.get("domain") or "").strip()
        try:
            domain_url, _hostname = normalize_domain(domain_value)
            if domain_url in seen_domains:
                errors.append({"domain": domain_value, "error": "Domain duplikat dilewati."})
                continue
            seen_domains.add(domain_url)
            project = save_project(batch_row_project_payload(row, payload, index, user_id), user_id)
            result = write_generated_file(project, "all")
            generated.append(result)
        except ValueError as exc:
            errors.append({"domain": domain_value, "error": str(exc)})
    return {"generated": generated, "errors": errors}


def export_generated_zip(user_id: int, project_ids: list[int] | None = None) -> bytes:
    projects = generated_projects(user_id)
    if project_ids:
        wanted = set(project_ids)
        projects = [project for project in projects if int(project["id"]) in wanted]
    if not projects:
        raise ValueError("Belum ada landing page yang berhasil digenerate.")

    output = io.BytesIO()
    root = GENERATED_DIR.resolve()
    with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as archive:
        domain_txt = generated_user_dir(user_id) / "domain.txt"
        if domain_txt.is_file():
            archive.write(domain_txt, domain_txt.name)
        for project in projects:
            folder = Path(project.get("generated_path") or generated_paths(project)["folder"]).resolve()
            if not folder.exists() or root not in folder.parents:
                continue
            for file_path in folder.rglob("*"):
                if file_path.is_file():
                    archive.write(file_path, Path(project["slug"]) / file_path.relative_to(folder))
    return output.getvalue()


def generated_paths(project: dict[str, Any]) -> dict[str, Path]:
    user_id = safe_int(project.get("user_id"))
    folder = (generated_user_dir(user_id) if user_id else GENERATED_DIR) / project["slug"]
    return {
        "folder": folder,
        "index": folder / "index.html",
        "amp_folder": folder / "amp",
        "amp_index": folder / "amp" / "index.html",
        "sitemap": folder / "sitemap.xml",
        "robots": folder / "robots.txt",
    }


def html_page(project: dict[str, Any]) -> str:
    template = FALLBACK_TEMPLATES.get("clean-saas", {})
    title = html.escape(project["seo_title"] or project["hostname"])
    description = html.escape(project["meta_description"] or project["hero_subheading"])
    keywords = html.escape(project["keywords"] or "")
    heading = html.escape(project["hero_heading"] or project["seo_title"])
    subheading = html.escape(project["hero_subheading"] or "")
    cta_label = html.escape(project["cta_label"] or "Mulai Sekarang")
    cta_url = html.escape(project["cta_url"] or project["domain_url"], quote=True)
    domain_url = html.escape(project["domain_url"], quote=True)
    visible_title = f'<p class="eyebrow">{title}</p>' if project["title_included"] else ""
    accent = template["accent"]

    return f"""<!doctype html>
<html lang="id">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{title}</title>
  <meta name="description" content="{description}">
  <meta name="keywords" content="{keywords}">
  <link rel="canonical" href="{domain_url}/">
  <meta property="og:title" content="{title}">
  <meta property="og:description" content="{description}">
  <meta property="og:type" content="website">
  <meta property="og:url" content="{domain_url}/">
  <style>
    :root {{ color-scheme: light; --accent: {accent}; --ink: #172033; --muted: #5f6b7a; --line: #dbe4ef; }}
    * {{ box-sizing: border-box; }}
    body {{ margin: 0; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: var(--ink); background: #f7fafc; }}
    .hero {{ min-height: 72vh; display: grid; align-items: center; padding: 72px 22px; background: linear-gradient(135deg, #ffffff 0%, #eef6ff 45%, #f8f3e8 100%); }}
    .wrap {{ width: min(1120px, 100%); margin: 0 auto; }}
    .eyebrow {{ color: var(--accent); font-weight: 800; text-transform: uppercase; letter-spacing: .08em; font-size: 13px; margin: 0 0 16px; }}
    h1 {{ max-width: 850px; font-size: clamp(42px, 7vw, 84px); line-height: .96; margin: 0; letter-spacing: 0; }}
    .lead {{ max-width: 720px; color: var(--muted); font-size: clamp(18px, 2.2vw, 24px); line-height: 1.6; margin: 24px 0 34px; }}
    .actions {{ display: flex; gap: 14px; flex-wrap: wrap; align-items: center; }}
    .btn {{ display: inline-flex; align-items: center; justify-content: center; min-height: 48px; padding: 0 22px; border-radius: 8px; background: var(--accent); color: #fff; text-decoration: none; font-weight: 800; }}
    .ghost {{ color: var(--ink); text-decoration: none; font-weight: 700; }}
    .proof {{ display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 18px; padding: 56px 22px; background: #fff; }}
    .proof .wrap {{ display: contents; }}
    .item {{ border: 1px solid var(--line); border-radius: 8px; padding: 22px; background: #fff; }}
    .item b {{ display: block; margin-bottom: 8px; font-size: 18px; }}
    .item p {{ margin: 0; color: var(--muted); line-height: 1.55; }}
    footer {{ padding: 28px 22px; color: var(--muted); text-align: center; border-top: 1px solid var(--line); background: #fff; }}
    @media (max-width: 760px) {{ .proof {{ grid-template-columns: 1fr; }} .hero {{ min-height: auto; }} }}
  </style>
</head>
<body>
  <main>
    <section class="hero">
      <div class="wrap">
        {visible_title}
        <h1>{heading}</h1>
        <p class="lead">{subheading}</p>
        <div class="actions">
          <a class="btn" href="{cta_url}">{cta_label}</a>
          <a class="ghost" href="{domain_url}/">Kunjungi Website</a>
        </div>
      </div>
    </section>
    <section class="proof" aria-label="Keunggulan">
      <div class="wrap">
        <article class="item"><b>SEO siap publish</b><p>Title, description, canonical, dan Open Graph sudah ditanam di halaman.</p></article>
        <article class="item"><b>Struktur cepat</b><p>Markup ringan dan responsif untuk campaign, bisnis lokal, atau produk digital.</p></article>
        <article class="item"><b>Fokus konversi</b><p>Hero, copy, dan CTA dibuat jelas agar pengunjung langsung memahami penawaran.</p></article>
      </div>
    </section>
  </main>
  <footer>&copy; {datetime.now().year} {html.escape(project["hostname"])}</footer>
</body>
</html>
"""


def sitemap_xml(project: dict[str, Any]) -> str:
    lastmod = datetime.now(timezone.utc).date().isoformat()
    domain = html.escape(project["domain_url"], quote=True)
    return f"""<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>{domain}/</loc>
    <lastmod>{lastmod}</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
</urlset>
"""


def robots_txt(project: dict[str, Any]) -> str:
    return f"""User-agent: *
Allow: /

Sitemap: {project["domain_url"]}/sitemap.xml
"""


def split_keywords(project: dict[str, Any]) -> list[str]:
    keywords = [item.strip() for item in str(project.get("keywords") or "").split(",")]
    return [item for item in keywords if item]


def auto_content(project: dict[str, Any]) -> dict[str, str]:
    title = str(project.get("seo_title") or project.get("hostname") or "Landing Page").strip()
    keywords = split_keywords(project)
    primary_keyword = keywords[0] if keywords else title
    keyword_text = ", ".join(keywords[:4]) if keywords else primary_keyword
    description = str(project.get("meta_description") or "").strip()
    hostname = str(project.get("hostname") or "")
    variant = sum(ord(char) for char in hostname) % len(CONTENT_ANGLES)
    angle = CONTENT_ANGLES[variant]

    heading = str(project.get("hero_heading") or "").strip() or title
    subheading = str(project.get("hero_subheading") or "").strip() or (
        description or f"Temukan informasi lengkap tentang {primary_keyword} melalui halaman yang cepat, rapi, dan siap SEO."
    )
    cta_label = str(project.get("cta_label") or "").strip() or "Lihat Penawaran"
    article_body = str(project.get("article_body") or "").strip()
    if not article_body:
        article_body = "\n\n".join([
            f"{title} dibuat sebagai {angle}. Halaman ini membantu pengunjung memahami konteks {primary_keyword} tanpa harus membaca informasi yang berputar-putar.",
            f"Konten untuk {hostname or title} disusun dengan pendekatan berbeda agar tidak terasa duplikat. Kata kunci seperti {keyword_text} ditempatkan secara natural di dalam narasi, bukan sekadar diulang.",
            f"{description or 'Setiap bagian landing page disusun untuk memberi gambaran manfaat, keunggulan, dan ajakan tindakan yang kuat.'} Media Library memastikan logo, icon, dan gambar utama tetap konsisten dengan kebutuhan campaign.",
            f"Pengunjung juga mendapatkan FAQ, review pengguna Indonesia, metadata SEO, Open Graph, schema, sitemap, dan robots.txt dalam satu proses generate yang diaudit sebelum disimpan.",
        ])
    return {
        "hero_heading": heading,
        "hero_subheading": subheading,
        "cta_label": cta_label,
        "article_body": article_body,
    }


def complete_project_content(project: dict[str, Any], refresh_ai: bool = True) -> dict[str, Any]:
    if bool(project.get("use_ai_content")):
        if refresh_ai or not project.get("ai_generated_at"):
            return apply_ai_content_to_project(project)
        return project
    generated = auto_content(project)
    updated = dict(project)
    changed = False
    for field, value in generated.items():
        if not str(updated.get(field) or "").strip():
            updated[field] = value
            changed = True
    if changed:
        now = utc_now()
        with db() as connection:
            connection.execute(
                """
                UPDATE projects
                SET hero_heading = ?,
                    hero_subheading = ?,
                    cta_label = ?,
                    article_body = ?,
                    updated_at = ?
                WHERE id = ? AND user_id = ?
                """,
                (
                    updated["hero_heading"],
                    updated["hero_subheading"],
                    updated["cta_label"],
                    updated["article_body"],
                    now,
                    updated["id"],
                    updated["user_id"],
                ),
            )
        refreshed = load_project(int(updated["id"]), int(updated["user_id"]))
        return refreshed or updated
    return updated


def generated_faqs(project: dict[str, Any]) -> list[dict[str, str]]:
    ai_payload = project.get("ai_content_json")
    ai_content = ai_payload.get("content") if isinstance(ai_payload, dict) else None
    ai_faqs = ai_content.get("faqs") if isinstance(ai_content, dict) else None
    if bool(project.get("use_ai_content")) and isinstance(ai_faqs, list) and len(ai_faqs) == 5:
        return [
            {
                "question": str(item.get("question") or ""),
                "answer": str(item.get("answer") or ""),
            }
            for item in ai_faqs
            if isinstance(item, dict)
        ]
    title = project.get("seo_title") or project.get("hostname") or "landing page ini"
    keyword = split_keywords(project)[0] if split_keywords(project) else title
    hostname = project.get("hostname") or title
    return [
        {
            "question": f"Apa keunggulan utama {title}?",
            "answer": f"Keunggulan utamanya adalah informasi disusun jelas, cepat dibaca, dan diarahkan untuk membantu pengunjung memahami {keyword} tanpa kebingungan.",
        },
        {
            "question": f"Apakah halaman {hostname} sudah siap SEO?",
            "answer": "Ya. Generator menambahkan title, meta description, keywords, canonical, Open Graph, Twitter Card, schema, sitemap.xml, dan robots.txt.",
        },
        {
            "question": "Apakah konten setiap domain dibuat berbeda?",
            "answer": "Ya. Batch generate memakai domain sebagai dasar variasi title, headline, artikel, FAQ, dan review agar hasilnya tidak kaku atau identik.",
        },
        {
            "question": "Apakah gambar dari Media Library ikut masuk output?",
            "answer": "Ya. Logo, icon, dan gambar utama yang dipilih akan dicopy ke folder output landing page dan digunakan di HTML hasil generate.",
        },
        {
            "question": "Apakah halaman diaudit sebelum disimpan?",
            "answer": "Ya. Jika opsi audit aktif, sistem mengecek metadata penting, FAQ, review, media, dan konten utama sebelum index.html ditulis.",
        },
    ]


def generated_reviews(project: dict[str, Any]) -> list[dict[str, str]]:
    ai_payload = project.get("ai_content_json")
    ai_content = ai_payload.get("content") if isinstance(ai_payload, dict) else None
    ai_reviews = ai_content.get("reviews") if isinstance(ai_content, dict) else None
    if bool(project.get("use_ai_content")) and isinstance(ai_reviews, list) and len(ai_reviews) == 5:
        return [
            {
                "name": str(item.get("name") or ""),
                "city": str(item.get("city") or ""),
                "rating": str(item.get("rating") or "5"),
                "body": str(item.get("body") or ""),
            }
            for item in ai_reviews
            if isinstance(item, dict)
        ]
    hostname = project.get("hostname") or "halaman ini"
    offset = sum(ord(char) for char in hostname) % len(INDONESIAN_PERSONAS)
    selected = [INDONESIAN_PERSONAS[(offset + index) % len(INDONESIAN_PERSONAS)] for index in range(5)]
    reviews = []
    for index, (name, city, body) in enumerate(selected, start=1):
        reviews.append({
            "name": name,
            "city": city,
            "rating": "5",
            "body": f"{body} Untuk {hostname}, kesannya terasa relevan dan tidak seperti template mentah.",
        })
    return reviews


def landing_required_errors(project: dict[str, Any], require_media: bool = True) -> list[str]:
    errors = [
        label
        for field, label in REQUIRED_LANDING_FIELDS.items()
        if not str(project.get(field) or "").strip()
    ]
    if require_media:
        user_id = safe_int(project.get("user_id"))
        for field, label in MEDIA_ROLES.items():
            media_id = safe_int(project.get(field))
            if not media_record(media_id, user_id):
                errors.append(label)
    if str(project.get("template_key") or "") == RANDOM_TEMPLATE_KEY and not discover_template89():
        errors.append("Folder TEMPLATE89 dengan index.html")
    return errors


def validate_generation(project: dict[str, Any], kind: str, require_media: bool = True) -> None:
    if kind not in {"landing", "all"}:
        return
    missing = landing_required_errors(project, require_media)
    if missing:
        raise ValueError("Lengkapi menu berikut sebelum Generate LP: " + ", ".join(missing))


def safe_reset_folder(folder: Path) -> None:
    resolved_folder = folder.resolve()
    resolved_generated = GENERATED_DIR.resolve()
    if resolved_folder == resolved_generated or resolved_generated not in resolved_folder.parents:
        raise ValueError("Folder output tidak valid.")
    if resolved_folder.exists():
        shutil.rmtree(resolved_folder)
    resolved_folder.mkdir(parents=True, exist_ok=True)


def project_media_assets(project: dict[str, Any]) -> dict[str, sqlite3.Row | None]:
    user_id = safe_int(project.get("user_id"))
    return {
        "logo": media_record(safe_int(project.get("logo_media_id")), user_id),
        "icon": media_record(safe_int(project.get("icon_media_id")), user_id),
        "main": media_record(safe_int(project.get("main_media_id")), user_id),
    }


def copy_project_media(project: dict[str, Any], folder: Path) -> dict[str, str]:
    media_folder = folder / "adminseo-media"
    media_folder.mkdir(parents=True, exist_ok=True)
    copied: dict[str, str] = {}
    for role, row in project_media_assets(project).items():
        if not row:
            continue
        source = Path(row["file_path"])
        suffix = source.suffix or ALLOWED_IMAGE_TYPES.get(row["content_type"], ".img")
        filename = f"{role}{suffix}"
        destination = media_folder / filename
        shutil.copy2(source, destination)
        copied[role] = f"adminseo-media/{quote(filename)}"
    return copied


def project_media_relative_paths(project: dict[str, Any], prefix: str = "adminseo-media/") -> dict[str, str]:
    paths: dict[str, str] = {}
    for role, row in project_media_assets(project).items():
        if not row:
            continue
        source = Path(row["file_path"])
        suffix = source.suffix or ALLOWED_IMAGE_TYPES.get(row["content_type"], ".img")
        paths[role] = f"{prefix}{quote(role + suffix)}"
    return paths


def normalize_url_or_empty(value: str) -> str:
    raw = value.strip()
    if not raw:
        return ""
    return raw if re.match(r"^https?://", raw, re.I) else f"https://{raw}"


def parse_alternate_links(value: str) -> list[tuple[str, str]]:
    links: list[tuple[str, str]] = []
    for line in str(value or "").splitlines():
        cleaned = line.strip()
        if not cleaned:
            continue
        if "|" in cleaned:
            lang, url = [part.strip() for part in cleaned.split("|", 1)]
        elif "," in cleaned:
            lang, url = [part.strip() for part in cleaned.split(",", 1)]
        else:
            parts = cleaned.split()
            if len(parts) < 2:
                continue
            lang, url = parts[0], parts[1]
        if not re.fullmatch(r"[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})?|x-default", lang):
            continue
        links.append((lang, normalize_url_or_empty(url)))
    return links[:20]


LEGACY_BRAND_IGNORE = {
    "column", "container", "facebook", "google", "hide", "instagram", "linkedin",
    "product", "review", "separator", "sha", "show", "tiktok", "twitter", "youtube",
}
HTML_VOID_TAGS = {
    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",
    "param", "source", "track", "wbr",
}
IMAGE_EXTENSIONS_PATTERN = r"(?:avif|gif|ico|jpe?g|png|svg|webp)(?:\?[^\s\"')]+)?"


def project_brand(project: dict[str, Any]) -> str:
    keywords = split_keywords(project)
    candidate = keywords[0] if keywords else str(project.get("seo_title") or project.get("hostname") or "Brand")
    candidate = re.sub(r"\s+", " ", candidate).strip(" |>-:")
    if len(candidate) > 40:
        candidate = candidate.split()[0]
    return candidate[:40] or "Brand"


def project_default_media_urls(project: dict[str, Any]) -> dict[str, str]:
    brand_slug = brand_asset_slug(project_brand(project))
    base = str(project.get("domain_url") or "").rstrip("/")
    return {
        "logo": f"{base}/img/logo-{brand_slug}.webp",
        "icon": f"{base}/img/icon.png",
        "main": f"{base}/img/gambar-{brand_slug}.jpg",
    }


def effective_media_paths(project: dict[str, Any], media_paths: dict[str, str] | None) -> dict[str, str]:
    defaults = project_default_media_urls(project)
    defaults.update({key: value for key, value in (media_paths or {}).items() if value})
    return defaults


def template_legacy_brands(content: str, current_brand: str) -> list[str]:
    candidates: dict[str, tuple[str, int, bool]] = {}
    current_key = re.sub(r"[^a-z0-9]", "", current_brand.lower())

    def remember(value: str, strong: bool = False) -> None:
        cleaned = html.unescape(re.sub(r"\s+", " ", value)).strip(" \t\r\n|>-:")
        key = re.sub(r"[^a-z0-9]", "", cleaned.lower())
        letters = re.sub(r"[^A-Za-z]", "", cleaned)
        if not key or key == current_key or not letters or len(cleaned) > 48:
            return
        if letters.lower() in LEGACY_BRAND_IGNORE:
            return
        previous = candidates.get(key)
        count = (previous[1] if previous else 0) + 1
        candidates[key] = (previous[0] if previous else cleaned, count, strong or (previous[2] if previous else False))

    for match in re.finditer(
        r"<meta\b[^>]*(?:property|name)=[\"'](?:og:site_name|application-name)[\"'][^>]*content=[\"']([^\"']+)[\"'][^>]*>",
        content,
        flags=re.I,
    ):
        remember(match.group(1), True)

    for match in re.finditer(r"\b[A-Za-z]{2,16}(?:[\s_-]?[0-9]{2,4})\b", content):
        token = match.group(0)
        letters = re.sub(r"[^A-Za-z]", "", token)
        remember(token, letters.isupper())

    return [value for value, _count, strong in candidates.values() if strong]


def replace_legacy_brands(content: str, legacy_brands: list[str], current_brand: str) -> str:
    cleaned = content
    for old_brand in sorted(legacy_brands, key=len, reverse=True):
        flexible = r"[\s_-]*".join(re.escape(part) for part in re.split(r"[\s_-]+", old_brand) if part)
        if flexible:
            cleaned = re.sub(flexible, current_brand, cleaned, flags=re.I)
    return cleaned


def media_role_from_hint(value: str) -> str:
    hint = value.lower()
    if "favicon" in hint or re.search(r"(?:^|[^a-z])icon(?:[^a-z]|$)", hint):
        return "icon"
    if "logo" in hint or "brand-mark" in hint or "brand_logo" in hint:
        return "logo"
    return "main"


def sanitize_css_images(value: str, media_paths: dict[str, str]) -> str:
    def repl(match: re.Match[str]) -> str:
        source = match.group(2).strip()
        if not re.search(rf"(?:data:image/|\.{IMAGE_EXTENSIONS_PATTERN}(?:[?#].*)?$)", source, flags=re.I):
            return match.group(0)
        role = media_role_from_hint(source)
        return f'url("{media_paths.get(role) or media_paths["main"]}")'

    return re.sub(r"url\(\s*([\"']?)(.*?)\1\s*\)", repl, value, flags=re.I | re.S)


def sanitize_css_identity_text(value: str, legacy_brands: list[str], current_brand: str) -> str:
    def repl(match: re.Match[str]) -> str:
        quote = match.group(1)
        text_value = replace_legacy_brands(match.group(2), legacy_brands, current_brand)
        return f"content: {quote}{text_value}{quote}"

    return re.sub(r"content\s*:\s*([\"'])(.*?)\1", repl, value, flags=re.I | re.S)


def sanitize_script_images(value: str, media_paths: dict[str, str]) -> str:
    pattern = rf"(?P<quote>[\"'])(?P<source>[^\"'\r\n]+\.{IMAGE_EXTENSIONS_PATTERN})(?P=quote)"

    def repl(match: re.Match[str]) -> str:
        source = match.group("source")
        role = media_role_from_hint(source)
        replacement = media_paths.get(role) or media_paths["main"]
        return f'{match.group("quote")}{replacement}{match.group("quote")}'

    return re.sub(pattern, repl, value, flags=re.I)


def template_content_features(content: str) -> dict[str, bool]:
    visible_markup = re.sub(r"<!--.*?-->", "", content, flags=re.S)
    visible_markup = re.sub(r"<(?:script|style)\b[^>]*>.*?</(?:script|style)>", "", visible_markup, flags=re.I | re.S)
    faq_pattern = r"(?:class|id|aria-label|data-testid)\s*=\s*[\"'][^\"']*(?:faq|question|pertanyaan)[^\"']*[\"']|<details\b"
    review_pattern = r"(?:class|id|aria-label|data-testid)\s*=\s*[\"'][^\"']*(?:review|testimonial|ulasan|rating)[^\"']*[\"']|<blockquote\b"
    return {
        "faq": bool(re.search(faq_pattern, visible_markup, flags=re.I)),
        "reviews": bool(re.search(review_pattern, visible_markup, flags=re.I)),
    }


def replace_template_brand_svgs(
    content: str,
    project: dict[str, Any],
    media_paths: dict[str, str],
    legacy_brands: list[str],
) -> str:
    brand = project_brand(project)
    has_uploaded_logo = bool(media_record(
        safe_int(project.get("logo_media_id")),
        safe_int(project.get("user_id")),
    ))

    def repl(match: re.Match[str]) -> str:
        svg = match.group(0)
        old_identity = any(re.search(re.escape(old_brand), svg, flags=re.I) for old_brand in legacy_brands)
        if not old_identity:
            return svg
        if has_uploaded_logo:
            return (
                f'<img class="adminseo-brand-logo" src="{html.escape(media_paths["logo"], quote=True)}" '
                f'alt="{html.escape(brand, quote=True)}">'
            )
        return f'<span class="adminseo-brand-text">{html.escape(brand)}</span>'

    return re.sub(r"<svg\b[^>]*>.*?</svg>", repl, content, flags=re.I | re.S)


def visible_document_text(content: str) -> str:
    body_match = re.search(r"<body\b[^>]*>(.*?)(?:</body>|$)", content, flags=re.I | re.S)
    visible = body_match.group(1) if body_match else content
    visible = re.sub(r"<!--.*?-->", " ", visible, flags=re.S)
    visible = re.sub(r"<(?:script|style)\b[^>]*>.*?</(?:script|style)>", " ", visible, flags=re.I | re.S)
    return html.unescape(re.sub(r"<[^>]+>", " ", visible))


def project_copy_catalog(project: dict[str, Any]) -> dict[str, list[str]]:
    brand = project_brand(project)
    hostname = str(project.get("hostname") or urlparse(str(project.get("domain_url") or "")).hostname or "website")
    title = str(project.get("seo_title") or hostname).strip()
    heading = str(project.get("hero_heading") or title).strip()
    description = str(project.get("meta_description") or project.get("hero_subheading") or title).strip()
    keywords = split_keywords(project)
    primary_keyword = keywords[0] if keywords else brand
    article_headings: list[str] = []
    article_paragraphs: list[str] = []
    for block in re.split(r"\n{2,}", str(project.get("article_body") or "")):
        lines = [line.strip() for line in block.splitlines() if line.strip()]
        if not lines:
            continue
        if len(lines) > 1 and len(lines[0]) <= 90:
            article_headings.append(lines[0])
            article_paragraphs.append(" ".join(lines[1:]))
        else:
            article_paragraphs.append(" ".join(lines))

    article_headings = article_headings or [
        f"Panduan {brand} untuk {hostname}",
        f"Pilihan dan Manfaat {primary_keyword}",
        f"Informasi Praktis untuk Pengunjung",
        f"Cara Menentukan Pilihan yang Tepat",
        f"Kesimpulan tentang {brand}",
    ]
    article_paragraphs = article_paragraphs or [description]
    faqs = generated_faqs(project)
    reviews = generated_reviews(project)
    return {
        "h1": [heading],
        "headings": article_headings,
        "paragraphs": [description, str(project.get("hero_subheading") or description)] + article_paragraphs,
        "bullets": [
            f"Informasi {primary_keyword} disusun khusus untuk {hostname}.",
            f"Identitas {brand} digunakan konsisten di seluruh halaman.",
            f"Tautan dan tindakan mengarah ke domain yang telah disiapkan.",
            "Konten dibuat berbeda untuk setiap hasil landing page.",
            "Struktur halaman telah dilengkapi metadata SEO dan audit.",
        ],
        "links": [
            str(project.get("cta_label") or f"Buka {brand}"),
            f"{brand} Login",
            f"{brand} Daftar",
            f"Tentang {brand}",
            "Panduan",
            "FAQ",
            "Review Pengguna",
        ],
        "short": [brand, f"{brand} Login", f"{brand} Daftar", primary_keyword, hostname, "Panduan", "Informasi", "Pilihan Terbaik"],
        "faqs": [item["question"] for item in faqs],
        "faq_answers": [item["answer"] for item in faqs],
        "reviews": [item["body"] for item in reviews],
        "review_names": [f'{item["name"]} - {item["city"]}' for item in reviews],
        "review_ratings": [f'{item["rating"]}/5 - Review Pengguna {brand}' for item in reviews],
        "labels": [f"Pilihan {brand}", f"Informasi {primary_keyword}", f"Layanan {hostname}"],
        "footer": [
            f"© {datetime.now().year} {brand}",
            "Kebijakan Privasi",
            "Syarat Penggunaan",
            f"Dukungan {brand}",
            f"Informasi {hostname}",
        ],
        "navigation": [brand, f"{brand} Login", f"{brand} Daftar", "Panduan", "FAQ", "Review"],
    }


class TemplateHTMLTransformer(HTMLParser):
    def __init__(
        self,
        project: dict[str, Any],
        media_paths: dict[str, str],
        legacy_brands: list[str] | None = None,
    ) -> None:
        super().__init__(convert_charrefs=False)
        self.project = project
        self.media_paths = media_paths
        self.legacy_brands = legacy_brands or []
        self.catalog = project_copy_catalog(project)
        self.brand = project_brand(project)
        self.title = str(project.get("seo_title") or project.get("hostname") or self.brand)
        self.domain_url = str(project.get("domain_url") or "").rstrip("/") + "/"
        self.cta_url = normalize_url_or_empty(str(project.get("cta_url") or "")) or self.domain_url
        self.amp_url = normalize_url_or_empty(str(project.get("amp_url") or ""))
        self.output: list[str] = []
        self.stack: list[dict[str, Any]] = []
        self.counts: dict[str, int] = {}

    def result(self) -> str:
        return "".join(self.output)

    def next_copy(self, group: str) -> str:
        items = self.catalog[group]
        index = self.counts.get(group, 0)
        self.counts[group] = index + 1
        return items[index % len(items)]

    def semantic_region(self, tag: str, attrs: list[tuple[str, str | None]]) -> tuple[str, str]:
        values = {name.lower(): value or "" for name, value in attrs}
        hint = " ".join([tag] + [values.get(key, "") for key in ("id", "class", "aria-label", "data-testid", "itemprop", "role")]).lower()
        parent_region = self.stack[-1]["region"] if self.stack else "content"
        footer_hint = " ".join([values.get("id", ""), values.get("class", "")]).lower()
        is_footer = (
            tag == "footer"
            or values.get("role", "").lower() == "contentinfo"
            or values.get("tag", "").lower() == "footer"
            or bool(re.search(r"(?:^|[\s_-])(?:footer|copyright)(?:[\s_-]|$)", footer_hint))
        )
        if is_footer or parent_region == "footer":
            return "footer", hint
        if re.search(r"(?:faq|question|pertanyaan)", hint) or tag == "details":
            return "faq", hint
        if re.search(r"(?:review|testimonial|ulasan|rating)", hint):
            return "reviews", hint
        if parent_region in {"faq", "reviews", "navigation"}:
            return parent_region, hint
        if tag in {"nav", "header"} or re.search(r"(?:navigation|navbar|menu)", hint):
            return "navigation", hint
        return "content", hint

    def visible_context(self) -> dict[str, Any] | None:
        structural = {"h1", "h2", "h3", "h4", "h5", "h6", "p", "li", "a", "button", "summary", "blockquote", "figcaption", "label", "option", "td", "th"}
        for frame in reversed(self.stack):
            if frame["tag"] in structural:
                return frame
        for frame in reversed(self.stack):
            if frame["tag"] in {"span", "strong", "b", "em", "small", "div"}:
                return frame
        return None

    def text_for_frame(self, frame: dict[str, Any], original_text: str = "") -> str:
        tag = frame["tag"]
        region = frame.get("region", "content")
        if "adminseo-brand" in frame.get("hint", ""):
            return self.brand
        if region == "footer":
            if tag in {"a", "button"}:
                return self.next_copy("links")
            return self.next_copy("footer")
        if tag in {"a", "button"}:
            if re.search(r"(?:daftar|register|sign\s*up)", original_text, flags=re.I):
                return f"Daftar {self.brand}"
            if re.search(r"(?:login|log\s*in|masuk)", original_text, flags=re.I):
                return f"Login {self.brand}"
        if region == "navigation":
            return self.next_copy("navigation")
        if region == "faq":
            if tag == "h2":
                return f"FAQ {self.brand}"
            if tag in {"h1", "h3", "h4", "h5", "h6", "summary", "a", "button"}:
                return self.next_copy("faqs")
            return self.next_copy("faq_answers")
        if region == "reviews":
            if tag in {"h1", "h2", "h3", "h4", "h5", "h6"}:
                return f"Review Pengguna {self.brand}"
            if tag in {"p", "blockquote", "li"}:
                if re.search(r"(?:\b20\d{2}\b|oleh|by\s|reviewer)", original_text, flags=re.I):
                    return self.next_copy("review_names")
                return self.next_copy("reviews")
            if re.search(r"(?:★|rating|\d(?:\.\d+)?\s*/\s*5)", original_text, flags=re.I):
                return self.next_copy("review_ratings")
            return self.next_copy("review_names")
        if tag == "h1":
            if len(re.sub(r"\s+", " ", original_text).strip()) <= 48:
                hostname = str(self.project.get("hostname") or "")
                return f"{self.brand} | {domain_title(hostname)}"
            return self.catalog["h1"][0]
        if tag in {"h2", "h3", "h4", "h5", "h6"}:
            return self.next_copy("headings")
        if tag == "p":
            return self.next_copy("paragraphs")
        if tag == "li":
            return self.next_copy("bullets")
        if tag in {"a", "button"}:
            return self.next_copy("links")
        if tag == "summary":
            return self.next_copy("faqs")
        if tag == "blockquote":
            return self.next_copy("reviews")
        if tag in {"label", "figcaption", "option", "td", "th"}:
            return self.next_copy("labels")
        return self.next_copy("short")

    def transform_attrs(self, tag: str, attrs: list[tuple[str, str | None]]) -> list[tuple[str, str | None]]:
        values = {name.lower(): value or "" for name, value in attrs}
        hint = " ".join([tag] + [values.get(key, "") for key in ("id", "class", "src", "alt", "title", "data-image")])
        role = media_role_from_hint(hint)
        transformed: list[tuple[str, str | None]] = []
        for name, value in attrs:
            lower_name = name.lower()
            current = value
            if current is None:
                transformed.append((name, value))
                continue

            if lower_name == "style":
                current = sanitize_css_images(current, self.media_paths)
            elif tag in {"img", "amp-img", "source"} and lower_name in {"src", "data-src", "data-lazy-src", "data-original", "srcset"}:
                image_url = self.media_paths.get(role) or self.media_paths["main"]
                current = image_url if lower_name != "srcset" else f"{image_url} 1x"
            elif lower_name in {"data-image", "data-background-image", "data-bg", "poster", "background"}:
                current = self.media_paths.get(role) or self.media_paths["main"]
            elif lower_name.startswith("data-") and re.search(r"https?(?::|%3a)(?:\\?/|%2f){2}", current, flags=re.I):
                if re.fullmatch(rf"https?://.+\.{IMAGE_EXTENSIONS_PATTERN}", current, flags=re.I):
                    current = self.media_paths.get(role) or self.media_paths["main"]
                else:
                    current = re.sub(
                        r"https?(?::|%3a)(?:\\?/|%2f){2}[^\"'\s<},&]+",
                        self.cta_url,
                        current,
                        flags=re.I,
                    )
            elif tag == "a" and lower_name == "href":
                current = current if current.startswith("#") else self.cta_url
            elif tag == "form" and lower_name == "action":
                current = self.cta_url
            elif tag == "base" and lower_name == "href":
                current = self.domain_url
            elif tag == "iframe" and lower_name == "src":
                current = "about:blank"
            elif tag == "link" and lower_name == "href":
                rel = values.get("rel", "").lower()
                if "canonical" in rel:
                    current = self.domain_url
                elif "amphtml" in rel and self.amp_url:
                    current = self.amp_url
                elif "icon" in rel:
                    current = self.media_paths["icon"]
            elif lower_name == "href":
                if re.search(rf"\.{IMAGE_EXTENSIONS_PATTERN}$", current, flags=re.I):
                    current = self.media_paths.get(role) or self.media_paths["main"]
                else:
                    current = self.cta_url
            elif tag == "meta" and lower_name == "content":
                meta_key = (values.get("name") or values.get("property") or values.get("itemprop") or "").lower()
                if "description" in meta_key:
                    current = str(self.project.get("meta_description") or self.project.get("hero_subheading") or self.title)
                elif "title" in meta_key:
                    current = self.title
                elif "site_name" in meta_key or "application-name" in meta_key:
                    current = self.brand
                elif "image" in meta_key:
                    current = self.media_paths["main"]
                elif meta_key.endswith("url") or "domain" in meta_key:
                    current = self.domain_url
            elif lower_name == "alt":
                current = f"{self.brand} - {self.title}"
            elif lower_name in {"aria-label", "title"}:
                current = f"{self.brand} - {self.next_copy('labels')}"
            elif lower_name == "placeholder":
                current = f"Masukkan informasi {self.brand}"
            elif lower_name == "value" and tag in {"button", "option"}:
                current = self.next_copy("labels")

            if lower_name.startswith("data-") and self.legacy_brands:
                current = replace_legacy_brands(current, self.legacy_brands, self.brand)

            transformed.append((name, current))
        if tag in {"img", "amp-img"} and not any(name.lower() == "src" for name, _value in transformed):
            transformed.append(("src", self.media_paths.get(role) or self.media_paths["main"]))
        return transformed

    def render_start(self, tag: str, attrs: list[tuple[str, str | None]], closed: bool = False) -> None:
        rendered_attrs = "".join(
            f" {name}" if value is None else f' {name}="{html.escape(value, quote=True)}"'
            for name, value in attrs
        )
        suffix = " />" if closed else ">"
        self.output.append(f"<{tag}{rendered_attrs}{suffix}")

    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        lower_tag = tag.lower()
        region, hint = self.semantic_region(lower_tag, attrs)
        transformed = self.transform_attrs(lower_tag, attrs)
        self.render_start(tag, transformed)
        if lower_tag not in HTML_VOID_TAGS:
            self.stack.append({"tag": lower_tag, "emitted": False, "region": region, "hint": hint})

    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        self.render_start(tag, self.transform_attrs(tag.lower(), attrs), True)

    def handle_endtag(self, tag: str) -> None:
        self.output.append(f"</{tag}>")
        lower_tag = tag.lower()
        for index in range(len(self.stack) - 1, -1, -1):
            if self.stack[index]["tag"] == lower_tag:
                del self.stack[index:]
                break

    def handle_data(self, data: str) -> None:
        tags = {frame["tag"] for frame in self.stack}
        if "style" in tags:
            self.output.append(sanitize_css_images(data, self.media_paths))
            return
        if "script" in tags:
            self.output.append(sanitize_script_images(data, self.media_paths))
            return
        if "head" in tags or not re.search(r"[A-Za-z0-9]", html.unescape(data)):
            self.output.append(data)
            return
        frame = self.visible_context()
        if not frame:
            self.output.append(data)
            return
        if frame["emitted"]:
            return
        frame["emitted"] = True
        leading = re.match(r"^\s*", data).group(0)
        trailing = re.search(r"\s*$", data).group(0)
        self.output.append(leading + html.escape(self.text_for_frame(frame, html.unescape(data))) + trailing)

    def handle_entityref(self, name: str) -> None:
        self.output.append(f"&{name};")

    def handle_charref(self, name: str) -> None:
        self.output.append(f"&#{name};")

    def handle_comment(self, data: str) -> None:
        return

    def handle_decl(self, decl: str) -> None:
        self.output.append(f"<!{decl}>")

    def handle_pi(self, data: str) -> None:
        self.output.append(f"<?{data}>")

    def unknown_decl(self, data: str) -> None:
        self.output.append(f"<![{data}]>")


def transform_template_html(
    content: str,
    project: dict[str, Any],
    media_paths: dict[str, str],
    legacy_brands: list[str] | None = None,
) -> str:
    transformer = TemplateHTMLTransformer(project, media_paths, legacy_brands)
    try:
        transformer.feed(content)
        transformer.close()
        return transformer.result()
    except (AssertionError, ValueError) as exc:
        raise ValueError("Struktur template tidak dapat dibersihkan dengan aman.") from exc


def seo_head(project: dict[str, Any], selected_template: str | None, media_paths: dict[str, str] | None = None) -> str:
    media_paths = media_paths or {}
    title = html.escape(project["seo_title"] or project["hostname"], quote=True)
    description = html.escape(project["meta_description"] or project["hero_subheading"], quote=True)
    keywords = html.escape(project["keywords"] or "", quote=True)
    domain_url = html.escape(project["domain_url"], quote=True)
    heading = html.escape(project["hero_heading"] or project["seo_title"], quote=True)
    template_name = "AdminSEO"
    icon_href = html.escape(media_paths.get("icon") or "", quote=True)
    logo_href = html.escape(media_paths.get("logo") or "", quote=True)
    image_href = html.escape(media_paths.get("main") or "", quote=True)
    amp_url = normalize_url_or_empty(str(project.get("amp_url") or ""))
    amp_markup = f'<link rel="amphtml" href="{html.escape(amp_url, quote=True)}">' if amp_url else ""
    alternate_markup = "\n".join(
        f'    <link rel="alternate" hreflang="{html.escape(lang, quote=True)}" href="{html.escape(url, quote=True)}">'
        for lang, url in parse_alternate_links(str(project.get("alternate_links") or ""))
    )
    schema = {
        "@context": "https://schema.org",
        "@type": "WebPage",
        "name": project["seo_title"] or project["hostname"],
        "description": project["meta_description"] or project["hero_subheading"],
        "url": f"{project['domain_url']}/",
        "headline": project["hero_heading"] or project["seo_title"],
        "image": media_paths.get("main") or "",
        "inLanguage": "id-ID",
    }
    schema_json = html.escape(json.dumps(schema, ensure_ascii=False), quote=False)
    icon_markup = f'<link rel="icon" href="{icon_href}">' if icon_href else ""
    apple_icon_markup = f'<link rel="apple-touch-icon" href="{icon_href}">' if icon_href else ""
    og_image_markup = f'<meta property="og:image" content="{image_href}"><meta name="twitter:image" content="{image_href}">' if image_href else ""
    return f"""
    <title>{title}</title>
    <meta name="description" content="{description}">
    <meta name="keywords" content="{keywords}">
    <meta name="robots" content="index, follow">
    <meta name="generator" content="AdminSEO TEMPLATE89">
    <meta name="adminseo-template" content="{template_name}">
    {icon_markup}
    {apple_icon_markup}
    {amp_markup}
{alternate_markup}
    <link rel="canonical" href="{domain_url}/">
    <meta property="og:type" content="website">
    <meta property="og:url" content="{domain_url}/">
    <meta property="og:title" content="{title}">
    <meta property="og:description" content="{description}">
    <meta name="twitter:card" content="summary_large_image">
    <meta name="twitter:title" content="{title}">
    <meta name="twitter:description" content="{description}">
    {og_image_markup}
    <script type="application/ld+json">{schema_json}</script>
    <script id="adminseo-runtime">
      window.ADMINSEO_LP = {{
        title: "{title}",
        headline: "{heading}",
        description: "{description}",
        ctaLabel: "{html.escape(project["cta_label"], quote=True)}",
        ctaUrl: "{html.escape(project["cta_url"], quote=True)}",
        logo: "{logo_href}",
        icon: "{icon_href}",
        mainImage: "{image_href}",
        template: "{template_name}"
      }};
    </script>
"""


def remove_old_head_seo(head: str) -> str:
    patterns = [
        r"<title\b[^>]*>.*?</title>",
        r"<meta\b[^>]*(?:name|property)=[\"'](?:description|keywords|robots|generator|adminseo-template|og:[^\"']+|twitter:[^\"']+)[\"'][^>]*>",
        r"<link\b[^>]*rel=[\"'](?:canonical|amphtml|alternate|icon|shortcut icon|apple-touch-icon|manifest|search)[\"'][^>]*>",
        r"<link\b(?=[^>]*\bas=[\"']image[\"'])[^>]*>",
        r"<script\b[^>]*type=[\"']application/ld\+json[\"'][^>]*>.*?</script>",
        r"<script\b[^>]*id=[\"']adminseo-runtime[\"'][^>]*>.*?</script>",
    ]
    cleaned = head
    for pattern in patterns:
        cleaned = re.sub(pattern, "", cleaned, flags=re.I | re.S)
    cleaned = re.sub(
        r"<link\b(?=[^>]*\brel\s*=\s*(?:[\"']?)(?:canonical|amphtml|alternate|icon|shortcut\s+icon|apple-touch-icon)\b)[^>]*>",
        "",
        cleaned,
        flags=re.I | re.S,
    )
    cleaned = re.sub(
        r"<meta\b(?![^>]*(?:charset\s*=|name\s*=\s*[\"']viewport[\"']))[^>]*>",
        "",
        cleaned,
        flags=re.I | re.S,
    )
    return cleaned


def amp_seo_head(project: dict[str, Any], selected_template: str, media_paths: dict[str, str]) -> str:
    title_text = str(project.get("seo_title") or project.get("hostname") or "Landing Page")
    description_text = str(project.get("meta_description") or project.get("hero_subheading") or title_text)
    domain_url = str(project.get("domain_url") or "").rstrip("/") + "/"
    title = html.escape(title_text)
    description = html.escape(description_text, quote=True)
    canonical = html.escape(domain_url, quote=True)
    icon = html.escape(media_paths.get("icon") or "", quote=True)
    main_image = html.escape(media_paths.get("main") or "", quote=True)
    icon_markup = f'<link rel="icon" href="{icon}">' if icon else ""
    image_markup = f'<meta property="og:image" content="{main_image}">' if main_image else ""
    return f"""  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">
  <title>{title}</title>
  <meta name="description" content="{description}">
  <meta name="robots" content="index,follow">
  <meta name="generator" content="AdminSEO AMP Generator">
  {icon_markup}
  <link rel="canonical" href="{canonical}">
  <meta property="og:type" content="website">
  <meta property="og:url" content="{canonical}">
  <meta property="og:title" content="{title}">
  <meta property="og:description" content="{description}">
  {image_markup}
"""


def replace_amp_head(
    content: str,
    project: dict[str, Any],
    selected_template: str,
    media_paths: dict[str, str],
) -> str:
    head_open = re.search(r"<head\b[^>]*>", content, flags=re.I)
    head_close = re.search(r"</head>", content, flags=re.I)
    body_open = re.search(r"<body\b[^>]*>", content, flags=re.I)
    boundary = head_close or body_open
    if not head_open or not boundary or head_open.end() > boundary.start():
        raise ValueError("Template AMP tidak memiliki struktur head yang valid.")
    original_head = content[head_open.end():boundary.start()]
    cleaned_head = remove_old_head_seo(original_head)
    cleaned_head = re.sub(r"<meta\b[^>]*charset\s*=\s*[^>]+>", "", cleaned_head, flags=re.I)
    cleaned_head = re.sub(
        r"<meta\b[^>]*name\s*=\s*[\"']viewport[\"'][^>]*>",
        "",
        cleaned_head,
        flags=re.I,
    )
    closing_head = "" if head_close else "</head>\n"
    return (
        content[:head_open.end()]
        + "\n"
        + amp_seo_head(project, selected_template, media_paths)
        + cleaned_head
        + closing_head
        + content[boundary.start():]
    )


def remove_non_amp_scripts(content: str) -> str:
    def repl(match: re.Match[str]) -> str:
        attributes = match.group(1)
        script_type = html_attribute(f"<script {attributes}>", "type").lower()
        if script_type == "application/ld+json":
            return match.group(0)
        source = html_attribute(f"<script {attributes}>", "src")
        parsed = urlparse(source)
        if parsed.hostname == "cdn.ampproject.org" and parsed.path.startswith("/v0"):
            return match.group(0)
        return ""

    return re.sub(r"<script\b([^>]*)>.*?</script>", repl, content, flags=re.I | re.S)


def replace_amp_brand_svgs(
    content: str,
    project: dict[str, Any],
    media_paths: dict[str, str],
    legacy_brands: list[str],
) -> str:
    brand = project_brand(project)

    def repl(match: re.Match[str]) -> str:
        svg = match.group(0)
        if not any(re.search(re.escape(old_brand), svg, flags=re.I) for old_brand in legacy_brands):
            return svg
        return (
            f'<amp-img class="adminseo-brand-logo" src="{html.escape(media_paths["logo"], quote=True)}" '
            f'alt="Logo {html.escape(brand, quote=True)}" width="180" height="60" layout="intrinsic"></amp-img>'
        )

    return re.sub(r"<svg\b[^>]*>.*?</svg>", repl, content, flags=re.I | re.S)


SAFE_TEMPLATE_SCRIPT_HOSTS = {
    "ajax.googleapis.com",
    "cdn.ampproject.org",
    "cdn.jsdelivr.net",
    "cdnjs.cloudflare.com",
    "code.jquery.com",
    "unpkg.com",
}


def remove_template_inline_scripts(content: str, project: dict[str, Any]) -> str:
    target_host = urlparse(str(project.get("domain_url") or "")).hostname

    def repl(match: re.Match[str]) -> str:
        attributes = match.group(1)
        if re.search(r"\bid\s*=\s*[\"']adminseo-runtime[\"']", attributes, flags=re.I):
            return match.group(0)
        source_match = re.search(r"\bsrc\s*=\s*[\"']([^\"']+)[\"']", attributes, flags=re.I)
        if source_match:
            source = html.unescape(source_match.group(1))
            parsed = urlparse(source)
            if parsed.hostname == target_host or parsed.hostname in SAFE_TEMPLATE_SCRIPT_HOSTS:
                return match.group(0)
        return ""

    return re.sub(r"<script\b([^>]*)>.*?</script>", repl, content, flags=re.I | re.S)


def replace_first_tag_text(content: str, tag_name: str, replacement: str) -> str:
    if not replacement:
        return content
    escaped = html.escape(replacement)
    pattern = rf"(<{tag_name}\b[^>]*>)(.*?)(</{tag_name}>)"
    return re.sub(
        pattern,
        lambda match: f"{match.group(1)}{escaped}{match.group(3)}",
        content,
        count=1,
        flags=re.I | re.S,
    )


def replace_first_cta(content: str, label: str, url: str) -> str:
    if not label or not url:
        return content
    escaped_label = html.escape(label)
    escaped_url = html.escape(url, quote=True)
    pattern = r"(<a\b[^>]*href=[\"'])[^\"']*([\"'][^>]*>)(.*?)(</a>)"
    return re.sub(
        pattern,
        lambda match: f"{match.group(1)}{escaped_url}{match.group(2)}{escaped_label}{match.group(4)}",
        content,
        count=1,
        flags=re.I | re.S,
    )


def replace_first_image(content: str, image_url: str, alt_text: str) -> str:
    if not image_url:
        return content
    escaped_url = html.escape(image_url, quote=True)
    escaped_alt = html.escape(alt_text, quote=True)

    def repl(match: re.Match[str]) -> str:
        tag = match.group(0)
        if re.search(r"\bsrc=[\"']", tag, flags=re.I):
            tag = re.sub(r"\bsrc=[\"'][^\"']*[\"']", f'src="{escaped_url}"', tag, count=1, flags=re.I)
        else:
            ending = "/>" if tag.rstrip().endswith("/>") else ">"
            tag = tag.rstrip()
            tag = tag[:-2].rstrip() if ending == "/>" else tag[:-1].rstrip()
            tag = f'{tag} src="{escaped_url}"{ending}'
        if re.search(r"\balt=[\"']", tag, flags=re.I):
            tag = re.sub(r"\balt=[\"'][^\"']*[\"']", f'alt="{escaped_alt}"', tag, count=1, flags=re.I)
        else:
            ending = "/>" if tag.rstrip().endswith("/>") else ">"
            tag = tag.rstrip()
            tag = tag[:-2].rstrip() if ending == "/>" else tag[:-1].rstrip()
            tag = f'{tag} alt="{escaped_alt}"{ending}'
        return tag

    return re.sub(r"<(?:amp-img|img)\b[^>]*>", repl, content, count=1, flags=re.I | re.S)


def inject_faq_review_blocks(
    content: str,
    project: dict[str, Any],
    existing_features: dict[str, bool] | None = None,
) -> str:
    existing_features = existing_features or template_content_features(content)
    blocks: list[str] = []
    if int(project.get("generate_faq") or 0) and not existing_features.get("faq"):
        faqs = generated_faqs(project)
        faq_items = "\n".join(
            f"""
      <details class="adminseo-faq-item" open>
        <summary>{html.escape(item["question"])}</summary>
        <p>{html.escape(item["answer"])}</p>
      </details>"""
            for item in faqs
        )
        blocks.append(f"""
  <section class="adminseo-faq" aria-label="FAQ">
    <div class="adminseo-trust-wrap">
      <h2>FAQ</h2>
{faq_items}
    </div>
  </section>""")

    if int(project.get("generate_reviews") or 0) and not existing_features.get("reviews"):
        reviews = generated_reviews(project)
        review_items = "\n".join(
            f"""
      <article class="adminseo-review-card">
        <strong>{html.escape(item["name"])} - {html.escape(item["city"])}</strong>
        <span>{html.escape(item["rating"])}/5</span>
        <p>{html.escape(item["body"])}</p>
      </article>"""
            for item in reviews
        )
        blocks.append(f"""
  <section class="adminseo-reviews" aria-label="Review Pengguna">
    <div class="adminseo-trust-wrap">
      <h2>Review Pengguna Indonesia</h2>
      <div class="adminseo-review-grid">
{review_items}
      </div>
    </div>
  </section>""")

    if not blocks:
        return content

    style = """
  <style id="adminseo-trust-style">
    .adminseo-faq, .adminseo-reviews { padding: 52px 18px; background: #f8fafc; color: #172033; }
    .adminseo-reviews { background: #ffffff; }
    .adminseo-trust-wrap { width: min(980px, 100%); margin: 0 auto; }
    .adminseo-trust-wrap h2 { margin: 0 0 22px; font-size: clamp(28px, 4vw, 44px); letter-spacing: 0; }
    .adminseo-faq-item { border: 1px solid #d8e1eb; border-radius: 8px; padding: 16px; margin-bottom: 10px; background: #fff; }
    .adminseo-faq-item summary { cursor: pointer; font-weight: 800; }
    .adminseo-faq-item p, .adminseo-review-card p { color: #455569; line-height: 1.7; }
    .adminseo-review-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 14px; }
    .adminseo-review-card { border: 1px solid #d8e1eb; border-radius: 8px; padding: 16px; background: #fff; }
    .adminseo-review-card strong, .adminseo-review-card span { display: block; }
    .adminseo-review-card span { color: #0f766e; margin-top: 4px; font-weight: 800; }
  </style>
"""
    block = "\n".join(blocks) + style
    footer_position = find_footer_start(content)
    if footer_position is not None:
        return content[:footer_position] + block + "\n" + content[footer_position:]
    if re.search(r"</body>", content, flags=re.I):
        return re.sub(r"</body>", block + "\n</body>", content, count=1, flags=re.I)
    return content + block


def inject_amp_faq_review_blocks(
    content: str,
    project: dict[str, Any],
    existing_features: dict[str, bool],
) -> str:
    updated = inject_faq_review_blocks(content, project, existing_features)
    style_match = re.search(
        r"\s*<style\b[^>]*id=[\"']adminseo-trust-style[\"'][^>]*>(.*?)</style>",
        updated,
        flags=re.I | re.S,
    )
    if not style_match:
        return updated
    trust_css = style_match.group(1).strip()
    updated = updated[:style_match.start()] + updated[style_match.end():]
    amp_style = re.search(r"(<style\b[^>]*amp-custom[^>]*>)(.*?)(</style>)", updated, flags=re.I | re.S)
    if not amp_style:
        raise ValueError("Template AMP tidak memiliki style amp-custom.")
    merged = amp_style.group(1) + amp_style.group(2) + "\n" + trust_css + "\n" + amp_style.group(3)
    return updated[:amp_style.start()] + merged + updated[amp_style.end():]


def inject_amp_project_content(
    content: str,
    project: dict[str, Any],
    selected_template: str,
    media_paths: dict[str, str] | None = None,
    legacy_brands: list[str] | None = None,
) -> str:
    final_media_paths = effective_media_paths(project, media_paths)
    current_brand = project_brand(project)
    source_brands = legacy_brands if legacy_brands is not None else template_legacy_brands(content, current_brand)
    content = replace_amp_brand_svgs(content, project, final_media_paths, source_brands)
    content = replace_amp_head(content, project, selected_template, final_media_paths)
    content = remove_non_amp_scripts(content)
    content = transform_template_html(content, project, final_media_paths, source_brands)
    return content


def html_attribute(tag: str, name: str) -> str:
    match = re.search(rf"(?<![\w:-]){re.escape(name)}\s*=\s*[\"']([^\"']*)[\"']", tag, flags=re.I)
    if not match:
        match = re.search(rf"(?<![\w:-]){re.escape(name)}\s*=\s*([^\s>]+)", tag, flags=re.I)
    return html.unescape(match.group(1)).strip() if match else ""


def find_footer_start(content: str) -> int | None:
    footer_positions: list[int] = []
    for match in re.finditer(r"<[A-Za-z][^>]*>", content, flags=re.S):
        tag_markup = match.group(0)
        tag_match = re.match(r"<\s*([A-Za-z0-9:-]+)", tag_markup)
        tag_name = tag_match.group(1).lower() if tag_match else ""
        role = html_attribute(tag_markup, "role").lower()
        semantic_tag = html_attribute(tag_markup, "tag").lower()
        footer_hint = f'{html_attribute(tag_markup, "id")} {html_attribute(tag_markup, "class")}'.lower()
        if (
            tag_name == "footer"
            or role == "contentinfo"
            or semantic_tag == "footer"
            or re.search(r"(?:^|[\s_-])footer(?:[\s_-]|$)", footer_hint)
        ):
            footer_positions.append(match.start())
    return min(footer_positions) if footer_positions else None


def audit_landing_content(
    content: str,
    project: dict[str, Any],
    require_media: bool = True,
    legacy_brands: list[str] | None = None,
    media_paths: dict[str, str] | None = None,
) -> list[str]:
    issues: list[str] = []
    auditable_content = re.sub(r"<!--.*?-->", "", content, flags=re.S)
    auditable_content = re.sub(r"<(?:script|style)\b[^>]*>.*?</(?:script|style)>", "", auditable_content, flags=re.I | re.S)
    checks = {
        "title": r"<title\b[^>]*>.+?</title>",
        "meta description": r"<meta\b[^>]*name=[\"']description[\"'][^>]*>",
        "canonical": r"<link\b[^>]*rel=[\"']canonical[\"'][^>]*>",
        "Open Graph title": r"<meta\b[^>]*property=[\"']og:title[\"'][^>]*>",
    }
    if require_media:
        checks["main image"] = r"adminseo-media/"
    for label, pattern in checks.items():
        if not re.search(pattern, content, flags=re.I | re.S):
            issues.append(label)
    content_features = template_content_features(content)
    if int(project.get("generate_faq") or 0) and not content_features["faq"]:
        issues.append("5 FAQ")
    if int(project.get("generate_reviews") or 0) and not content_features["reviews"]:
        issues.append("5 review")
    if re.search(r"adminseo-article", content, flags=re.I):
        issues.append("artikel tambahan di luar template")

    footer_position = find_footer_start(content)
    if footer_position is not None:
        for section_name in ("adminseo-faq", "adminseo-reviews"):
            section_match = re.search(rf'class=["\'][^"\']*\b{section_name}\b', content, flags=re.I)
            if section_match and section_match.start() > footer_position:
                issues.append("konten setelah footer")
                break
    if project.get("amp_url") and not re.search(r"rel=[\"']amphtml[\"']", content, flags=re.I):
        issues.append("AMP URL")
    if project.get("alternate_links") and not re.search(r"rel=[\"']alternate[\"']", content, flags=re.I):
        issues.append("alternate hreflang")

    canonical_tags = [
        tag for tag in re.findall(r"<link\b[^>]*>", auditable_content, flags=re.I)
        if "canonical" in html_attribute(tag, "rel").lower().split()
    ]
    expected_canonical = str(project.get("domain_url") or "").rstrip("/") + "/"
    if len(canonical_tags) != 1 or html_attribute(canonical_tags[0], "href").rstrip("/") + "/" != expected_canonical:
        issues.append("canonical domain")

    allowed_anchor_hosts = {
        urlparse(normalize_url_or_empty(str(project.get(key) or ""))).hostname
        for key in ("domain_url", "cta_url")
        if str(project.get(key) or "").strip()
    }
    foreign_anchor = False
    for tag in re.findall(r"<a\b[^>]*>", auditable_content, flags=re.I):
        href = html_attribute(tag, "href")
        if not href or href.startswith("#"):
            continue
        parsed = urlparse(normalize_url_or_empty(href))
        if parsed.hostname and parsed.hostname not in allowed_anchor_hosts:
            foreign_anchor = True
            break
    if foreign_anchor:
        issues.append("anchor domain")

    final_media_paths = effective_media_paths(project, media_paths)
    allowed_images = {html.unescape(value) for value in final_media_paths.values() if value}
    image_tags = re.findall(r"<(?:img|amp-img)\b[^>]*>", auditable_content, flags=re.I)
    if image_tags and any(html_attribute(tag, "src") not in allowed_images for tag in image_tags):
        issues.append("gambar template lama")

    visible_identity = visible_document_text(content)
    visible_identity += " " + " ".join(
        html_attribute(tag, attribute)
        for tag in re.findall(r"<[^>]+>", auditable_content, flags=re.S)
        for attribute in ("alt", "title", "aria-label")
    )
    for old_brand in legacy_brands or []:
        if re.search(re.escape(old_brand), visible_identity, flags=re.I):
            issues.append(f"brand lama {old_brand}")
            break
    return issues


def inject_project_content(
    content: str,
    project: dict[str, Any],
    selected_template: str | None,
    media_paths: dict[str, str] | None = None,
    legacy_brands: list[str] | None = None,
) -> str:
    media_paths = effective_media_paths(project, media_paths)
    current_brand = project_brand(project)
    legacy_brands = legacy_brands if legacy_brands is not None else template_legacy_brands(content, current_brand)
    existing_features = template_content_features(content)
    content = replace_template_brand_svgs(content, project, media_paths, legacy_brands)
    head_match = re.search(r"<head\b[^>]*>", content, flags=re.I)
    close_head_match = re.search(r"</head>", content, flags=re.I)
    if head_match and close_head_match and head_match.end() <= close_head_match.start():
        head_open = content[:head_match.end()]
        head_body = content[head_match.end():close_head_match.start()]
        after_head = content[close_head_match.start():]
        content = head_open + seo_head(project, selected_template, media_paths) + remove_old_head_seo(head_body) + after_head
    elif head_match:
        body_match = re.search(r"<body\b[^>]*>", content[head_match.end():], flags=re.I)
        if body_match:
            body_start = head_match.end() + body_match.start()
            head_open = content[:head_match.end()]
            head_body = content[head_match.end():body_start]
            content = (
                head_open
                + seo_head(project, selected_template, media_paths)
                + remove_old_head_seo(head_body)
                + "\n</head>\n"
                + content[body_start:]
            )
        else:
            content = content[:head_match.end()] + seo_head(project, selected_template, media_paths) + remove_old_head_seo(content[head_match.end():])
    else:
        content = seo_head(project, selected_template, media_paths) + content

    content = remove_template_inline_scripts(content, project)
    content = transform_template_html(content, project, media_paths, legacy_brands)
    content = inject_faq_review_blocks(content, project, existing_features)
    return content


def media_paths_relative_to_file(project: dict[str, Any], media_root: Path, file_path: Path) -> dict[str, str]:
    paths = project_default_media_urls(project)
    media_folder = media_root / "adminseo-media"
    if not media_folder.is_dir():
        return paths
    for role in ("logo", "icon", "main"):
        matches = list(media_folder.glob(f"{role}.*"))
        if matches:
            paths[role] = os.path.relpath(matches[0], file_path.parent).replace("\\", "/")
    return paths


def sanitize_copied_template_assets(
    template_folder: Path,
    media_root: Path,
    project: dict[str, Any],
    legacy_brands: list[str],
) -> None:
    media_folder = (media_root / "adminseo-media").resolve()
    image_suffixes = {f".{extension}" for extension in ("avif", "gif", "ico", "jpeg", "jpg", "png", "svg", "webp")}
    for file_path in list(template_folder.rglob("*")):
        if not file_path.is_file():
            continue
        resolved = file_path.resolve()
        if media_folder == resolved.parent or media_folder in resolved.parents:
            continue
        suffix = file_path.suffix.lower()
        if suffix in image_suffixes:
            file_path.unlink()
            continue
        if suffix in {".html", ".htm"} and file_path.name.lower() != "index.html":
            file_path.unlink()
            continue
        if suffix in {".js", ".json", ".txt", ".xml"}:
            file_path.unlink()
            continue
        if suffix not in {".css", ".js", ".json", ".txt", ".xml"}:
            continue
        try:
            asset_content = file_path.read_text(encoding="utf-8", errors="ignore")
        except OSError:
            continue
        asset_media = media_paths_relative_to_file(project, media_root, file_path)
        if suffix == ".css":
            asset_content = sanitize_css_identity_text(asset_content, legacy_brands, project_brand(project))
            asset_content = sanitize_css_images(asset_content, asset_media)
        file_path.write_text(asset_content, encoding="utf-8")


def build_landing_from_template(project: dict[str, Any], folder: Path, require_media: bool = True) -> str | None:
    selected_key, template_path = selected_template_path(str(project.get("template_key") or RANDOM_TEMPLATE_KEY))
    if not template_path or not template_path.is_dir():
        folder.mkdir(parents=True, exist_ok=True)
        (folder / "index.html").write_text(html_page(project), encoding="utf-8")
        return None

    safe_reset_folder(folder)
    shutil.copytree(template_path, folder, dirs_exist_ok=True)
    media_paths = copy_project_media(project, folder)
    index_path = folder / "index.html"
    content = index_path.read_text(encoding="utf-8", errors="ignore")
    legacy_brands = template_legacy_brands(content, project_brand(project))
    final_content = inject_project_content(content, project, selected_key, media_paths, legacy_brands)
    if int(project.get("audit_before_save") or 0):
        issues = audit_landing_content(final_content, project, require_media, legacy_brands, media_paths)
        if issues:
            raise ValueError("Audit gagal sebelum menyimpan: " + ", ".join(issues))
    index_path.write_text(final_content, encoding="utf-8")
    sanitize_copied_template_assets(folder, folder, project, legacy_brands)
    return selected_key


def build_amp_from_template(project: dict[str, Any], amp_folder: Path) -> str | None:
    selected_key, template_path = selected_amp_template_path(str(project.get("amp_template_key") or RANDOM_AMP_TEMPLATE_KEY))
    if not selected_key or not template_path or not template_path.is_dir():
        raise ValueError("Tidak ada template AMPALL valid yang dapat digunakan.")
    safe_reset_folder(amp_folder)
    shutil.copytree(template_path, amp_folder, dirs_exist_ok=True)
    copy_project_media(project, amp_folder.parent)
    media_paths = project_media_relative_paths(project, "../adminseo-media/")
    index_path = amp_folder / "index.html"
    source_content = index_path.read_text(encoding="utf-8", errors="ignore")
    legacy_brands = template_legacy_brands(source_content, project_brand(project))
    final_content = inject_amp_project_content(
        source_content,
        project,
        selected_key,
        media_paths,
        legacy_brands,
    )
    index_path.write_text(final_content, encoding="utf-8")
    validation = validate_amp_file(index_path)
    if validation["status"] != "PASS":
        errors = validation.get("errors") or []
        reason = errors[0].get("message") if errors else "validator resmi tidak tersedia"
        raise ValueError(f"Template AMPALL {selected_key} gagal validasi: {reason}")
    sanitize_copied_template_assets(amp_folder, amp_folder.parent, project, legacy_brands)
    sync_landing_amp_link(project, amp_folder.parent / "index.html")
    return selected_key


def valid_public_url(value: str) -> bool:
    parsed = urlparse(str(value or "").strip())
    return parsed.scheme in {"http", "https"} and bool(parsed.hostname)


def node_executable() -> str | None:
    configured = str(os.environ.get("ADMINSEO_NODE") or "").strip()
    command_node = shutil.which("node")
    candidates = [
        Path(configured) if configured else None,
        Path(command_node) if command_node else None,
        Path.home() / ".cache" / "codex-runtimes" / "codex-primary-runtime" / "dependencies" / "node" / "bin" / "node.exe",
    ]
    runtime_root = Path.home() / ".cache" / "codex-runtimes"
    if runtime_root.is_dir():
        candidates.extend(runtime_root.glob("*/dependencies/node/bin/node.exe"))
    for candidate in candidates:
        if candidate and candidate.is_file():
            return str(candidate)
    return None


def validate_amp_file(file_path: Path) -> dict[str, Any]:
    node = node_executable()
    if not node or not AMP_VALIDATOR_SCRIPT.is_file():
        return {
            "status": "FAIL",
            "available": False,
            "errors": [{"message": "Validator AMP resmi belum terpasang."}],
        }
    try:
        result = subprocess.run(
            [node, str(AMP_VALIDATOR_SCRIPT), str(file_path)],
            cwd=BASE_DIR,
            capture_output=True,
            text=True,
            timeout=45,
            check=False,
        )
        payload = json.loads(result.stdout or "{}")
    except (OSError, subprocess.TimeoutExpired, json.JSONDecodeError) as error:
        return {
            "status": "FAIL",
            "available": True,
            "errors": [{"message": f"Validator AMP tidak dapat dijalankan: {error}"}],
        }

    results = payload.get("results") if isinstance(payload, dict) else []
    errors: list[dict[str, Any]] = []
    if isinstance(results, list):
        for item in results:
            if isinstance(item, dict):
                errors.extend(item.get("errors") or [])
    if not errors and isinstance(payload, dict):
        errors.extend(payload.get("errors") or [])
    return {
        "status": "PASS" if payload.get("status") == "PASS" and result.returncode == 0 else "FAIL",
        "available": True,
        "errors": errors,
    }


def sync_landing_amp_link(project: dict[str, Any], index_path: Path) -> None:
    amp_url = normalize_url_or_empty(str(project.get("amp_url") or ""))
    if not amp_url or not valid_public_url(amp_url) or not index_path.is_file():
        return
    content = index_path.read_text(encoding="utf-8", errors="ignore")
    content = re.sub(
        r"<link\b(?=[^>]*\brel\s*=\s*([\"'])amphtml\1)[^>]*>\s*",
        "",
        content,
        flags=re.I,
    )
    link = f'  <link rel="amphtml" href="{html.escape(amp_url, quote=True)}">\n'
    if re.search(r"</head>", content, flags=re.I):
        content = re.sub(r"</head>", link + "</head>", content, count=1, flags=re.I)
    else:
        content = link + content
    index_path.write_text(content, encoding="utf-8")


def generated_source_legacy_brands(project: dict[str, Any], amp: bool = False) -> list[str]:
    template_key = str(project.get("last_amp_template_key" if amp else "last_template_key") or "")
    templates = discover_ampall() if amp else discover_template89()
    metadata = templates.get(template_key)
    if not metadata:
        return []
    source_path = Path(metadata["path"]) / "index.html"
    try:
        source = source_path.read_text(encoding="utf-8", errors="ignore")
    except OSError:
        return []
    return template_legacy_brands(source, project_brand(project))


def analyze_generated_project(project: dict[str, Any]) -> dict[str, Any]:
    paths = generated_paths(project)
    landing_exists = paths["index"].is_file()
    amp_exists = paths["amp_index"].is_file()
    landing = paths["index"].read_text(encoding="utf-8", errors="ignore") if landing_exists else ""
    amp = paths["amp_index"].read_text(encoding="utf-8", errors="ignore") if amp_exists else ""
    combined_visible = visible_document_text(landing) + " " + visible_document_text(amp)
    brand = project_brand(project)
    legacy_lp = generated_source_legacy_brands(project, False)
    legacy_amp = generated_source_legacy_brands(project, True)
    legacy_brands = list(dict.fromkeys([*legacy_lp, *legacy_amp]))
    old_brand_hits = [
        old_brand
        for old_brand in legacy_brands
        if re.search(re.escape(old_brand), combined_visible, flags=re.I)
    ]

    checks: list[dict[str, Any]] = []

    def add_check(key: str, label: str, passed: bool, detail: str) -> None:
        checks.append({
            "key": key,
            "label": label,
            "status": "pass" if passed else "fail",
            "detail": detail,
        })

    add_check(
        "output_files",
        "File landing page dan AMP",
        landing_exists and amp_exists,
        "index.html dan amp/index.html tersedia." if landing_exists and amp_exists else "Salah satu file output belum tersedia.",
    )

    title_match = re.search(r"<title\b[^>]*>(.*?)</title>", landing, flags=re.I | re.S)
    rendered_title = html.unescape(re.sub(r"<[^>]+>", "", title_match.group(1))).strip() if title_match else ""
    expected_title = str(project.get("seo_title") or "").strip()
    title_ok = bool(expected_title and rendered_title == expected_title and re.search(re.escape(brand), rendered_title, flags=re.I))
    add_check(
        "brand_title",
        "Brand dan SEO title",
        title_ok,
        f"Title: {rendered_title or '-'} | Brand wajib: {brand}",
    )

    brand_visible = bool(re.search(re.escape(brand), combined_visible, flags=re.I))
    add_check(
        "brand_visible",
        "Konsistensi brand pada halaman",
        brand_visible and not old_brand_hits,
        "Brand konsisten dan merek template tidak terlihat."
        if brand_visible and not old_brand_hits
        else f"Brand lama terdeteksi: {', '.join(old_brand_hits) or 'brand utama belum terlihat'}.",
    )

    ai_payload = project.get("ai_content_json")
    ai_report = ai_payload.get("report") if isinstance(ai_payload, dict) else None
    ai_enabled = bool(project.get("use_ai_content"))
    ai_content_ok = not ai_enabled or (
        isinstance(ai_report, dict)
        and ai_report.get("source") == "openai"
        and bool(project.get("ai_generated_at"))
    )
    add_check(
        "content_engine",
        "Sumber konten",
        ai_content_ok,
        (
            f"Konten dibuat OpenAI model {ai_report.get('model')} pada {project.get('ai_generated_at')}."
            if ai_enabled and isinstance(ai_report, dict)
            else "Konten memakai generator lokal."
            if not ai_enabled
            else "AI diaktifkan tetapi laporan generate belum tersedia."
        ),
    )

    uniqueness_content = {
        "seo_title": str(project.get("seo_title") or ""),
        "article_sections": [{"body": str(project.get("article_body") or "")}],
    }
    if project.get("user_id") is not None and project.get("id") is not None:
        uniqueness = ai_content_duplicate_report(
            int(project["user_id"]),
            int(project["id"]),
            uniqueness_content,
        )
    else:
        uniqueness = {"passed": True, "score": 0.0, "domain": ""}
    add_check(
        "content_uniqueness",
        "Keunikan title dan artikel",
        bool(uniqueness["passed"]),
        (
            f"Lolos audit duplikasi. Kemiripan tertinggi {uniqueness['score']:.0%}"
            + (f" terhadap {uniqueness['domain']}." if uniqueness["domain"] else ".")
            if uniqueness["passed"]
            else f"Terlalu mirip {uniqueness['score']:.0%} dengan {uniqueness['domain']}. Generate ulang."
        ),
    )

    media_folder = paths["folder"] / "adminseo-media"
    combined_markup = landing + " " + amp
    for role, label, field in (
        ("logo", "Logo", "logo_media_id"),
        ("icon", "Icon", "icon_media_id"),
        ("main", "Gambar utama", "main_media_id"),
    ):
        selected = bool(media_record(
            safe_int(project.get(field)),
            safe_int(project.get("user_id")),
        ))
        copied = media_folder.is_dir() and any(media_folder.glob(f"{role}.*"))
        referenced = bool(re.search(rf"(?:\.\./)?adminseo-media/{role}\.[A-Za-z0-9]+", combined_markup, flags=re.I))
        passed = selected and copied and referenced
        add_check(
            f"media_{role}",
            label,
            passed,
            f"{label} dipilih, disalin, dan digunakan pada LP/AMP." if passed else f"{label} belum lengkap: pilih media lalu generate ulang.",
        )

    expected_canonical = str(project.get("domain_url") or "").rstrip("/") + "/"
    canonical_tags = [
        tag for tag in re.findall(r"<link\b[^>]*>", landing, flags=re.I)
        if "canonical" in html_attribute(tag, "rel").lower().split()
    ]
    canonical_ok = len(canonical_tags) == 1 and html_attribute(canonical_tags[0], "href").rstrip("/") + "/" == expected_canonical
    add_check(
        "canonical",
        "Canonical domain",
        canonical_ok,
        f"Canonical wajib: {expected_canonical}",
    )

    amp_url = str(project.get("amp_url") or "").strip()
    amp_tags = [
        tag for tag in re.findall(r"<link\b[^>]*>", landing, flags=re.I)
        if "amphtml" in html_attribute(tag, "rel").lower().split()
    ]
    amp_link_ok = (
        amp_exists
        and valid_public_url(amp_url)
        and len(amp_tags) == 1
        and html_attribute(amp_tags[0], "href").rstrip("/") + "/" == amp_url.rstrip("/") + "/"
    )
    add_check(
        "amp",
        "AMP dan rel=amphtml",
        amp_link_ok,
        f"AMP URL: {amp_url or '-'} | Template: {project.get('last_amp_template_key') or '-'}",
    )

    amp_validation = validate_amp_file(paths["amp_index"]) if amp_exists else {
        "status": "FAIL",
        "available": True,
        "errors": [{"message": "File amp/index.html belum tersedia."}],
    }
    amp_errors = amp_validation.get("errors") or []
    amp_detail = (
        "PASS - struktur AMP HTML valid menurut amphtml-validator resmi."
        if amp_validation["status"] == "PASS"
        else "FAIL - " + str(amp_errors[0].get("message") if amp_errors else "validasi AMP gagal")
    )
    add_check(
        "amp_validator",
        "Validasi AMP resmi",
        amp_validation["status"] == "PASS",
        amp_detail,
    )

    amp_canonical_tags = [
        tag for tag in re.findall(r"<link\b[^>]*>", amp, flags=re.I)
        if "canonical" in html_attribute(tag, "rel").lower().split()
    ]
    amp_canonical_ok = (
        len(amp_canonical_tags) == 1
        and html_attribute(amp_canonical_tags[0], "href").rstrip("/") + "/" == expected_canonical
    )
    add_check(
        "amp_canonical",
        "Canonical pada AMP",
        amp_canonical_ok,
        f"Canonical AMP wajib kembali ke: {expected_canonical}",
    )

    expected_alternates = parse_alternate_links(str(project.get("alternate_links") or ""))
    actual_alternates = [
        (html_attribute(tag, "hreflang"), html_attribute(tag, "href"))
        for tag in re.findall(r"<link\b[^>]*>", landing, flags=re.I)
        if "alternate" in html_attribute(tag, "rel").lower().split()
    ]
    alternate_ok = bool(expected_alternates) and all(
        valid_public_url(url) and (language, url) in actual_alternates
        for language, url in expected_alternates
    )
    add_check(
        "alternate",
        "Alternate hreflang",
        alternate_ok,
        f"{len(actual_alternates)} alternate ditemukan dari {len(expected_alternates)} konfigurasi.",
    )

    features = template_content_features(landing)
    add_check(
        "faq",
        "FAQ",
        not int(project.get("generate_faq") or 0) or features["faq"],
        "Bagian FAQ tersedia." if features["faq"] else "Bagian FAQ belum ditemukan.",
    )
    add_check(
        "reviews",
        "Review pengguna",
        not int(project.get("generate_reviews") or 0) or features["reviews"],
        "Bagian review tersedia." if features["reviews"] else "Bagian review belum ditemukan.",
    )

    landing_media = media_paths_relative_to_file(project, paths["folder"], paths["index"])
    amp_media = project_media_relative_paths(project, "../adminseo-media/")
    landing_issues = audit_landing_content(landing, project, False, legacy_lp, landing_media) if landing else ["index.html"]
    amp_issues = audit_landing_content(amp, project, False, legacy_amp, amp_media) if amp else ["amp/index.html"]
    isolation_issues = sorted(set(
        issue for issue in [*landing_issues, *amp_issues]
        if issue in {"anchor domain", "gambar template lama", "konten setelah footer", "artikel tambahan di luar template"}
        or issue.startswith("brand lama ")
    ))
    add_check(
        "template_cleanup",
        "Pembersihan template",
        not isolation_issues,
        "Tidak ada tautan, gambar, brand, atau blok tambahan dari template lama."
        if not isolation_issues else "Masalah: " + ", ".join(isolation_issues),
    )

    seo_files_ok = paths["sitemap"].is_file() and paths["robots"].is_file()
    add_check(
        "seo_files",
        "Sitemap dan robots",
        seo_files_ok,
        "sitemap.xml dan robots.txt tersedia." if seo_files_ok else "File SEO belum lengkap.",
    )

    failed_count = sum(1 for item in checks if item["status"] == "fail")
    return {
        "project_id": int(project["id"]),
        "checked_at": utc_now(),
        "status": "pass" if failed_count == 0 else "fail",
        "passed_count": len(checks) - failed_count,
        "failed_count": failed_count,
        "checks": checks,
        "identity": {
            "brand": brand,
            "domain": project.get("hostname") or "",
            "landing_template": project.get("last_template_key") or "",
            "amp_template": project.get("last_amp_template_key") or "",
            "legacy_brands": legacy_brands,
        },
        "amp_validation": amp_validation,
        "previews": {
            "landing": f"/generated/{quote(str(project['slug']))}/index.html",
            "amp": f"/generated/{quote(str(project['slug']))}/amp/index.html",
        },
    }


def store_finishing_report(project_id: int, report: dict[str, Any], user_id: int) -> None:
    checked_at = str(report.get("checked_at") or utc_now())
    with db() as connection:
        connection.execute(
            """
            UPDATE projects
            SET finishing_report = ?, finishing_checked_at = ?, updated_at = ?
            WHERE id = ? AND user_id = ?
            """,
            (json.dumps(report, ensure_ascii=False), checked_at, checked_at, project_id, user_id),
        )


def ensure_finishing_report(project: dict[str, Any]) -> dict[str, Any]:
    report = project.get("finishing_report")
    if not isinstance(report, dict) or not report.get("checks"):
        report = analyze_generated_project(project)
        store_finishing_report(int(project["id"]), report, int(project["user_id"]))
        project = {**project, "finishing_report": report, "finishing_checked_at": report["checked_at"]}
    return project


def reanalyze_project(project_id: int, user_id: int) -> dict[str, Any]:
    project = load_project(project_id, user_id)
    if not project or not project.get("last_generated_at"):
        raise ValueError("Hasil generate project belum tersedia.")
    report = analyze_generated_project(project)
    store_finishing_report(project_id, report, user_id)
    refreshed = load_project(project_id, user_id)
    return {"project": refreshed, "report": report}


def generated_user_dir(user_id: int) -> Path:
    return GENERATED_DIR / f"user-{int(user_id)}"


def migrate_generated_storage() -> None:
    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
    with db() as connection:
        rows = connection.execute(
            """
            SELECT id, user_id, slug, generated_path, last_generated_at
            FROM projects
            WHERE generated_path IS NOT NULL OR last_generated_at IS NOT NULL
            """
        ).fetchall()
        for row in rows:
            user_id = int(row["user_id"])
            target = generated_user_dir(user_id) / str(row["slug"])
            recorded = Path(str(row["generated_path"] or "")) if row["generated_path"] else None
            legacy = recorded if recorded and recorded.exists() else GENERATED_DIR / str(row["slug"])
            if legacy.exists() and legacy.resolve() != target.resolve():
                target.parent.mkdir(parents=True, exist_ok=True)
                if target.exists():
                    shutil.copytree(legacy, target, dirs_exist_ok=True)
                    if GENERATED_DIR.resolve() in legacy.resolve().parents:
                        shutil.rmtree(legacy)
                else:
                    shutil.move(str(legacy), str(target))
            connection.execute(
                "UPDATE projects SET generated_path = ? WHERE id = ? AND user_id = ?",
                (str(target), row["id"], user_id),
            )


def refresh_domain_txt(user_id: int | None = None) -> None:
    if user_id is None:
        with db() as connection:
            user_ids = [int(row["id"]) for row in connection.execute("SELECT id FROM users")]
        for scoped_user_id in user_ids:
            refresh_domain_txt(scoped_user_id)
        return

    lines: list[str] = []
    for project in generated_projects(user_id):
        lines.append(str(project.get("hostname") or ""))
        amp_host = urlparse(str(project.get("amp_url") or "")).hostname
        if amp_host:
            lines.append(amp_host)
    domain_txt = generated_user_dir(user_id) / "domain.txt"
    domain_txt.parent.mkdir(parents=True, exist_ok=True)
    domain_txt.write_text("\n".join(dict.fromkeys(line for line in lines if line)) + ("\n" if lines else ""), encoding="utf-8")


def approve_project(project_id: int, manual_confirmation: bool, user_id: int) -> dict[str, Any]:
    if not manual_confirmation:
        raise ValueError("Konfirmasi pemeriksaan manual wajib dicentang.")
    project = load_project(project_id, user_id)
    if not project or not project.get("last_generated_at"):
        raise ValueError("Hasil generate project belum tersedia.")
    report = analyze_generated_project(project)
    amp_check = next((item for item in report["checks"] if item["key"] == "amp_validator"), None)
    if not amp_check or amp_check["status"] != "pass":
        raise ValueError("AMP belum valid. Generate ulang dan pastikan Validasi AMP resmi berstatus PASS.")
    now = utc_now()
    action = "approved" if report["status"] == "pass" else "approved_with_warnings"
    with db() as connection:
        connection.execute(
            """
            UPDATE projects
            SET publication_status = 'approved',
                finishing_report = ?,
                finishing_checked_at = ?,
                approved_at = ?,
                updated_at = ?
            WHERE id = ? AND user_id = ?
            """,
            (json.dumps(report, ensure_ascii=False), report["checked_at"], now, now, project_id, user_id),
        )
        connection.execute(
            "INSERT INTO generation_logs (project_id, action, created_at) VALUES (?, ?, ?)",
            (project_id, action, now),
        )
    refresh_domain_txt(user_id)
    refreshed = load_project(project_id, user_id)
    return {"project": refreshed, "report": report, "result_url": "/results"}


def write_generated_file(project: dict[str, Any], kind: str, require_media: bool = True) -> dict[str, Any]:
    if kind in {"landing", "all"}:
        project = complete_project_content(project)
    validate_generation(project, kind, require_media)
    paths = generated_paths(project)
    paths["folder"].mkdir(parents=True, exist_ok=True)
    selected_template: str | None = None
    selected_amp_template: str | None = None

    if kind == "landing":
        selected_template = build_landing_from_template(project, paths["folder"], require_media)
        selected_amp_template = build_amp_from_template(project, paths["amp_folder"])
        files = ["index.html", "amp/index.html"]
    elif kind == "sitemap":
        paths["sitemap"].write_text(sitemap_xml(project), encoding="utf-8")
        files = ["sitemap.xml"]
    elif kind == "robots":
        paths["robots"].write_text(robots_txt(project), encoding="utf-8")
        files = ["robots.txt"]
    elif kind == "all":
        selected_template = build_landing_from_template(project, paths["folder"], require_media)
        selected_amp_template = build_amp_from_template(project, paths["amp_folder"])
        paths["sitemap"].write_text(sitemap_xml(project), encoding="utf-8")
        paths["robots"].write_text(robots_txt(project), encoding="utf-8")
        files = ["index.html", "amp/index.html", "sitemap.xml", "robots.txt"]
    else:
        raise ValueError("Jenis generate tidak dikenali.")

    now = utc_now()
    content_generated = kind in {"landing", "all"}
    audit_project = {
        **project,
        "last_template_key": selected_template or project.get("last_template_key") or "",
        "last_amp_template_key": selected_amp_template or project.get("last_amp_template_key") or "",
    }
    finishing_report = analyze_generated_project(audit_project) if content_generated else None
    generated_urls = [f"/generated/{quote(project['slug'])}/{quote(name)}" for name in files]
    if not content_generated:
        generated_urls = list(dict.fromkeys([*(project.get("generated_urls") or []), *generated_urls]))
    with db() as connection:
        connection.execute(
            """
            UPDATE projects
            SET last_generated_at = ?,
                generated_path = ?,
                generated_urls = ?,
                last_template_key = CASE WHEN ? != '' THEN ? ELSE last_template_key END,
                last_amp_template_key = CASE WHEN ? != '' THEN ? ELSE last_amp_template_key END,
                publication_status = CASE WHEN ? = 1 THEN 'pending' ELSE publication_status END,
                finishing_report = CASE WHEN ? = 1 THEN ? ELSE finishing_report END,
                finishing_checked_at = CASE WHEN ? = 1 THEN ? ELSE finishing_checked_at END,
                approved_at = CASE WHEN ? = 1 THEN NULL ELSE approved_at END,
                updated_at = ?
            WHERE id = ? AND user_id = ?
            """,
            (
                now,
                str(paths["folder"]),
                json.dumps(generated_urls),
                selected_template or "",
                selected_template or "",
                selected_amp_template or "",
                selected_amp_template or "",
                1 if content_generated else 0,
                1 if content_generated else 0,
                json.dumps(finishing_report or {}, ensure_ascii=False),
                1 if content_generated else 0,
                (finishing_report or {}).get("checked_at"),
                1 if content_generated else 0,
                now,
                project["id"],
                project["user_id"],
            ),
        )
        connection.execute(
            "INSERT INTO generation_logs (project_id, action, created_at) VALUES (?, ?, ?)",
            (project["id"], kind, now),
        )

    refreshed = load_project(int(project["id"]), int(project["user_id"]))
    return {
        "project": refreshed,
        "files": files,
        "folder": str(paths["folder"]),
        "urls": generated_urls,
        "template": selected_template,
        "amp_template": selected_amp_template,
        "audit": finishing_report,
        "review_url": f"/finishing?project={project['id']}" if content_generated else None,
    }


def login_html(error: str = "", success: str = "") -> str:
    error_block = f'<div class="login-error">{html.escape(error)}</div>' if error else ""
    success_block = f'<div class="account-create-status success">{html.escape(success)}</div>' if success else ""
    return f"""<!doctype html>
<html lang="id">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Login AdminSEO</title>
  <meta name="description" content="Login AdminSEO Landing Page Generator.">
  <link rel="stylesheet" href="/public/styles.css">
</head>
<body class="login-screen">
  <main class="login-wrap">
    <section class="login-visual" aria-label="AdminSEO access panel">
      <div class="signal-grid"></div>
      <div class="orbital-card">
        <span class="pulse-dot"></span>
        <p>Secure Access</p>
        <h1>AdminSEO Control Center</h1>
        <span>Landing page, SEO metadata, sitemap, dan robots dikelola dari satu dashboard tertutup.</span>
      </div>
    </section>

    <form class="login-card" method="post" action="/login">
      <div class="brand login-brand">
        <span class="brand-mark">A</span>
        <div>
          <strong>AdminSEO</strong>
          <small>Authorized Login</small>
        </div>
      </div>
      <h2>Masuk Dashboard</h2>
      <p class="login-copy">Gunakan akun admin untuk membuka generator landing page dan file SEO.</p>
      {success_block}
      {error_block}
      <label for="username">Username</label>
      <input id="username" name="username" type="text" autocomplete="username" required autofocus>
      <label for="password">Password</label>
      <input id="password" name="password" type="password" autocomplete="current-password" required>
      <button class="primary glow" type="submit">Login</button>
    </form>
  </main>
</body>
</html>
"""


def account_security_html(username: str, error: str = "") -> str:
    error_block = f'<div class="account-create-status error">{html.escape(error)}</div>' if error else ""
    return f"""<!doctype html>
<html lang="id">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Keamanan Akun AdminSEO</title>
  <meta name="robots" content="noindex,nofollow">
  <link rel="stylesheet" href="/public/styles.css">
</head>
<body class="admin-screen account-create-screen">
  <main class="account-create-wrap">
    <section class="account-create-card">
      <div class="brand account-create-brand">
        <span class="brand-mark">{html.escape((username[:1] or 'A').upper())}</span>
        <div>
          <strong>{html.escape(username)}</strong>
          <small>Account Security</small>
        </div>
      </div>
      <p class="account-create-eyebrow">Keamanan Online</p>
      <h1>Ganti Password</h1>
      <p class="account-security-copy">Setelah diganti, semua sesi login lama akan berakhir dan Anda wajib masuk kembali.</p>
      {error_block}
      <form method="post" action="/account/security">
        <label for="currentPassword">Password Saat Ini</label>
        <input id="currentPassword" name="current_password" type="password" autocomplete="current-password" required autofocus>
        <label for="newPassword">Password Baru</label>
        <input id="newPassword" name="new_password" type="password" minlength="12" maxlength="128" autocomplete="new-password" required>
        <label for="confirmPassword">Konfirmasi Password Baru</label>
        <input id="confirmPassword" name="confirmation" type="password" minlength="12" maxlength="128" autocomplete="new-password" required>
        <button class="primary glow" type="submit">Perbarui Password</button>
      </form>
      <a class="account-create-back" href="/">Kembali ke Dashboard</a>
    </section>
  </main>
</body>
</html>
"""


def create_admin_html(success: str = "", error: str = "") -> str:
    success_block = f'<div class="account-create-status success">{html.escape(success)}</div>' if success else ""
    error_block = f'<div class="account-create-status error">{html.escape(error)}</div>' if error else ""
    return f"""<!doctype html>
<html lang="id">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Buat Akun AdminSEO</title>
  <meta name="robots" content="noindex,nofollow">
  <link rel="stylesheet" href="/public/styles.css">
</head>
<body class="admin-screen account-create-screen">
  <main class="account-create-wrap">
    <section class="account-create-card">
      <div class="brand account-create-brand">
        <span class="brand-mark">A</span>
        <div>
          <strong>AdminSEO</strong>
          <small>Account Control</small>
        </div>
      </div>
      <p class="account-create-eyebrow">Primary Admin</p>
      <h1>Buat Akun Baru</h1>
      {success_block}
      {error_block}
      <form method="post" action="/pembuatan-admin">
        <label for="newUsername">Username</label>
        <input id="newUsername" name="username" type="text" minlength="3" maxlength="32" autocomplete="off" required autofocus>
        <label for="newPassword">Password</label>
        <input id="newPassword" name="password" type="password" minlength="8" maxlength="128" autocomplete="new-password" required>
        <button class="primary glow" type="submit">Buat Akun</button>
      </form>
      <a class="account-create-back" href="/">Kembali ke Dashboard</a>
    </section>
  </main>
</body>
</html>
"""


def openai_model_options_markup() -> str:
    groups = []
    for group_label, models in OPENAI_MODEL_GROUPS:
        options = []
        for model_id, label, quality, speed, use_case in models:
            selected = " selected" if model_id == DEFAULT_OPENAI_MODEL else ""
            options.append(
                f'<option value="{html.escape(model_id, quote=True)}" '
                f'data-quality="{html.escape(quality, quote=True)}" '
                f'data-speed="{html.escape(speed, quote=True)}" '
                f'data-use="{html.escape(use_case, quote=True)}"{selected}>'
                f'{html.escape(label)}</option>'
            )
        groups.append(
            f'<optgroup label="{html.escape(group_label, quote=True)}">'
            + "".join(options)
            + "</optgroup>"
        )
    groups.append(
        '<optgroup label="Lainnya">'
        '<option value="__custom__" data-quality="Sesuai model" data-speed="Sesuai model" '
        'data-use="Gunakan ID model atau snapshot yang tersedia di akun">ID model kustom...</option>'
        '</optgroup>'
    )
    return "".join(groups)


def index_html(active_page: str = "domains", username: str = DEFAULT_USERNAME) -> str:
    template_options = "\n".join(
        f'<option value="{html.escape(key)}">{html.escape(value["name"])}</option>'
        for key, value in template_menu_options().items()
    )
    amp_template_options = "\n".join(
        f'<option value="{html.escape(key)}">{html.escape(value["name"])}</option>'
        for key, value in amp_template_menu_options().items()
    ) or f'<option value="{RANDOM_AMP_TEMPLATE_KEY}">AMPALL belum ditemukan</option>'
    generator_open = active_page in {"domains", "batch", "workflow", "media", "alternate"}
    seo_tools_open = active_page == "sitemap"
    ai_menu_open = active_page in {"ai-api", "ai-analytics", "ai-schema"}
    generator_group_class = "menu-group is-open contains-active" if generator_open else "menu-group"
    seo_group_class = "menu-group is-open contains-active" if seo_tools_open else "menu-group"
    ai_group_class = "menu-group is-open contains-active" if ai_menu_open else "menu-group"
    generator_hidden = "" if generator_open else " hidden"
    seo_tools_hidden = "" if seo_tools_open else " hidden"
    ai_menu_hidden = "" if ai_menu_open else " hidden"
    page_title = {
        "ai-api": "Konek API AI",
        "ai-analytics": "Analytic SEO",
        "ai-schema": "Alur Skema SEO",
    }.get(active_page, "Generator Landing Page + SEO")
    return f"""<!doctype html>
<html lang="id">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>AdminSEO Landing Page Generator</title>
  <meta name="description" content="Panel admin untuk membuat landing page, SEO title, sitemap.xml, dan robots.txt.">
  <link rel="stylesheet" href="/public/styles.css">
</head>
<body class="admin-screen" data-active-page="{html.escape(active_page)}">
  <div class="shell">
    <aside class="sidebar">
      <div class="brand">
        <span class="brand-mark">A</span>
        <div>
          <strong>AdminSEO</strong>
          <small>Landing Generator</small>
        </div>
      </div>
      <nav class="menu" aria-label="Menu utama">
        <div class="{generator_group_class}" data-menu-group data-menu-pages="domains batch workflow media alternate">
          <button class="menu-group-toggle" type="button" aria-expanded="{'true' if generator_open else 'false'}" aria-controls="landingPageSubmenu">
            <span>Generate Landing Page</span>
            <span class="menu-chevron" aria-hidden="true"></span>
          </button>
          <div class="menu-submenu" id="landingPageSubmenu"{generator_hidden}>
            <a href="/domains" data-nav-page="domains">Single Domain</a>
            <a href="/batch" data-nav-page="batch">Batch 10 Domain</a>
            <a href="/workflow" data-nav-page="workflow">Auto Workflow</a>
            <a href="/media" data-nav-page="media">Media</a>
            <a href="/alternate" data-nav-page="alternate">Alternate & AMP</a>
          </div>
        </div>

        <a class="menu-primary-link" href="/finishing" data-nav-page="finishing">
          <span>Finishing & Audit</span>
          <span id="finishingMenuCount" class="menu-count">0</span>
        </a>
        <a class="menu-primary-link" href="/results" data-nav-page="results">Hasil Landing Page</a>

        <div class="{seo_group_class}" data-menu-group data-menu-pages="sitemap">
          <button class="menu-group-toggle" type="button" aria-expanded="{'true' if seo_tools_open else 'false'}" aria-controls="seoToolsSubmenu">
            <span>SEO Tools</span>
            <span class="menu-chevron" aria-hidden="true"></span>
          </button>
          <div class="menu-submenu" id="seoToolsSubmenu"{seo_tools_hidden}>
            <a href="/sitemap" data-nav-page="sitemap">File Sitemap & Robots</a>
            <button class="menu-action" id="generateSitemap" type="button">Buat Sitemap.xml</button>
            <button class="menu-action" id="generateRobots" type="button">Buat Robots.txt</button>
          </div>
        </div>

        <div class="{ai_group_class}" data-menu-group data-menu-pages="ai-api ai-analytics ai-schema">
          <button class="menu-group-toggle" type="button" aria-expanded="{'true' if ai_menu_open else 'false'}" aria-controls="aiMenuSubmenu">
            <span>AI MENU</span>
            <span class="menu-chevron" aria-hidden="true"></span>
          </button>
          <div class="menu-submenu" id="aiMenuSubmenu"{ai_menu_hidden}>
            <a href="/ai/konek-api" data-nav-page="ai-api">Konek API</a>
            <a href="/ai/analytic-seo" data-nav-page="ai-analytics">Analytic SEO</a>
            <a href="/ai/alur-skema-seo" data-nav-page="ai-schema">Alur Skema SEO</a>
          </div>
        </div>
      </nav>
      <div class="side-note">
        <span id="projectCount">0</span>
        <small>domain tersimpan</small>
      </div>
      <div class="account-summary">
        <span class="account-avatar">{html.escape((username[:1] or 'A').upper())}</span>
        <div>
          <small>Akun aktif</small>
          <strong>{html.escape(username)}</strong>
        </div>
      </div>
      <a class="account-security-link" href="/account/security">Keamanan Akun</a>
      <form class="logout-form" method="post" action="/logout">
        <button type="submit">Logout</button>
      </form>
    </aside>

    <main class="workspace">
      <section class="topbar">
        <div>
          <p>Secure SEO Console</p>
          <h1>{html.escape(page_title)}</h1>
        </div>
        <button class="secondary" id="newProject" type="button">Project Baru</button>
      </section>

      <section class="grid" data-editor-pages="domains batch workflow media alternate">
        <form id="projectForm" class="panel" data-editor-pages="domains batch workflow media alternate">
          <input type="hidden" id="projectId" name="id">
          <input type="hidden" id="logoMediaId" name="logo_media_id" data-generate-required>
          <input type="hidden" id="iconMediaId" name="icon_media_id" data-generate-required>
          <input type="hidden" id="mainMediaId" name="main_media_id" data-generate-required>

          <div id="domain" class="form-section" data-cms-page="domains">
            <span class="section-number">01</span>
            <div>
              <p class="section-kicker">Mode Tunggal</p>
              <h2>Single Domain</h2>
              <label for="domainUrl">URL Domain</label>
              <input id="domainUrl" name="domain_url" type="text" placeholder="example.com" data-generate-required>
              <p class="field-hint">Gunakan menu ini kalau ingin simpan atau generate satu landing page saja.</p>
            </div>
          </div>

          <div id="batch" class="form-section" data-cms-page="batch">
            <span class="section-number">01</span>
            <div>
              <p class="section-kicker">Mode Massal</p>
              <h2>Batch 10 Domain</h2>
              <div class="batch-box">
                <div class="panel-head tight">
                  <div>
                    <p>Batch Generator</p>
                    <h3>Generator Table 10 Landing Page</h3>
                  </div>
                  <button class="secondary" id="fillGeneratorRows" type="button">Isi 10 Baris</button>
                </div>
                <p class="field-hint">Setiap baris bisa punya domain, AMP/alternate, Media Group, template, dan opsi auto sendiri. Kosongkan kolom AMP/alternate/template untuk memakai setting global di bawah.</p>
                <div class="generator-table-wrap">
                  <table class="generator-table">
                    <thead>
                      <tr>
                        <th>Domain</th>
                        <th>Alternate & AMP</th>
                        <th>Media Group</th>
                        <th>Template LP & AMP</th>
                        <th>Auto Lainnya</th>
                      </tr>
                    </thead>
                    <tbody id="generatorRows"></tbody>
                  </table>
                </div>
                <details class="legacy-domains">
                  <summary>Input cepat daftar domain</summary>
                  <label for="batchDomains">Daftar Domain</label>
                  <textarea id="batchDomains" rows="5" placeholder="domain1.com&#10;domain2.com&#10;domain3.com"></textarea>
                </details>
                <button class="primary" id="batchGenerate" type="button">Generate Landing Page</button>
              </div>
            </div>
          </div>

          <div id="template-default" class="form-section" data-cms-page="domains batch workflow">
            <span class="section-number">02</span>
            <div>
              <p class="section-kicker">Pengaturan Utama</p>
              <h2>Template LP & AMP Default</h2>
              <label for="templateKey">Template LP Default</label>
              <select id="templateKey" name="template_key" data-generate-required>{template_options}</select>
              <p class="field-hint">Di Batch, template default dipakai kalau kolom Template LP pada baris domain dikosongkan.</p>
              <label for="ampTemplateKey">Template AMP Default</label>
              <select id="ampTemplateKey" name="amp_template_key">{amp_template_options}</select>
              <p class="field-hint">Pilih Random dari AMPALL agar setiap domain mengambil salah satu template AMP yang tersedia.</p>
              <div class="generator-options compact-options">
                <label class="checkline">
                  <input id="generateFaq" name="generate_faq" type="checkbox" checked>
                  <span>Default: Buat 5 FAQ</span>
                </label>
                <label class="checkline">
                  <input id="generateReviews" name="generate_reviews" type="checkbox" checked>
                  <span>Default: Buat 5 review pengguna persona Indonesia</span>
                </label>
                <label class="checkline">
                  <input id="auditBeforeSave" name="audit_before_save" type="checkbox" checked>
                  <span>Default: Audit hasil sebelum menyimpan</span>
                </label>
              </div>
            </div>
          </div>

          <div id="workflow" class="form-section" data-cms-page="workflow">
            <span class="section-number">01</span>
            <div>
              <p class="section-kicker">Workflow Manual Jadi Auto</p>
              <h2>Auto Workflow Starter</h2>
              <p class="field-hint">Tempel daftar folder/domain lama, isi title opsional jika ada, lalu sistem membuat content file, AMP folder, sitemap, robots, domain.txt, dan landing page jika media sudah dipilih.</p>
              <label for="workflowDomains">Folder / Domain</label>
              <textarea id="workflowDomains" rows="8" placeholder="[franksburger.es]&#10;[laestaciondiscopub.es]&#10;pizzarbol.es"></textarea>
              <label for="workflowTitles">Title Opsional Per Domain</label>
              <textarea id="workflowTitles" rows="6" placeholder="franksburger.es|WAK89 | Burger Frank Pilihan Login Tercepat&#10;pizzarbol.es|WAK89 > Situs Pizza Rbol Alternatif Terbaik"></textarea>
              <div class="workflow-toolbar">
                <button class="secondary" id="buildWorkflowRows" type="button">Susun Tabel Workflow</button>
              </div>
              <div class="generator-table-wrap workflow-table-wrap">
                <table class="generator-table workflow-table">
                  <thead>
                    <tr>
                      <th>Domain</th>
                      <th>Title</th>
                      <th>Template LP & AMP</th>
                      <th>Media Group</th>
                    </tr>
                  </thead>
                  <tbody id="workflowRows"></tbody>
                </table>
              </div>
              <div class="defaults-grid">
                <div>
                  <label for="workflowBrand">Keyword Brand</label>
                  <input id="workflowBrand" type="text" value="WAK89">
                </div>
                <div>
                  <label for="workflowAmpWords">Kata Subdomain AMP</label>
                  <input id="workflowAmpWords" type="text" value="lament, deus, rosea, nusa, orbit">
                </div>
              </div>
              <div class="defaults-grid">
                <div>
                  <label for="workflowMediaGroup">Media Group Landing Page</label>
                  <select id="workflowMediaGroup">
                    <option value="">Media global / content saja</option>
                  </select>
                </div>
                <div>
                  <label for="workflowCtaUrl">URL CTA Default</label>
                  <input id="workflowCtaUrl" type="text" placeholder="Kosongkan untuk pakai URL domain">
                </div>
              </div>
              <div class="actions inline-actions">
                <button class="primary" id="runWorkflowStarter" type="button">Generate Auto Workflow</button>
              </div>
              <div id="workflowResultList" class="workflow-results"></div>
            </div>
          </div>

          <div id="seo" class="form-section" data-cms-page="domains batch workflow">
            <span class="section-number">03</span>
            <div>
              <p class="section-kicker">SEO Global</p>
              <h2>Default SEO</h2>
              <label for="seoTitle">Sertakan Title Default</label>
              <input id="seoTitle" name="seo_title" type="text" placeholder="Judul SEO utama" data-generate-required>
              <label class="checkline">
                <input id="titleIncluded" name="title_included" type="checkbox" checked>
                <span>Tampilkan title di halaman landing page</span>
              </label>
              <label for="metaDescription">Meta Description</label>
              <textarea id="metaDescription" name="meta_description" rows="3" placeholder="Deskripsi singkat untuk mesin pencari" data-generate-required></textarea>
              <label for="keywords">Keywords</label>
              <input id="keywords" name="keywords" type="text" placeholder="landing page, jasa, produk" data-generate-required>
              <div class="ai-content-engine">
                <div class="ai-content-engine-head">
                  <div>
                    <p class="section-kicker">AI Content Engine</p>
                    <h3>Konten Unik dengan AI</h3>
                  </div>
                  <span id="aiGeneratorState" class="ai-state waiting"><span></span>Memeriksa API</span>
                </div>
                <label class="checkline ai-content-toggle">
                  <input id="useAiContent" name="use_ai_content" type="checkbox">
                  <span>Gunakan AI saat Generate Landing Page</span>
                </label>
                <div class="defaults-grid">
                  <div>
                    <label for="aiContentMode">Mode Penulisan</label>
                    <select id="aiContentMode" name="ai_content_mode">
                      <option value="rewrite">Tulis ulang semua</option>
                      <option value="fill">Pertahankan arahan manual</option>
                    </select>
                  </div>
                  <div class="ai-engine-summary">
                    <small>Output otomatis</small>
                    <strong>Title, artikel, FAQ, dan review</strong>
                  </div>
                </div>
                <label for="aiInstructions">Arahan Khusus AI</label>
                <textarea id="aiInstructions" name="ai_instructions" rows="4" placeholder="Contoh: fokus pada layanan lokal, gaya profesional, target pembaca Indonesia, hindari klaim berlebihan."></textarea>
                <p id="aiGeneratorHint" class="field-hint">Hubungkan OpenAI API dari AI MENU agar fitur ini dapat digunakan.</p>
              </div>
            </div>
          </div>

          <div id="media" class="form-section" data-cms-page="media">
            <span class="section-number">03</span>
            <div>
              <h2>Media</h2>
              <p class="field-hint">Upload gambar lalu pilih masing-masing sebagai Logo, Icon, dan Gambar Utama. Tiga pilihan ini wajib sebelum Generate LP.</p>
              <div class="media-upload">
                <input id="mediaFiles" type="file" accept="image/*" multiple>
                <button class="secondary" id="uploadMedia" type="button">Upload Media</button>
              </div>
              <div class="media-selected">
                <div><strong>Logo</strong><span id="logoMediaLabel">Belum dipilih</span></div>
                <div><strong>Icon</strong><span id="iconMediaLabel">Belum dipilih</span></div>
                <div><strong>Gambar Utama</strong><span id="mainMediaLabel">Belum dipilih</span></div>
              </div>
              <div class="media-group-builder">
                <div>
                  <label for="mediaGroupName">Nama Media Group</label>
                  <input id="mediaGroupName" type="text" placeholder="Media Grup A">
                </div>
                <button class="primary" id="saveMediaGroup" type="button">Simpan Media Group</button>
              </div>
              <div id="mediaGroupList" class="group-list"></div>
              <div id="mediaLibrary" class="media-library"></div>
            </div>
          </div>

          <div id="content" class="form-section" data-cms-page="domains batch workflow">
            <span class="section-number">04</span>
            <div>
              <p class="section-kicker">Opsional</p>
              <h2>Default Konten</h2>
              <label for="heroHeading">Headline</label>
              <input id="heroHeading" name="hero_heading" type="text" placeholder="Kosongkan untuk dibuat otomatis">
              <label for="heroSubheading">Subheadline</label>
              <textarea id="heroSubheading" name="hero_subheading" rows="3" placeholder="Kosongkan untuk dibuat otomatis"></textarea>
              <label for="articleBody">Artikel</label>
              <textarea id="articleBody" name="article_body" rows="8" placeholder="Kosongkan agar artikel dibuat otomatis dari SEO title, description, dan keywords"></textarea>
              <div class="two">
                <div>
                  <label for="ctaLabel">Teks CTA</label>
                  <input id="ctaLabel" name="cta_label" type="text" placeholder="Kosongkan untuk dibuat otomatis">
                </div>
                <div>
                  <label for="ctaUrl">URL CTA</label>
                  <input id="ctaUrl" name="cta_url" type="text" placeholder="https://example.com/order" data-generate-required>
                </div>
              </div>
              <p class="field-hint">Headline, subheadline, teks CTA, dan artikel bisa dibuat otomatis saat klik Generate.</p>
            </div>
          </div>

          <div id="generate" class="actions" data-cms-page="domains">
            <button class="primary" type="submit">Simpan Single Domain</button>
            <button class="primary dark" id="generateLanding" type="button">Generate Single LP</button>
          </div>

          <div id="alternate" class="form-section" data-cms-page="alternate">
            <span class="section-number">01</span>
            <div>
              <h2>Default Alternate & AMP</h2>
              <p class="field-hint">Dipakai untuk single domain atau baris generator yang kolom AMP/alternate-nya kosong. Data ini akan disisipkan ke kode landing page dan ikut masuk ketika export ZIP.</p>
              <label for="ampUrl">AMP URL</label>
              <input id="ampUrl" name="amp_url" type="text" placeholder="https://amp.domain.com/">
              <label for="alternateLinks">Alternate Hreflang</label>
              <textarea id="alternateLinks" name="alternate_links" rows="8" placeholder="id|https://domain.com/&#10;en|https://domain.com/en/&#10;x-default|https://domain.com/"></textarea>
              <p class="field-hint">Format per baris: `kode-bahasa|url`, contoh `id|https://domain.com/`.</p>
              <div class="actions inline-actions">
                <button class="primary" type="submit">Simpan Alternate & AMP</button>
              </div>
            </div>
          </div>
        </form>

        <aside class="panel compact">
          <div class="panel-head">
            <h2>Domain Tersimpan</h2>
            <button class="icon" id="refreshProjects" type="button" aria-label="Refresh">R</button>
          </div>
          <div id="projectList" class="project-list"></div>

          <div class="output">
            <h2>Output</h2>
            <div id="status" class="status">Belum ada aksi.</div>
            <div id="generatedLinks" class="links"></div>
          </div>
        </aside>
      </section>

      <section class="panel page-panel" data-cms-page="sitemap">
        <div class="panel-head">
          <div>
            <p>SEO Files</p>
            <h2>Sitemap & Robots</h2>
          </div>
          <button class="primary" id="refreshResults" type="button">Refresh</button>
        </div>
        <p class="field-hint">Setiap landing page yang berhasil digenerate otomatis membawa `sitemap.xml` dan `robots.txt`. Menu ini dipakai untuk cek file SEO yang sudah tersedia.</p>
        <div id="sitemapList" class="result-list"></div>
      </section>

      <section class="panel page-panel ai-page" data-cms-page="ai-api">
        <div class="panel-head">
          <div>
            <p>AI Infrastructure</p>
            <h2>Konek API</h2>
          </div>
          <span id="aiConnectionState" class="ai-state offline"><span></span>Belum terhubung</span>
        </div>
        <div class="ai-metrics" aria-label="Status koneksi API">
          <div><small>Provider</small><strong id="aiProviderValue">OpenAI</strong></div>
          <div><small>Model</small><strong id="aiModelValue">{DEFAULT_OPENAI_MODEL}</strong></div>
          <div><small>Workspace</small><strong>{html.escape(username)}</strong></div>
        </div>
        <form id="aiConnectionForm" class="ai-connection-form">
          <div class="ai-form-grid">
            <div>
              <label for="aiProvider">Provider</label>
              <select id="aiProvider" name="provider">
                <option value="openai">OpenAI</option>
              </select>
            </div>
            <div class="ai-model-field">
              <label for="aiModel">Model</label>
              <select id="aiModel" name="model_preset" required>
                {openai_model_options_markup()}
              </select>
              <input id="aiCustomModel" class="ai-custom-model" name="model" type="text" autocomplete="off" placeholder="Contoh: gpt-5.6-terra-YYYY-MM-DD" hidden>
              <div id="aiModelGuide" class="ai-model-guide" aria-live="polite">
                <div><small>Kualitas</small><strong id="aiModelQuality">Tinggi</strong></div>
                <div><small>Kecepatan</small><strong id="aiModelSpeed">Seimbang</strong></div>
                <div><small>Cocok untuk</small><strong id="aiModelUse">Landing page produksi dan batch</strong></div>
              </div>
            </div>
            <div class="ai-key-field">
              <label for="aiApiKey">OpenAI API Key</label>
              <input id="aiApiKey" name="api_key" type="password" autocomplete="new-password" placeholder="sk-...">
              <small id="aiKeyHint">Belum ada API key tersimpan.</small>
            </div>
          </div>
          <div id="aiConnectionStatus" class="status">Masukkan API key lalu uji koneksi.</div>
          <div class="ai-connection-actions">
            <button class="primary" id="saveAiConnection" type="submit">Simpan Koneksi</button>
            <button class="secondary" id="testAiConnection" type="button">Uji Koneksi</button>
            <button class="secondary ai-delete-connection" id="deleteAiConnection" type="button" hidden>Hapus Koneksi</button>
          </div>
          <p class="field-hint">API key dienkripsi di server dan tidak ditampilkan kembali. Gunakan HTTPS sebelum panel dipasang pada domain publik.</p>
        </form>
      </section>

      <section class="panel page-panel ai-page" data-cms-page="ai-analytics">
        <div class="panel-head">
          <div>
            <p>AI SEO Inspector</p>
            <h2>Analytic SEO</h2>
          </div>
          <span class="ai-state waiting"><span></span>Menunggu API</span>
        </div>
        <div class="ai-metrics" aria-label="Ringkasan analisis SEO">
          <div><small>Domain Dianalisis</small><strong>0</strong></div>
          <div><small>Audit AI</small><strong>0</strong></div>
          <div><small>Rekomendasi</small><strong>0</strong></div>
        </div>
        <div class="ai-empty-state">
          <span class="ai-empty-mark">SEO</span>
          <h3>Belum ada analisis AI</h3>
          <p>Hubungkan API sebelum menjalankan analisis domain dan hasil landing page.</p>
          <a class="download-button subtle" href="/ai/konek-api">Konek API</a>
        </div>
      </section>

      <section class="panel page-panel ai-page seo-flow-page" data-cms-page="ai-schema">
        <div class="panel-head">
          <div>
            <p>SEO Automation Map</p>
            <h2>Alur Skema SEO</h2>
          </div>
          <span id="seoFlowState" class="ai-state waiting"><span></span>Belum ada skema</span>
        </div>
        <div class="seo-flow-editor">
          <div class="seo-flow-input-pane">
            <div class="seo-flow-input-head">
              <div>
                <label for="seoFlowInput">Data Redirect</label>
                <small>Manual, TXT, atau CSV</small>
              </div>
              <label class="download-button subtle seo-flow-import" for="seoFlowFile">Import Data</label>
              <input id="seoFlowFile" type="file" accept=".txt,.csv,text/plain,text/csv" hidden>
            </div>
            <textarea id="seoFlowInput" rows="11" placeholder="domain1.com 301 ke domainb.com&#10;domain2.com 301 ke domainb.com"></textarea>
            <div id="seoFlowStatus" class="status">Masukkan data redirect untuk membuat skema.</div>
            <div class="seo-flow-input-actions">
              <button class="primary" id="generateSeoFlow" type="button">Buat Skema</button>
              <button class="secondary" id="loadSeoFlowExample" type="button">Contoh</button>
              <button class="secondary" id="clearSeoFlow" type="button">Bersihkan</button>
            </div>
          </div>

          <div class="seo-flow-visual-pane">
            <div class="seo-flow-toolbar">
              <div class="seo-flow-stats" aria-label="Statistik skema redirect">
                <span><strong id="seoFlowNodeCount">0</strong> domain</span>
                <span><strong id="seoFlowEdgeCount">0</strong> redirect</span>
                <span><strong id="seoFlowTargetCount">0</strong> target</span>
              </div>
              <div class="seo-flow-controls">
                <button type="button" id="seoFlowZoomOut" aria-label="Perkecil diagram" title="Perkecil">-</button>
                <button type="button" id="seoFlowZoomReset" aria-label="Reset zoom" title="Reset zoom">100%</button>
                <button type="button" id="seoFlowZoomIn" aria-label="Perbesar diagram" title="Perbesar">+</button>
                <select id="seoFlowExportFormat" class="seo-flow-export-format" aria-label="Pilih format export">
                  <option value="png">PNG Diagram</option>
                  <option value="xlsx">Excel Data (.xlsx)</option>
                </select>
                <button class="secondary" type="button" id="exportSeoFlow">Export</button>
              </div>
            </div>
            <div id="seoFlowCanvas" class="seo-flow-canvas">
              <div id="seoFlowEmpty" class="seo-flow-empty">
                <span class="ai-empty-mark">301</span>
                <h3>Skema redirect belum dibuat</h3>
                <p>Relasi antar-domain akan divisualisasikan di area ini.</p>
              </div>
              <svg id="seoFlowSvg" role="img" aria-label="Diagram redirect SEO" hidden></svg>
            </div>
          </div>
        </div>
      </section>

      <section class="panel page-panel" data-cms-page="results">
        <div class="panel-head">
          <div>
            <p>Generated Output</p>
            <h2>Hasil Landing Page</h2>
          </div>
          <div class="result-actions">
            <a class="download-button subtle" href="/generated/domain.txt" target="_blank" rel="noreferrer">domain.txt</a>
            <a class="download-button" href="/export/all.zip">Export ZIP</a>
          </div>
        </div>
        <div id="resultsList" class="result-list"></div>
        <div class="output">
          <h2>History Generate</h2>
          <div id="historyList" class="history-list"></div>
        </div>
      </section>

      <section class="panel page-panel finishing-page" data-cms-page="finishing">
        <div class="panel-head">
          <div>
            <p>Publication Gate</p>
            <h2>Finishing & Audit</h2>
          </div>
          <button class="primary" id="refreshFinishing" type="button">Analisa Semua</button>
        </div>
        <p class="field-hint">Setiap hasil generate wajib diperiksa di sini. Hanya hasil yang sudah Anda setujui yang masuk ke Hasil Landing Page dan Export ZIP.</p>
        <div class="finishing-layout">
          <aside>
            <div class="finishing-queue-head">
              <strong>Menunggu Pemeriksaan</strong>
              <span id="finishingQueueCount">0</span>
            </div>
            <div id="finishingList" class="finishing-list"></div>
          </aside>
          <div id="finishingDetail" class="finishing-detail">
            <div class="status">Pilih domain dari antrean untuk membuka laporan audit.</div>
          </div>
        </div>
      </section>
    </main>
  </div>
  <script src="/public/app.js"></script>
</body>
</html>
"""


class AdminSEOHandler(SimpleHTTPRequestHandler):
    server_version = "AdminSEO/1.0"

    def do_GET(self) -> None:
        parsed = urlparse(self.path)
        user = self.current_user()
        if parsed.path == "/login":
            if user:
                self.redirect("/")
                return
            success = "Password berhasil diperbarui. Silakan login kembali." if parse_qs(parsed.query).get("changed") == ["1"] else ""
            self.send_html(login_html(success=success))
            return
        if parsed.path == "/account/security":
            if not user:
                self.redirect("/login")
                return
            self.send_html(account_security_html(str(user["username"])))
            return
        if parsed.path == "/pembuatan-admin":
            if not user:
                self.redirect("/login")
                return
            if str(user["username"]) != DEFAULT_USERNAME:
                self.send_error(HTTPStatus.NOT_FOUND, "Halaman tidak ditemukan.")
                return
            self.send_html(create_admin_html())
            return
        page_routes = {
            "/": "domains",
            "/admin": "domains",
            "/domains": "domains",
            "/batch": "batch",
            "/workflow": "workflow",
            "/media": "media",
            "/alternate": "alternate",
            "/sitemap": "sitemap",
            "/ai/konek-api": "ai-api",
            "/ai/analytic-seo": "ai-analytics",
            "/ai/alur-skema-seo": "ai-schema",
            "/finishing": "finishing",
            "/results": "results",
        }
        if parsed.path in page_routes:
            if not user:
                self.redirect("/login")
                return
            self.send_html(index_html(page_routes[parsed.path], str(user["username"])))
            return
        if parsed.path == "/api/projects":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({
                "projects": list_projects(user_id),
                "templates": template_menu_options(),
                "amp_templates": amp_template_menu_options(),
            })
            return
        if parsed.path == "/api/ai/connection":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({"connection": public_ai_connection(user_id)})
            return
        if parsed.path == "/api/ai/seo-flow/export.xlsx":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            try:
                workbook = export_seo_flow_xlsx(user_id)
            except ValueError as exc:
                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
                return
            self.send_bytes(
                workbook,
                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                "alur-skema-seo.xlsx",
            )
            return
        if parsed.path == "/api/ai/seo-flow":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({"schema": load_seo_flow_schema(user_id)})
            return
        if parsed.path == "/api/media":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({"media": list_media(user_id)})
            return
        if parsed.path == "/api/media-groups":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({"groups": list_media_groups(user_id)})
            return
        if parsed.path == "/api/results":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_json({"projects": generated_projects(user_id), "history": generation_history(user_id)})
            return
        if parsed.path == "/api/finishing":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            projects = pending_finishing_projects(user_id)
            self.send_json({"projects": projects, "count": len(projects)})
            return
        if parsed.path == "/export/all.zip":
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.send_bytes(export_generated_zip(user_id), "application/zip", "adminseo-landing-pages.zip")
            return
        if parsed.path.startswith("/public/"):
            self.serve_file(PUBLIC_DIR, parsed.path.removeprefix("/public/"))
            return
        if parsed.path.startswith("/uploads/"):
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            stored_name = Path(unquote(parsed.path.removeprefix("/uploads/"))).name
            with db() as connection:
                owned = connection.execute(
                    "SELECT id FROM media_assets WHERE stored_name = ? AND user_id = ?",
                    (stored_name, user_id),
                ).fetchone()
            if not owned:
                self.send_error(HTTPStatus.NOT_FOUND, "Media tidak ditemukan.")
                return
            self.serve_file(UPLOAD_DIR, parsed.path.removeprefix("/uploads/"))
            return
        if parsed.path.startswith("/generated/"):
            if not self.require_auth():
                return
            user_id = int(self.current_user()["id"])
            self.serve_file(generated_user_dir(user_id), parsed.path.removeprefix("/generated/"))
            return
        self.send_error(HTTPStatus.NOT_FOUND, "Halaman tidak ditemukan.")

    def do_POST(self) -> None:
        parsed = urlparse(self.path)
        try:
            if parsed.path == "/login":
                client_key = self.login_client_key()
                if login_is_rate_limited(client_key):
                    self.send_html(
                        login_html("Terlalu banyak percobaan login. Tunggu 15 menit lalu coba kembali."),
                        HTTPStatus.TOO_MANY_REQUESTS,
                    )
                    return
                payload = self.read_payload()
                user = authenticate(str(payload.get("username", "")), str(payload.get("password", "")))
                if not user:
                    record_login_failure(client_key)
                    self.send_html(login_html("Username atau password salah."), HTTPStatus.UNAUTHORIZED)
                    return
                clear_login_failures(client_key)
                token, expires_at = create_session(int(user["id"]))
                self.redirect("/", cookie=self.session_cookie(token, expires_at))
                return

            if parsed.path == "/logout":
                destroy_session(self.session_token())
                self.redirect("/login", cookie=self.expired_session_cookie())
                return

            if parsed.path == "/account/security":
                user = self.current_user()
                if not user:
                    self.redirect("/login")
                    return
                payload = self.read_payload()
                try:
                    change_user_password(
                        int(user["id"]),
                        str(payload.get("current_password", "")),
                        str(payload.get("new_password", "")),
                        str(payload.get("confirmation", "")),
                    )
                except ValueError as exc:
                    self.send_html(
                        account_security_html(str(user["username"]), error=str(exc)),
                        HTTPStatus.BAD_REQUEST,
                    )
                    return
                self.redirect(
                    "/login?changed=1",
                    cookie=self.expired_session_cookie(),
                )
                return

            if parsed.path == "/pembuatan-admin":
                user = self.current_user()
                if not user:
                    self.redirect("/login")
                    return
                if str(user["username"]) != DEFAULT_USERNAME:
                    self.send_error(HTTPStatus.NOT_FOUND, "Halaman tidak ditemukan.")
                    return
                payload = self.read_payload()
                try:
                    account = create_user_account(
                        str(payload.get("username", "")),
                        str(payload.get("password", "")),
                    )
                except ValueError as exc:
                    self.send_html(create_admin_html(error=str(exc)), HTTPStatus.BAD_REQUEST)
                    return
                self.send_html(
                    create_admin_html(success=f"Akun {account['username']} berhasil dibuat."),
                    HTTPStatus.CREATED,
                )
                return

            if not self.require_auth():
                return
            current_user = self.current_user()
            if not current_user:
                return
            user_id = int(current_user["id"])

            if parsed.path == "/api/ai/connection":
                self.send_json(
                    {"connection": save_ai_connection(user_id, self.read_payload())},
                    HTTPStatus.CREATED,
                )
                return

            if parsed.path == "/api/ai/connection/test":
                self.send_json(test_ai_connection(user_id, self.read_payload()))
                return

            if parsed.path == "/api/ai/seo-flow":
                payload = self.read_payload()
                self.send_json({
                    "schema": save_seo_flow_schema(user_id, str(payload.get("source_text") or ""))
                })
                return

            if parsed.path == "/api/projects":
                self.send_json({"project": save_project(self.read_payload(), user_id)}, HTTPStatus.CREATED)
                return

            if parsed.path == "/api/projects/batch-generate":
                self.send_json(batch_generate(self.read_payload(), user_id), HTTPStatus.CREATED)
                return

            if parsed.path == "/api/workflow/starter":
                self.send_json(run_workflow_starter(self.read_payload(), user_id), HTTPStatus.CREATED)
                return

            if parsed.path == "/api/media":
                content_type = self.headers.get("Content-Type", "")
                if "multipart/form-data" not in content_type:
                    raise ValueError("Upload gambar harus memakai multipart/form-data.")
                length = int(self.headers.get("Content-Length", "0") or "0")
                if length <= 0 or length > MAX_UPLOAD_BODY_BYTES:
                    raise ValueError("Ukuran total upload tidak valid atau melebihi batas 32 MB.")
                body = self.rfile.read(length)
                files = parse_multipart_upload(body, content_type)
                self.send_json({"media": save_uploaded_media(files, user_id)}, HTTPStatus.CREATED)
                return

            if parsed.path == "/api/media-groups":
                self.send_json({"group": save_media_group(self.read_payload(), user_id)}, HTTPStatus.CREATED)
                return

            finishing_match = re.fullmatch(r"/api/projects/(\d+)/(reanalyze|approve)", parsed.path)
            if finishing_match:
                project_id = int(finishing_match.group(1))
                if finishing_match.group(2) == "reanalyze":
                    self.send_json(reanalyze_project(project_id, user_id))
                else:
                    payload = self.read_payload()
                    confirmed = payload.get("manual_confirmation") in {True, "true", "1", 1, "on"}
                    self.send_json(approve_project(project_id, confirmed, user_id))
                return

            match = re.fullmatch(r"/api/projects/(\d+)/(generate|sitemap|robots)", parsed.path)
            if match:
                project = load_project(int(match.group(1)), user_id)
                if not project:
                    self.send_json({"error": "Project tidak ditemukan."}, HTTPStatus.NOT_FOUND)
                    return
                action = {"generate": "all", "sitemap": "sitemap", "robots": "robots"}[match.group(2)]
                self.send_json(write_generated_file(project, action))
                return

            self.send_error(HTTPStatus.NOT_FOUND, "Endpoint tidak ditemukan.")
        except ValueError as exc:
            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
        except sqlite3.IntegrityError as exc:
            self.send_json({"error": f"Data tidak valid: {exc}"}, HTTPStatus.BAD_REQUEST)

    def do_DELETE(self) -> None:
        parsed = urlparse(self.path)
        try:
            if not self.require_auth():
                return
            current_user = self.current_user()
            if not current_user:
                return
            user_id = int(current_user["id"])

            if parsed.path == "/api/ai/connection":
                delete_ai_connection(user_id)
                self.send_json({"deleted": True})
                return

            if parsed.path == "/api/ai/seo-flow":
                delete_seo_flow_schema(user_id)
                self.send_json({"deleted": True})
                return

            match = re.fullmatch(r"/api/media/(\d+)", parsed.path)
            if match:
                media = delete_media_asset(int(match.group(1)), user_id)
                self.send_json({"deleted": media})
                return

            self.send_error(HTTPStatus.NOT_FOUND, "Endpoint tidak ditemukan.")
        except ValueError as exc:
            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
        except sqlite3.IntegrityError as exc:
            self.send_json({"error": f"Data tidak valid: {exc}"}, HTTPStatus.BAD_REQUEST)

    def read_payload(self) -> dict[str, Any]:
        length = int(self.headers.get("Content-Length", "0") or "0")
        if length < 0 or length > MAX_FORM_BODY_BYTES:
            raise ValueError("Ukuran request melebihi batas yang diizinkan.")
        body = self.rfile.read(length).decode("utf-8")
        content_type = self.headers.get("Content-Type", "")
        if "application/json" in content_type:
            return json.loads(body or "{}")
        return {key: values[-1] for key, values in parse_qs(body).items()}

    def login_client_key(self) -> str:
        cloudflare_ip = self.headers.get("CF-Connecting-IP", "").strip()
        if cloudflare_ip:
            return cloudflare_ip[:80]
        return str(self.client_address[0])[:80]

    def session_token(self) -> str | None:
        cookie_header = self.headers.get("Cookie", "")
        cookies = SimpleCookie()
        cookies.load(cookie_header)
        morsel = cookies.get(SESSION_COOKIE)
        return morsel.value if morsel else None

    def current_user(self) -> sqlite3.Row | None:
        token = self.session_token()
        if not token:
            return None
        with db() as connection:
            cleanup_sessions(connection)
            return connection.execute(
                """
                SELECT users.*
                FROM sessions
                JOIN users ON users.id = sessions.user_id
                WHERE sessions.token_hash = ?
                  AND sessions.expires_at > ?
                """,
                (token_hash(token), utc_now()),
            ).fetchone()

    def require_auth(self) -> bool:
        if self.current_user():
            return True
        accepts_html = "text/html" in self.headers.get("Accept", "")
        if accepts_html:
            self.redirect("/login")
        else:
            self.send_json({"error": "Login diperlukan."}, HTTPStatus.UNAUTHORIZED)
        return False

    def request_is_https(self) -> bool:
        forwarded_proto = self.headers.get("X-Forwarded-Proto", "").split(",", 1)[0].strip().lower()
        return FORCE_SECURE_COOKIE or forwarded_proto == "https"

    def send_security_headers(self, content_security_policy: bool = False) -> None:
        self.send_header("X-Content-Type-Options", "nosniff")
        self.send_header("X-Frame-Options", "SAMEORIGIN")
        self.send_header("Referrer-Policy", "same-origin")
        self.send_header("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
        if self.request_is_https():
            self.send_header("Strict-Transport-Security", "max-age=15552000")
        if content_security_policy:
            self.send_header(
                "Content-Security-Policy",
                "default-src 'self'; img-src 'self' data: blob:; style-src 'self' 'unsafe-inline'; "
                "script-src 'self'; connect-src 'self'; frame-src 'self'; object-src 'none'; "
                "base-uri 'self'; form-action 'self'; frame-ancestors 'self'",
            )

    def session_cookie(self, token: str, expires_at: str) -> str:
        expires = datetime.fromisoformat(expires_at).strftime("%a, %d %b %Y %H:%M:%S GMT")
        secure = "; Secure" if self.request_is_https() else ""
        return f"{SESSION_COOKIE}={token}; Path=/; HttpOnly; SameSite=Lax; Expires={expires}{secure}"

    def expired_session_cookie(self) -> str:
        secure = "; Secure" if self.request_is_https() else ""
        return f"{SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0{secure}"

    def serve_file(self, root: Path, requested: str) -> None:
        path = (root / unquote(requested)).resolve()
        try:
            path.relative_to(root.resolve())
        except ValueError:
            self.send_error(HTTPStatus.FORBIDDEN, "Akses file ditolak.")
            return
        if not path.is_file():
            self.send_error(HTTPStatus.NOT_FOUND, "File tidak ditemukan.")
            return
        self.path = str(path)
        self.send_response(HTTPStatus.OK)
        self.send_header("Content-Type", self.guess_type(str(path)))
        self.send_header("Content-Length", str(path.stat().st_size))
        self.end_headers()
        with path.open("rb") as source:
            self.copyfile(source, self.wfile)

    def send_html(self, content: str, status: HTTPStatus = HTTPStatus.OK) -> None:
        encoded = content.encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(encoded)))
        self.send_header("Cache-Control", "no-store")
        self.send_security_headers(content_security_policy=True)
        self.end_headers()
        self.wfile.write(encoded)

    def send_json(self, payload: dict[str, Any], status: HTTPStatus = HTTPStatus.OK) -> None:
        encoded = json.dumps(payload, ensure_ascii=False).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(encoded)))
        self.send_header("Cache-Control", "no-store")
        self.send_security_headers()
        self.end_headers()
        self.wfile.write(encoded)

    def send_bytes(self, payload: bytes, content_type: str, filename: str) -> None:
        self.send_response(HTTPStatus.OK)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(len(payload)))
        self.send_header("Content-Disposition", f'attachment; filename="{filename}"')
        self.send_header("Cache-Control", "no-store")
        self.send_security_headers()
        self.end_headers()
        self.wfile.write(payload)

    def redirect(self, location: str, cookie: str | None = None) -> None:
        self.send_response(HTTPStatus.SEE_OTHER)
        self.send_header("Location", location)
        if cookie:
            self.send_header("Set-Cookie", cookie)
        self.send_header("Cache-Control", "no-store")
        self.send_security_headers()
        self.end_headers()

    def log_message(self, format: str, *args: Any) -> None:
        print(f"[{datetime.now().strftime('%H:%M:%S')}] {self.address_string()} {format % args}")


def main() -> None:
    parser = argparse.ArgumentParser(description="AdminSEO Landing Page Generator")
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=8098)
    args = parser.parse_args()

    init_db()
    PUBLIC_DIR.mkdir(parents=True, exist_ok=True)
    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)

    httpd = ThreadingHTTPServer((args.host, args.port), AdminSEOHandler)
    print(f"AdminSEO berjalan di http://{args.host}:{args.port}")
    httpd.serve_forever()


if __name__ == "__main__":
    main()
