"""سئوی سمت سرور — robots.txt، sitemap.xml، llms.txt و سرو همهٔ صفحات با متای تزریقی.

فرانت‌اند یک SPA است؛ خزنده‌های جست‌وجو و شبکه‌های اجتماعی جاوااسکریپت اجرا نمی‌کنند.
این ماژول همان index.html بیلد فرانت‌اند را می‌خواند و پیش از ارسال، تگ‌های
title / description / canonical / OG / hreflang / JSON-LD را از دیتابیس داخل آن تزریق می‌کند —
بازدیدکننده‌های عادی همان SPA همیشگی را می‌بینند و خزنده‌ها متای درست را در HTML اولیه می‌خوانند.
(اسکیمای صفحه داخل <script id="seo-jsonld"> تزریق می‌شود؛ همان اسکریپتی که سمت مرورگر
بعد از هیدریشن بازنویسی می‌شود — پس نسخهٔ تکراری ساخته نمی‌شود. اسکیمای Organization
جداگانه و پایدار تزریق می‌شود و سمت مرورگر دست نمی‌خورد.)

دو زبانه بودن: نسخه فارسی روی مسیرهای اصلی و نسخه انگلیسی روی /en/... سرو می‌شود.
لینک‌های alternate (هم در head و هم در sitemap) فقط وقتی اعلام می‌شوند که ترجمهٔ
انگلیسی واقعاً وجود داشته باشد — وگرنه گوگل محتوای فارسی را با برچسب «en» می‌بیند
و مجموعهٔ hreflang ناسازگار می‌شود. صفحهٔ انگلیسیِ ترجمه‌نشده برای بازدیدکننده سرو
می‌شود ولی هیچ ادعای hreflang ندارد.

حالت پیش‌نمایش (PREVIEW_MODE=on): robots.txt همه‌چیز را می‌بندد، sitemap خالی است
و llms.txt با کد ۴۰۴ پاسخ می‌دهد — هیچ نشانی‌ای از سایت خصوصی بیرون درز نمی‌کند.
"""

import hashlib
import html
import io
import json
import re
import urllib.parse
import zipfile
from datetime import date, datetime, timezone
from functools import lru_cache
from pathlib import Path
from urllib.parse import quote

from fastapi import APIRouter, Depends, Response
from fastapi.encoders import jsonable_encoder
from fastapi.responses import HTMLResponse, RedirectResponse
from sqlalchemy.orm import Session

from . import models
from .api.public import build_site_payload
from .config import settings
from .database import get_db

router = APIRouter()

STATIC_PATHS = ["/", "/about", "/services", "/projects", "/investment", "/blog", "/faq", "/contact"]
# صفحاتی که متای آن‌ها از seo_meta خوانده می‌شود — کلید همان page_key است
META_KEYS = ["home", "about", "services", "projects", "investment", "blog", "faq", "contact"]
FALLBACK_FA_BRAND = "گروه ساختمانی آرامش"
FALLBACK_EN_BRAND = "Aramesh Construction Group"
# تصویر پیش‌فرض شبکه‌های اجتماعی — در frontend/public بیلد می‌شود
DEFAULT_OG_IMAGE = "/og-default.jpg"
DEFAULT_OG_SIZE = (1200, 630)
# مختصات دفتر مرکزی (اصفهان، ملاصدرا شمالی) — همان مقدار فرانت‌اند
# (frontend/src/data/mapProjects.ts: OFFICE_LOCATION)؛ در اسکیمای LocalBusiness
# به geo و hasMap تبدیل می‌شود. دو مقدار باید همیشه یکی بمانند.
OFFICE_GEO = (32.61764688216492, 51.666306342927214)
OFFICE_MAPS_URL = f"https://www.google.com/maps/search/?api=1&query={OFFICE_GEO[0]},{OFFICE_GEO[1]}"
# کلید IndexNow — اثبات مالکیت برای اعلام فوری نشانی‌های سایت به Bing/Copilot و
# موتورهای مشارکت‌کننده در پروتکل (فایل در /.well-known/indexnow-key.txt سرو می‌شود)
INDEXNOW_KEY = "daa4488a8e2905312b5efd02ad5fc614"
# خزنده‌های هوش مصنوعی جست‌وجو/ارجاع — سیاست صریح «مجاز» تا قالب‌های پیش‌فرض
# «بستن همه‌چیز» اتفاقی آن‌ها را نبندند (GPTBot آموزش است، OAI-SearchBot ارجاع چت‌جی‌پی‌تی)
AI_SEARCH_BOTS = [
    "GPTBot",
    "OAI-SearchBot",
    "ChatGPT-User",
    "ClaudeBot",
    "Claude-SearchBot",
    "PerplexityBot",
    "Perplexity-User",
    "Google-Extended",
    "Applebot-Extended",
]


def _absolute(path: str) -> str:
    if not path:
        return ""
    if path.startswith(("http://", "https://")):
        return path
    site = settings.site_url.rstrip("/")
    return f"{site}{path}" if site else path


def _en_path(path: str) -> str:
    """مسیر انگلیسی معادل یک مسیر فارسی — / و /en یکدیگرند."""
    return "/en" if path == "/" else f"/en{path}"


def _fa_path(path: str) -> str:
    """مسیر فارسی معادل یک مسیر انگلیسی."""
    if path == "/en":
        return "/"
    return path[3:] if path.startswith("/en/") else path


def _url_escape(url: str) -> str:
    """درصدگذاری نویسه‌های غیر-ASCII و ناامن (اسلاگ‌های فارسی، فاصله و «?» در
    اسلاگ انگلیسی) — استاندارد sitemap و IndexNow. ? و # عمداً «امن» نیستند:
    در اسلاگِ خام، شروع query/fragment می‌شوند و URL را می‌شکنند."""
    return quote(url, safe=":/[]@!$&'()*+,;=")


def _clip(text: str, limit: int) -> str:
    """برش متن به طول مشخص برای توضیح‌های تک‌خطی (llms.txt)."""
    text = " ".join((text or "").split())
    return text[:limit] + ("…" if len(text) > limit else "")


# ---------- تاریخ مقاله — ISO میلادی یا شمسی دست‌نویس → ISO برای datePublished ----------

_FA_DIGITS = str.maketrans("۰۱۲۳۴۵۶۷۸۹", "0123456789")
_FA_MONTHS = {
    "فروردین": 1, "اردیبهشت": 2, "خرداد": 3, "تیر": 4, "مرداد": 5, "شهریور": 6,
    "مهر": 7, "آبان": 8, "آذر": 9, "دی": 10, "بهمن": 11, "اسفند": 12,
}


def _jalali_to_gregorian(jy: int, jm: int, jd: int) -> tuple[int, int, int]:
    """تبدیل تاریخ جلالی به میلادی — الگوریتم استاندارد jalaali."""
    jy += 1595
    days = -355668 + (365 * jy) + ((jy // 33) * 8) + (((jy % 33) + 3) // 4) + jd
    days += (jm - 1) * 31 if jm < 7 else ((jm - 7) * 30) + 186
    gy = 400 * (days // 146097)
    days %= 146097
    if days > 36524:
        days -= 1
        gy += 100 * (days // 36524)
        days %= 36524
        if days >= 365:
            days += 1
    gy += 4 * (days // 1461)
    days %= 1461
    if days > 365:
        gy += (days - 1) // 365
        days = (days - 1) % 365
    gd = days + 1
    leap = (gy % 4 == 0 and gy % 100 != 0) or (gy % 400 == 0)
    for gm, md in enumerate([31, 29 if leap else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], start=1):
        if gd <= md:
            return gy, gm, gd
        gd -= md
    return gy, 12, 31


def _parse_site_date(value: str | None) -> str | None:
    """تاریخ مقاله → ISO (YYYY-MM-DD) برای datePublished اسکیما؛ تاریخ نامفهوم → None.
    هم ISO میلادی (خروجی انتخابگر تاریخ پنل) و هم شمسی دست‌نویس («۲۴ مرداد ۱۴۰۳») را می‌فهمد."""
    raw = (value or "").strip().translate(_FA_DIGITS)
    if not raw:
        return None
    try:
        return datetime.fromisoformat(raw).date().isoformat()
    except ValueError:
        pass
    m = re.fullmatch(r"(\d{1,2})\s*([\u0600-\u06FF]+)\s*(\d{4})", raw)
    if m and m.group(2) in _FA_MONTHS:
        gy, gm, gd = _jalali_to_gregorian(int(m.group(3)), _FA_MONTHS[m.group(2)], int(m.group(1)))
        return date(gy, gm, gd).isoformat()
    return None


def _iso_stamp(value: datetime | None) -> str | None:
    """زمان سیستمی رکورد → W3C Datetime (UTC) برای <lastmod> نقشه سایت.
    None یعنی آخرین تغییر رکورد ثبت نشده و lastmod صادر نمی‌شود."""
    if value is None:
        return None
    return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S+00:00")


# ---------- alternates — فقط وقتی ترجمهٔ انگلیسی واقعاً وجود دارد ----------


def _alternate_pairs(
    path: str,
    lang: str,
    has_en: bool,
    fa_override: str = "",
    en_override: str = "",
) -> list[tuple[str, str]]:
    """جفت‌های (hreflang، href) یک صفحه — مبنای مشترک head و sitemap.
    صفحهٔ انگلیسیِ ترجمه‌نشده هیچ ادعایی ندارد (لیست خالی). مقاله‌ها می‌توانند
    در دو زبان اسلاگ متفاوت داشته باشند؛ overrideها همان نشانی واقعی‌اند."""
    fa = fa_override or (path if lang == "fa" else _fa_path(path))
    if lang == "en" and not has_en:
        return []
    # نشانی‌ها خام برمی‌گردند — درصدگذاری URL با مصرف‌کننده است
    # (_alternates برای head و url_entry برای sitemap)
    pairs = [("fa", _absolute(fa)), ("x-default", _absolute(fa))]
    if has_en:
        en = en_override or (_en_path(path) if lang == "fa" else path)
        pairs.insert(1, ("en", _absolute(en)))
    return pairs


def _alternates(path: str, lang: str, has_en: bool = True, fa_override: str = "", en_override: str = "") -> str:
    """تگ‌های link alternate برای head — از همان جفت‌های sitemap (درصدگذاری اینجا)."""
    pairs = _alternate_pairs(path, lang, has_en, fa_override, en_override)
    return "\n    ".join(
        f'<link rel="alternate" hreflang="{lang_code}" href="{html.escape(_url_escape(href_))}" />'
        for lang_code, href_ in pairs
    )


def _article_has_en(article: models.Article) -> bool:
    """آیا ترجمهٔ انگلیسی واقعی برای مقاله ثبت شده است؟"""
    if (article.title_en or "").strip() or (article.excerpt_en or "").strip():
        return True
    return bool(isinstance(article.body_en, dict) and (article.body_en.get("content") or []))


def _project_has_en(project: models.Project) -> bool:
    return bool((project.title_en or "").strip() or (project.summary_en or "").strip())


# ---------- پوستهٔ HTML با متای تزریقی ----------


def _read_index() -> str | None:
    try:
        return (Path(settings.frontend_dist) / "index.html").read_text(encoding="utf-8")
    except OSError:
        return None


@lru_cache(maxsize=1)
def _default_og() -> str:
    """تصویر پیش‌فرض OG — فقط وقتی فایل واقعاً در بیلد فرانت‌اند باشد."""
    if (Path(settings.frontend_dist) / DEFAULT_OG_IMAGE.lstrip("/")).is_file():
        return _absolute(DEFAULT_OG_IMAGE)
    return ""


def _doc_text(doc: object, limit: int = 300) -> str:
    """متن ساده سند TipTap — برای noscript و پیش‌نمایش."""
    words: list[str] = []

    def walk(node: object) -> None:
        if not isinstance(node, dict):
            return
        if node.get("type") == "text" and isinstance(node.get("text"), str):
            words.append(node["text"])
        for child in node.get("content") or []:
            walk(child)

    if isinstance(doc, dict):
        for block in doc.get("content") or []:
            walk(block)
    text = " ".join(words).strip()
    return text[:limit] + ("…" if len(text) > limit else "")


def _site_json(db: Session) -> str:
    """محتوای کامل سایت به‌صورت JSON برای تزریق داخل HTML (window.__SITE__).
    فرانت‌اند با همین داده بدون انتظار برای XHR رندر می‌شود — خزنده‌های رندرکننده
    (گوگل) هیچ‌وقت در پنجرهٔ «در حال بارگذاری» صفحهٔ نیمه‌خالی نمی‌بینند."""
    payload = jsonable_encoder(build_site_payload(db))
    data = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
    # امن‌سازی درج در HTML: توالی بستن اسکریپت و کامنت HTML نباید در داده ظاهر شود
    return data.replace("</", "<\\/").replace("<!--", "<\\u0021--")


def _shell(
    *,
    title: str,
    description: str,
    path: str,
    lang: str = "fa",
    has_en: bool = True,
    # نشانی‌های override برای مقاله‌هایی که دو زبان اسلاگ متفاوت دارند —
    # پیش‌فرض همان مسیر با پیشوند /en است (اسلاگ مشترک)
    alt_fa: str = "",
    alt_en: str = "",
    og_image: str = "",
    og_image_alt: str = "",
    og_type: str = "website",
    jsonld: dict | list | None = None,
    org_jsonld: dict | None = None,
    noscript: str = "",
    status_code: int = 200,
    noindex: bool = False,
    db: Session | None = None,
) -> HTMLResponse:
    """index.html فرانت‌اند با متای تزریقی؛ اگر بیلد در دسترس نبود، صفحه حداقلی."""
    title = title.strip() or (FALLBACK_EN_BRAND if lang == "en" else FALLBACK_FA_BRAND)
    description = description.strip()
    canonical = _url_escape(_absolute(path))
    esc = html.escape
    alternates = _alternates(path, lang, has_en, alt_fa, alt_en)

    # تصویر OG — تصویر اختصاصی صفحه یا تصویر پیش‌فرض برند
    custom_image = (og_image or "").strip()
    image = _absolute(custom_image) if custom_image else _default_og()
    image_is_default = not custom_image and bool(_default_og())

    tags = []
    if noindex:
        # صفحهٔ انگلیسی بدون ترجمهٔ واقعی — همان محتوای فارسی زیر نشانی /en است؛
        # به گوگل صریح می‌گوییم ایندکس نکند (برای کاربر عادی سالم می‌ماند و
        # به‌محض اضافه‌شدن ترجمه، خودکار برمی‌گردد)
        tags.append('<meta name="robots" content="noindex, follow" />')
    tags += [
        f'<link rel="canonical" href="{esc(canonical)}" />',
        f'<meta name="description" content="{esc(description)}" />',
        f'<meta property="og:title" content="{esc(title)}" />',
        f'<meta property="og:description" content="{esc(description)}" />',
        f'<meta property="og:type" content="{esc(og_type)}" />',
        f'<meta property="og:url" content="{esc(canonical)}" />',
        f'<meta property="og:locale" content="{"en_US" if lang == "en" else "fa_IR"}" />',
        f'<meta property="og:locale:alternate" content="{"fa_IR" if lang == "en" else "en_US"}" />',
        f'<meta name="twitter:card" content="summary_large_image" />',
        f'<meta name="twitter:title" content="{esc(title)}" />',
        f'<meta name="twitter:description" content="{esc(description)}" />',
    ]
    if image:
        tags.append(f'<meta property="og:image" content="{esc(image)}" />')
        tags.append(f'<meta name="twitter:image" content="{esc(image)}" />')
        tags.append(f'<meta property="og:image:alt" content="{esc(og_image_alt.strip() or title)}" />')
        if image_is_default:
            tags.append(f'<meta property="og:image:width" content="{DEFAULT_OG_SIZE[0]}" />')
            tags.append(f'<meta property="og:image:height" content="{DEFAULT_OG_SIZE[1]}" />')
    if jsonld:
        payload = json.dumps(jsonld, ensure_ascii=False).replace("</", "<\\/")
        # id="seo-jsonld" — سمت مرورگر همان اسکریپت بازنویسی می‌شود، نه اینکه تکراری ساخته شود
        tags.append(f'<script type="application/ld+json" id="seo-jsonld">{payload}</script>')
    if org_jsonld:
        payload = json.dumps(org_jsonld, ensure_ascii=False).replace("</", "<\\/")
        tags.append(f'<script type="application/ld+json" id="seo-org-jsonld">{payload}</script>')
    if db is not None:
        # دادهٔ کامل سایت داخل HTML — اولین رندر بدون انتظار برای درخواست /api/site
        tags.append(f"<script>window.__SITE__={_site_json(db)};</script>")
    block = "\n    ".join(tags)

    raw = _read_index()
    if raw is None:
        # بیلد فرانت‌اند سوار نشده — صفحه حداقلی با خودِ متا تا خزنده‌ها دست خالی نمانند
        lang_attr = 'lang="en" dir="ltr"' if lang == "en" else 'lang="fa" dir="rtl"'
        body = f"<h1>{esc(title)}</h1><p>{esc(description)}</p>"
        return HTMLResponse(
            f'<!doctype html><html {lang_attr}><head><meta charset="utf-8">'
            f"<title>{esc(title)}</title>{alternates}{block}</head><body>{body}</body></html>",
            status_code=status_code,
            headers={"Cache-Control": "no-store"},
        )

    # اسکیمای Organization مینیمالِ پوستهٔ استاتیک حذف می‌شود تا با نسخهٔ غنی تزریقی تکراری نشود
    if org_jsonld:
        raw = re.sub(r'<script type="application/ld\+json">[^<]*</script>', "", raw, count=1)
    if lang == "en":
        # پوسته بیلدشده فارسی است — برای نسخه انگلیسی جهت، زبان و برند سند عوض می‌شود
        raw = re.sub(r'<html[^>]*>', '<html lang="en" dir="ltr">', raw, count=1)
        raw = raw.replace(FALLBACK_FA_BRAND, FALLBACK_EN_BRAND)
    # description استاتیک حذف می‌شود تا با متای تزریقی تکراری نشود
    raw = re.sub(r'<meta name="description"[^>]*/>\s*', '', raw, count=1)
    # og:locale — در پوسته استاتیک به‌روز می‌شود و از بلوک تزریقی حذف تا دوباره نوشته نشود
    og_locale = "en_US" if lang == "en" else "fa_IR"
    if re.search(r'<meta property="og:locale"', raw):
        raw = re.sub(
            r'(<meta property="og:locale" content=")[^"]*(")',
            lambda m: f'{m.group(1)}{og_locale}{m.group(2)}',
            raw,
            count=1,
        )
        tags = [t for t in tags if 'og:locale' not in t]
        block = "\n    ".join(tags)
    raw = re.sub(r"<title>.*?</title>", f"<title>{esc(title)}</title>", raw, count=1, flags=re.S)
    raw = raw.replace("</head>", f"    {alternates}\n    {block}\n  </head>", 1)
    if noscript:
        raw = raw.replace("</body>", f"<noscript>{noscript}</noscript>\n  </body>", 1)
    return HTMLResponse(raw, status_code=status_code, headers={"Cache-Control": "no-store"})


# ---------- موجودیت‌های ساخت‌یافته (JSON-LD) ----------


def _brand_row(db: Session) -> models.Brand | None:
    return db.query(models.Brand).first()


def _brand_name(db: Session, lang: str = "fa") -> str:
    brand = _brand_row(db)
    if brand is None:
        return FALLBACK_EN_BRAND if lang == "en" else FALLBACK_FA_BRAND
    if lang == "en":
        return brand.name_en or brand.name or FALLBACK_EN_BRAND
    return brand.name or FALLBACK_FA_BRAND


def _page_meta(db: Session, page_key: str) -> models.SeoMeta | None:
    return db.query(models.SeoMeta).filter(models.SeoMeta.page_key == page_key).first()


def _meta_for(db: Session, page_key: str, lang: str) -> tuple[str, str]:
    """عنوان و توضیح سئوی یک صفحه به زبان درخواستی — با برگشت به فارسی."""
    meta = _page_meta(db, page_key)
    if meta is None:
        return "", ""
    if lang == "en":
        return meta.title_en or meta.title or "", meta.description_en or meta.description or ""
    return meta.title or "", meta.description or ""


def _meta_desc_for(article: models.Article, lang: str) -> str:
    """توضیح سئوی مقاله به زبان درخواستی — توضیح اختصاصی در اولویت، چکیده در برگشت."""
    if lang == "en":
        return (article.meta_description_en or article.meta_description or article.excerpt_en or article.excerpt or "").strip()
    return (article.meta_description or article.excerpt or "").strip()


def _org_jsonld(db: Session, lang: str) -> dict:
    """اسکیمای Organization — روی همهٔ صفحات تزریق می‌شود (موجودیت برند سایت).
    فقط داده‌های واقعی: لوگو، شبکه‌های اجتماعی فوتر و تماس ثبت‌شده در پنل."""
    brand = _brand_row(db)
    org: dict = {
        "@context": "https://schema.org",
        "@type": "Organization",
        "name": _brand_name(db, lang),
    }
    if settings.site_url:
        org["url"] = _absolute("/")
    logo = (brand.logo or "").strip() if brand else ""
    if logo:
        # لوگوی رسمی به‌صورت ImageObject — تا موتورها و دستیارهای AI آن را
        # به‌عنوان نشان برند بشناسند، نه یک تصویر عمومی بی‌هویت
        org["logo"] = {
            "@type": "ImageObject",
            "url": _absolute(logo),
            "contentUrl": _absolute(logo),
            "name": f"{_brand_name(db, lang)} — {'لوگوی رسمی' if lang == 'fa' else 'official logo'}",
            "caption": _brand_name(db, lang),
        }
        # تصویر شاخص برند به‌عنوان تصویر معرفی سازمان
        hero_img = (brand.hero or "").strip() if brand else ""
        if hero_img:
            org["image"] = {"@type": "ImageObject", "url": _absolute(hero_img), "caption": _brand_name(db, lang)}
    footer = db.query(models.FooterContent).first()
    socials = []
    if footer is not None:
        socials = (footer.socials_en if lang == "en" and footer.socials_en else footer.socials) or []
    same_as: list[str] = []
    for item in socials if isinstance(socials, list) else []:
        if isinstance(item, dict):
            href_ = (item.get("href") or "").strip()
            if href_.startswith("http") and href_ not in same_as:
                same_as.append(href_)
    if same_as:
        org["sameAs"] = same_as
    phone = (brand.phone or "").strip() if brand else ""
    if phone:
        org["contactPoint"] = [
            {"@type": "ContactPoint", "contactType": "customer service", "telephone": phone}
        ]
    email = (brand.email or "").strip() if brand else ""
    if email:
        org["email"] = email
    # هویت تاریخی برند — تأسیس ۱۳۸۱ (= ۲۰۰۲ میلادی) در اصفهان؛ سیگنال تمایز
    # در برابر شرکت‌هایی که از نام برند استفاده می‌کنند (تأسیس ۱۳۹۱ آن‌هاست)
    org["foundingDate"] = "2002"
    org["foundingLocation"] = {
        "@type": "Place",
        "name": "Isfahan, Iran" if lang == "en" else "اصفهان، ایران",
    }
    return org


def _localbusiness_jsonld(db: Session, lang: str, path: str) -> dict | None:
    """اسکیمای GeneralContractor از دفاتر ثبت‌شده — برای صفحه‌های تماس و درباره."""
    offices = db.query(models.Office).order_by(models.Office.position, models.Office.id).all()
    if not offices:
        return None
    brand = _brand_row(db)
    business: dict = {
        "@context": "https://schema.org",
        "@type": "GeneralContractor",
        "name": _brand_name(db, lang),
        "url": _absolute(path),
    }
    phone = (brand.phone or "").strip() if brand else ""
    if phone:
        business["telephone"] = phone
    email = (brand.email or "").strip() if brand else ""
    if email:
        business["email"] = email
    addresses: list[dict] = []
    areas: list[str] = []
    for office in offices:
        city = ((office.city_en or office.city) if lang == "en" else office.city).strip()
        street = ((office.address_en or office.address) if lang == "en" else office.address).strip()
        address: dict = {"@type": "PostalAddress", "addressCountry": "IR"}
        if street:
            address["streetAddress"] = street
        if city:
            address["addressLocality"] = city
            areas.append(city)
        addresses.append(address)
    business["address"] = addresses[0] if len(addresses) == 1 else addresses
    if areas:
        business["areaServed"] = sorted(set(areas))
    # دادهٔ مکانی دقیق دفتر — سیگنال مستقیم برای گوگل و دستیارهای AI؛
    # hasMap همان قالب رسمی Maps URLs بدون کلید API است که فرانت‌اند هم می‌سازد
    business["geo"] = {
        "@type": "GeoCoordinates",
        "latitude": OFFICE_GEO[0],
        "longitude": OFFICE_GEO[1],
    }
    business["hasMap"] = OFFICE_MAPS_URL
    return business


def _breadcrumb_jsonld(items: list[tuple[str, str]]) -> dict:
    """اسکیمای BreadcrumbList — متناظر با مسیر بطری بصری صفحه."""
    return {
        "@context": "https://schema.org",
        "@type": "BreadcrumbList",
        "itemListElement": [
            {"@type": "ListItem", "position": i + 1, "name": name, "item": _url_escape(_absolute(url))}
            for i, (name, url) in enumerate(items)
        ],
    }


def _faq_entities(faqs: object, lang: str = "fa", faqs_en: object = None) -> list[dict]:
    """ساخت mainEntity اسکیمای FAQPage از ردیف‌های [{question, answer}]."""
    rows = faqs if isinstance(faqs, list) else []
    if lang == "en":
        rows_en = faqs_en if isinstance(faqs_en, list) else None
        if rows_en:
            rows = rows_en
    entities = []
    for item in rows:
        if isinstance(item, dict):
            question = (item.get("question") or "").strip()
            answer = (item.get("answer") or "").strip()
            if question and answer:
                entities.append(
                    {"@type": "Question", "name": question,
                     "acceptedAnswer": {"@type": "Answer", "text": answer}}
                )
    return entities


def _faq_page_jsonld(db: Session, lang: str) -> dict | None:
    """اسکیمای FAQPage صفحهٔ پرسش‌وپاسخ — از موجودیت faqs.
    (گوگل از اردیبهشت ۱۴۰۵ نتیجهٔ غنی FAQ برای همهٔ سایت‌ها برداشت؛ این اسکیما برای
    موتورهای هوش مصنوعی است که پرسش‌وپاسخ ساخت‌یافته را مستقیم می‌خوانند.)"""
    rows = db.query(models.Faq).order_by(models.Faq.position, models.Faq.id).all()
    entities = _faq_entities(
        [{"question": f.question, "answer": f.answer} for f in rows],
        lang,
        [{"question": f.question_en, "answer": f.answer_en} for f in rows],
    )
    if not entities:
        return None
    return {"@context": "https://schema.org", "@type": "FAQPage", "mainEntity": entities}


def _article_jsonld(article: models.Article, lang: str, db: Session) -> dict:
    """اسکیمای Article — با نویسنده (Person در صورت ثبت نام)، تاریخ انتشار و ناشر."""
    brand = _brand_name(db, lang)
    title = (article.title_en or article.title) if lang == "en" else article.title
    en_slug = ((article.slug_en or "").strip() or article.slug) if lang == "en" else article.slug
    author_name = ((article.author_en or "").strip() or (article.author or "").strip()) if lang == "en" else (article.author or "").strip()
    publisher: dict = {"@type": "Organization", "name": brand}
    brand_row = _brand_row(db)
    logo = (brand_row.logo or "").strip() if brand_row else ""
    if logo:
        publisher["logo"] = {"@type": "ImageObject", "url": _absolute(logo)}
    schema: dict = {
        "@context": "https://schema.org",
        "@type": "Article",
        "headline": title,
        "description": _meta_desc_for(article, lang),
        "inLanguage": lang,
        "author": {"@type": "Person", "name": author_name} if author_name else {"@type": "Organization", "name": brand},
        "publisher": publisher,
        "mainEntityOfPage": _absolute(f"/blog/{article.slug}" if lang == "fa" else f"/en/blog/{en_slug}"),
    }
    image = _absolute(article.image) if (article.image or "").strip() else ""
    if image:
        schema["image"] = image
    published = _parse_site_date(article.date_en if lang == "en" else article.date) or _parse_site_date(article.date)
    if published:
        schema["datePublished"] = published
    return schema


def _nav_label(db: Session, href: str, lang: str) -> str:
    """برچسب فارسی/انگلیسی یک مسیر از ناوبری — برای پیش‌فرض عنوان و بردکرامب."""
    nav = db.query(models.NavItem).filter(models.NavItem.href == href).first()
    if nav is None:
        return ""
    return ((nav.label_en or nav.label) if lang == "en" else nav.label or "").strip()


# ---------- robots.txt و sitemap.xml و llms.txt ----------


@router.get("/robots.txt", response_class=Response)
def robots(db: Session = Depends(get_db)):
    # پیش‌نمایش خصوصی — هیچ خزنده‌ای نباید چیزی ذخیره کند
    if settings.preview_mode:
        return Response(
            content="User-agent: *\nDisallow: /\n",
            media_type="text/plain; charset=utf-8",
        )
    # /api/site مسدود نمی‌شود: رندرر گوگل این XHR را واکشی می‌کند و Disallow کلی
    # /api باعث می‌شد «مسدود توسط robots.txt» ثبت شود. افزودن Allow داخل همان گروه
    # قابل‌اعتماد نبود (برخی خزنده‌ها گروه Disallow را ملاک می‌گیرند). حالا فقط
    # مسیرهای حساس اداری و اندپوینت‌های مدیریتی مسدود می‌شوند — نه /api/site.
    lines = [
        "User-agent: *",
        "Disallow: /admin",
        "Disallow: /api/admin",
        "Allow: /api/site",
        "",
    ]
    # سیاست صریح خزنده‌های هوش مصنوعی — ربات‌های جست‌وجو/ارجاع آزادند تا محتوا
    # در پاسخ‌های ChatGPT/Claude/Perplexity/Gemini ارجاع شود
    for bot in AI_SEARCH_BOTS:
        lines += [f"User-agent: {bot}", "Allow: /", ""]
    # خزندهٔ تهاجمی با سود کم
    lines += ["User-agent: Bytespider", "Disallow: /", ""]
    if settings.site_url:
        lines.append(f"Sitemap: {_absolute('/sitemap.xml')}")
    return Response(content="\n".join(lines), media_type="text/plain; charset=utf-8")


def _static_has_en(db: Session, page_key: str) -> bool:
    """آیا صفحهٔ استاتیک ترجمهٔ انگلیسی واقعی دارد؟ (متای سئوی انگلیسی ثبت شده باشد)"""
    meta = _page_meta(db, page_key)
    return bool(
        meta
        and ((meta.title_en or "").strip() or (meta.description_en or "").strip())
    )


@router.get("/sitemap.xml", response_class=Response)
def sitemap(db: Session = Depends(get_db)):
    # پیش‌نمایش خصوصی — نقشه سایت خالی تا هیچ نشانی‌ای اعلام نشود
    if settings.preview_mode:
        xml = (
            '<?xml version="1.0" encoding="UTF-8"?>\n'
            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"></urlset>\n'
        )
        return Response(
            content=xml,
            media_type="application/xml; charset=utf-8",
            headers={"Cache-Control": "public, max-age=300"},
        )
    esc = html.escape

    articles = {
        a.slug: a
        for a in db.query(models.Article)
        .filter(models.Article.status == "published")
        .order_by(models.Article.position, models.Article.id)
        .all()
    }
    projects = {
        p.slug: p for p in db.query(models.Project).order_by(models.Project.position, models.Project.id).all()
    }

    def entry(loc: str, lang: str, has_en: bool, lastmod: str | None = None) -> str:
        """ورودی sitemap با جفت‌های alternateِ هم‌اسلاگ (صفحات استاتیک/پروژه‌ها)."""
        return url_entry(loc, _alternate_pairs(loc, lang, has_en), lastmod)

    def url_entry(loc: str, pairs: list[tuple[str, str]], lastmod: str | None = None) -> str:
        """ورودی sitemap با جفت‌های alternate صریح — برای مقاله‌هایی که دو زبان
        اسلاگ جدا دارند."""
        links = "\n".join(
            f'      <xhtml:link rel="alternate" hreflang="{code}" href="{esc(_url_escape(href_))}" />'
            for code, href_ in pairs
        )
        # lastmod فقط با زمان واقعی ثبت‌شده — تاریخ جعلی همگن خودش سیگنال منفی است
        stamp = f"\n      <lastmod>{esc(lastmod)}</lastmod>" if lastmod else ""
        return f"    <url><loc>{esc(_url_escape(_absolute(loc)))}</loc>{stamp}\n{links}\n    </url>"

    urls: list[str] = []
    # صفحات استاتیک فارسی + معادل‌های انگلیسیِ ترجمه‌شده
    for path in STATIC_PATHS:
        page_key = "home" if path == "/" else path.strip("/")
        has_en = _static_has_en(db, page_key)
        urls.append(entry(path, "fa", has_en))
        if has_en:
            urls.append(entry(_en_path(path), "en", True))
    # مقاله‌ها — نشانی انگلیسی، اسلاگ انگلیسیِ خودش را دارد (اگر ثبت شده)؛
    # جفت‌های alternate صریح‌اند چون دو زبان می‌توانند اسلاگ متفاوت داشته باشند
    for slug, article in articles.items():
        fa_path = f"/blog/{slug}"
        has_en = _article_has_en(article)
        stamp = _iso_stamp(article.updated_at)
        if has_en:
            en_slug = (article.slug_en or "").strip() or slug
            en_path = f"/en/blog/{en_slug}"
            # مسیرهای خام — url_entry خودش درصدگذاری می‌کند (یک‌بار، نه دوبار)
            pairs = [("fa", fa_path), ("en", en_path), ("x-default", fa_path)]
            urls.append(url_entry(fa_path, pairs, stamp))
            urls.append(url_entry(en_path, pairs, stamp))
        else:
            urls.append(entry(fa_path, "fa", False, stamp))
    # پروژه‌ها — اسلاگ مشترک دو زبان است
    for slug, project in projects.items():
        fa_path = f"/projects/{slug}"
        has_en = _project_has_en(project)
        stamp = _iso_stamp(project.updated_at)
        urls.append(entry(fa_path, "fa", has_en, stamp))
        if has_en:
            urls.append(entry(_en_path(fa_path), "en", True, stamp))
    xml = (
        '<?xml version="1.0" encoding="UTF-8"?>\n'
        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" '
        'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n'
        f"{chr(10).join(urls)}\n</urlset>\n"
    )
    return Response(
        content=xml,
        media_type="application/xml; charset=utf-8",
        headers={"Cache-Control": "public, max-age=300"},
    )


@router.get("/.well-known/indexnow-key.txt", response_class=Response)
def indexnow_key_file():
    """فایل تأیید مالکیت IndexNow — موتورها با خواندن آن، ارسال‌های IndexNow را می‌پذیرند."""
    return Response(content=INDEXNOW_KEY, media_type="text/plain; charset=utf-8")


@router.get(f"/{INDEXNOW_KEY}.txt", response_class=Response)
def indexnow_key_root():
    """محل پیش‌فرض پروتکل IndexNow: /<key>.txt در ریشهٔ دامنه — برخی اعتبارسنج‌ها فقط همین را می‌خوانند."""
    return Response(content=INDEXNOW_KEY, media_type="text/plain; charset=utf-8")


@router.get("/llms.txt", response_class=Response)
def llms_txt(db: Session = Depends(get_db)):
    """راهنمای سایت برای دستیارهای هوش مصنوعی — برند، واقعیت‌های کلیدی و صفحه‌های اصلی.
    در حالت پیش‌نمایش خصوصی ۴۰۴ می‌دهد تا ساختار سایت بیرون درز نکند."""
    if settings.preview_mode:
        return Response(status_code=404)
    brand = _brand_name(db, "en")
    _, home_desc = _meta_for(db, "home", "en")
    lines = [
        f"# {brand}",
        f"> {_clip(home_desc or 'Construction group — engineering, contracting and property investment.', 200)}",
        "",
    ]
    services = [
        (s.title_en or s.title).strip()
        for s in db.query(models.Service).order_by(models.Service.position, models.Service.id).all()
        if (s.title_en or s.title).strip()
    ]
    offices = db.query(models.Office).order_by(models.Office.position, models.Office.id).all()
    cities = [
        (o.city_en or o.city).strip() for o in offices if (o.city_en or o.city).strip()
    ]
    facts = []
    if services:
        facts.append(f"- Services: {', '.join(services)}")
    if cities:
        facts.append(f"- Offices: {', '.join(sorted(set(cities)))}")
    facts.append("- Languages: Persian at / and English at /en")
    lines += ["## Key Facts", *facts, ""]
    lines.append("## Pages")
    for page_key, label in [
        ("home", "Home"), ("about", "About"), ("services", "Services"),
        ("projects", "Projects"), ("blog", "Blog"), ("faq", "FAQ"), ("contact", "Contact"),
    ]:
        title, description = _meta_for(db, page_key, "en")
        url = "/" if page_key == "home" else f"/en/{page_key}"
        # توضیح متا کوتاه است (۱۵۰–۱۶۰ نویسه) — کامل می‌آید تا جمله نیمه‌بریده نشود
        summary = " ".join((description or "").split())
        lines.append(f"- [{label}]({_absolute(url)})" + (f": {summary}" if summary else ""))
    featured_projects = (
        db.query(models.Project).order_by(models.Project.position, models.Project.id).limit(6).all()
    )
    if featured_projects:
        lines += ["", "## Featured Projects"]
        for p in featured_projects:
            title_en = (p.title_en or "").strip()
            # بدون ترجمهٔ انگلیسی، عنوان فارسی با نشان «(Persian)» می‌آید تا متن انگلیسی
            # مخلوط به نظر نرسد؛ خلاصه هم از نسخهٔ همان زبان عنوان می‌آید
            title = (title_en or p.title.strip()) + ("" if title_en else " (Persian)")
            summary = ((p.summary_en or "").strip() if title_en else "") or (p.summary or "").strip()
            if title_en and not (p.summary_en or "").strip():
                place = (p.location_en or p.location or "").strip()
                summary = f"Project in {place}" if place else ""
            summary = _clip(summary, 140)
            # بدون ترجمهٔ انگلیسی، همان نشانی فارسی اعلام می‌شود؛ توضیح خالی هم حذف می‌شود
            path = f"/en/projects/{p.slug}" if _project_has_en(p) else f"/projects/{p.slug}"
            lines.append(f"- [{title}]({_url_escape(_absolute(path))})" + (f": {summary}" if summary else ""))
    latest = (
        db.query(models.Article)
        .filter(models.Article.status == "published")
        .order_by(models.Article.position, models.Article.id)
        .limit(6)
        .all()
    )
    if latest:
        lines += ["", "## Recent Articles"]
        for a in latest:
            title_en = (a.title_en or "").strip()
            title = (title_en or a.title.strip()) + ("" if title_en else " (Persian)")
            summary = ((a.excerpt_en or "").strip() if title_en else "") or (a.excerpt or "").strip()
            summary = _clip(summary, 140)
            # نشانی انگلیسی اسلاگ انگلیسی خودش را دارد (اگر ثبت شده باشد)
            if _article_has_en(a):
                path = f"/en/blog/{(a.slug_en or '').strip() or a.slug}"
            else:
                path = f"/blog/{a.slug}"
            lines.append(f"- [{title}]({_url_escape(_absolute(path))})" + (f": {summary}" if summary else ""))
    brand_row = _brand_row(db)
    contact_lines = []
    if brand_row and (brand_row.phone or "").strip():
        contact_lines.append(f"- Phone: {brand_row.phone.strip()}")
    if brand_row and (brand_row.email or "").strip():
        contact_lines.append(f"- Email: {brand_row.email.strip()}")
    for o in offices:
        city = (o.city_en or o.city).strip()
        street = ((o.address_en or o.address) or o.address).strip()
        # اگر نشانی خودش نام شهر را دارد، تکرار نشود («اصفهان، ملاصدرا…» + «، اصفهان»)
        detail = street if (city and city in street) else (street + ("، " + city if city and street else city))
        if detail:
            contact_lines.append(f"- Office: {_clip(detail, 120)}")
    # مختصات و پیوند نقشهٔ دفتر مرکزی — دادهٔ مکانی مستقیم برای دستیارهای AI
    contact_lines.append(f"- Head office on map: {OFFICE_MAPS_URL}")
    if contact_lines:
        lines += ["", "## Contact", *contact_lines]
    # راهنمای دستیارهای AI: تصاویر هر پروژه به‌صورت آرشیو ZIP با manifest قابل دریافت است
    project_count = db.query(models.Project).count()
    if project_count:
        lines += [
            "",
            "## Project images (machine-readable)",
            f"- [{project_count} projects with image archives]"
            f"({_absolute('/projects-images.json')}): JSON index — page URL, image count,"
            " area, year and a ZIP download link for every project.",
            f"- Per project: {_absolute('/projects/{slug}/images.zip')} — ZIP of that project's"
            " photos plus manifest.json (specs, per-image captions). Replace {slug} with the"
            " URL-encoded project slug from the index above.",
        ]
    # llms.txt زنده از دیتابیس ساخته می‌شود — بدون کش تا همیشه تازه باشد
    return Response(
        content="\n".join(lines) + "\n",
        media_type="text/plain; charset=utf-8",
        headers={"Cache-Control": "no-store"},
    )


# این مسیر باید بعد از همهٔ مسیرهای .txt مشخص (robots/llms/indexnow) تعریف شود
# تا هیچکدام را سایه نیندازد
@router.get("/{key}.txt", response_class=Response)
def indexnow_key_any(key: str):
    """هر کلید IndexNow معتبر (۳۲ نویسهٔ هگز) — فایل /{key}.txt همان کلید را برمیگرداند.
    پنل Bing/دیگر موتورها هر بار کلید تازه میسازند؛ این مسیر یعنی هیچ کلیدی
    نیاز به افزودن دستی فایل ندارد (فایلهای موجود در بیلد هم معتبر میمانند)."""
    if re.fullmatch(r"[a-f0-9]{32}", key):
        return Response(content=key, media_type="text/plain; charset=utf-8")
    return Response(status_code=404)


# ---------- صفحات استاتیک فارسی ----------


def _site_content_html(db: Session, page_key: str, lang: str) -> str:
    """محتوای واقعی سایت به‌صورت متن HTML خوانا — داخل <noscript>.

    خزنده‌هایی که جاوااسکریپت اجرا نمی‌کنند (اکثر ربات‌های هوش مصنوعی: GPTBot،
    OAI-SearchBot، ClaudeBot، PerplexityBot) فقط HTML اولیه را می‌خوانند؛ بدون این،
    از سایت فقط عنوان و یک خط توضیح می‌دیدند. اینجا معرفی، خدمات، پروژه‌ها، آمار،
    دفاتر و پرسش‌وپاسخ‌ها به متن واقعی تبدیل می‌شوند. برای مرورگرهای معمولی نامرئی
    است (noscript وقتی JS فعال است نمایش داده نمی‌شود)."""
    def en(fa_value: str, en_value: str | None) -> str:
        return (en_value or "").strip() if (lang == "en" and (en_value or "").strip()) else (fa_value or "").strip()

    esc = html.escape
    parts: list[str] = []

    brand = _brand_row(db)
    hero = db.query(models.Hero).first()
    if hero:
        parts.append(f"<h2>{esc(en(hero.title, hero.title_en))}</h2>")
        sub = en(hero.subtitle, hero.subtitle_en)
        if sub:
            parts.append(f"<p>{esc(sub)}</p>")

    if page_key == "home":
        story = db.query(models.StorySection).first()
        if story:
            parts.append(f"<h2>{esc(en(story.title, story.title_en))}</h2>")
            # نسخهٔ انگلیسی متن داستان اگر ثبت شده باشد، جایگزین می‌شود
            paras = story.paragraphs if isinstance(story.paragraphs, list) else []
            if lang == "en" and isinstance(getattr(story, "paragraphs_en", None), list) and story.paragraphs_en:
                paras = story.paragraphs_en
            for para in paras:
                if isinstance(para, str) and para.strip():
                    parts.append(f"<p>{esc(para.strip())}</p>")

        stats = db.query(models.Stat).order_by(models.Stat.position, models.Stat.id).all()
        if stats:
            items = "".join(
                f"<li>{esc(str(s.value))}{esc(en(s.suffix, s.suffix_en))} — {esc(en(s.label, s.label_en))}</li>"
                for s in stats
            )
            parts.append(f"<h2>{'Key Numbers' if lang == 'en' else 'آمار کلیدی'}</h2><ul>{items}</ul>")

    if page_key in ("home", "projects"):
        projects = db.query(models.Project).order_by(models.Project.position, models.Project.id).all()
        if projects:
            items = ""
            for p in projects:
                title = en(p.title, p.title_en)
                loc = en(p.location, p.location_en)
                year = en(p.year, p.year_en)
                # متراژ و طبقات هم در فهرست می‌آید — بدون این، دستیارهای AI
                # نتیجه می‌گیرند «برای پروژه‌ها متراژ ثبت نشده» (فقط صفحهٔ جزئیات داشت)
                def num(fa_v: object, en_v: object) -> str:
                    return str(en_v).strip() if (lang == "en" and str(en_v or "").strip()) else str(fa_v or "").strip()

                specs = []
                if num(p.land_area, getattr(p, "land_area_en", "")):
                    specs.append(("Land" if lang == "en" else "زمین") + f" {num(p.land_area, getattr(p, 'land_area_en', ''))} m²")
                if num(p.area, getattr(p, "area_en", "")):
                    specs.append(("Built" if lang == "en" else "زیربنا") + f" {num(p.area, getattr(p, 'area_en', ''))} m²")
                if num(p.floors, getattr(p, "floors_en", "")):
                    specs.append(("Floors" if lang == "en" else "طبقات") + f" {num(p.floors, getattr(p, 'floors_en', ''))}")
                if num(p.units_residential, getattr(p, "units_residential_en", "")):
                    specs.append(("Units" if lang == "en" else "واحد") + f" {num(p.units_residential, getattr(p, 'units_residential_en', ''))}")
                bits = "، ".join(x for x in (loc, year) if x)
                tail = "؛ ".join(specs)
                # نام پروژه پیوند به صفحهٔ جزئیات — خزنده می‌تواند مشخصات کامل را دنبال کند
                href = f"/en/projects/{p.slug}" if lang == "en" else f"/projects/{p.slug}"
                line = f'<a href="{esc(_absolute(href))}">{esc(title)}</a>'
                if bits:
                    line += f" — {esc(bits)}"
                if tail:
                    line += f" [{esc(tail)}]"
                # پیوند صریح به آرشیو تصاویر همان پروژه
                zip_url = _absolute(f"/projects/{urllib.parse.quote(p.slug)}/images.zip")
                zip_label = "images (ZIP)" if lang == "en" else "تصاویر (ZIP)"
                line += f' — <a href="{esc(zip_url)}">{esc(zip_label)}</a>'
                items += f"<li>{line}</li>"
            parts.append(f"<h2>{'Our Projects' if lang == 'en' else 'پروژه‌های ما'}</h2><ul>{items}</ul>")

    # مقاله‌های منتشرشده — فهرست وبلاگ برای خزنده‌های بدون جاوااسکریپت (ربات‌های AI)؛
    # نشانی انگلیسی همان اسلاگ انگلیسی مقاله است (اگر ثبت شده باشد)
    if page_key in ("home", "blog"):
        blog_items = (
            db.query(models.Article)
            .filter(models.Article.status == "published")
            .order_by(models.Article.position, models.Article.id)
            .limit(6)
            .all()
        )
        if blog_items:
            items = ""
            for a in blog_items:
                title = en(a.title, a.title_en)
                if lang == "en" and _article_has_en(a):
                    href = f"/en/blog/{quote((a.slug_en or '').strip() or a.slug, safe='')}"
                else:
                    href = f"/blog/{quote(a.slug, safe='')}"
                items += f'<li><a href="{esc(_absolute(href))}">{esc(title)}</a>'
                summary = en(a.excerpt, a.excerpt_en)
                if summary:
                    items += f": {esc(_clip(summary, 160))}"
                items += "</li>"
            parts.append(f"<h2>{'Blog' if lang == 'en' else 'وبلاگ'}</h2><ul>{items}</ul>")

    if page_key in ("home", "services"):
        services = db.query(models.Service).order_by(models.Service.position, models.Service.id).all()
        if services:
            items = "".join(
                f"<li><strong>{esc(en(s.title, s.title_en))}</strong>"
                + (f": {esc(en(s.desc, s.desc_en))}" if en(s.desc, s.desc_en) else "")
                + "</li>"
                for s in services
            )
            parts.append(f"<h2>{'Our Services' if lang == 'en' else 'خدمات ما'}</h2><ul>{items}</ul>")

    if page_key == "investment":
        models_list = db.query(models.InvestmentModel).order_by(models.InvestmentModel.position).all()
        for m in models_list:
            parts.append(f"<h3>{esc(en(m.title, m.title_en))}</h3>")
            if en(m.desc, m.desc_en):
                parts.append(f"<p>{esc(en(m.desc, m.desc_en))}</p>")

    if page_key in ("home", "faq"):
        faqs = db.query(models.Faq).order_by(models.Faq.position, models.Faq.id).all()
        if faqs:
            items = "".join(
                f"<li><strong>{esc(en(f.question, f.question_en))}</strong> {esc(en(f.answer, f.answer_en))}</li>"
                for f in faqs
            )
            parts.append(f"<h2>{'Frequently Asked Questions' if lang == 'en' else 'پرسش‌های پرتکرار'}</h2><ul>{items}</ul>")

    # بخش «تیم ما» موقتاً از خروجی حذف شده — همراه صفحهٔ درباره در فرانت‌اند غیرفعال شد
    # تا خزنده‌ها و دستیارهای AI هم چیزی از آن نبینند؛ برای بازگردانی این بلوک را دوباره فعال کنید
    # if page_key == "about":
    #     team = db.query(models.TeamMember).order_by(models.TeamMember.position).all()
    #     if team:
    #         items = "".join(
    #             f"<li><strong>{esc(en(m.name, m.name_en))}</strong> — {esc(en(m.role, m.role_en))}</li>" for m in team
    #         )
    #         parts.append(f"<h2>{'Our Team' if lang == 'en' else 'تیم ما'}</h2><ul>{items}</ul>")

    if page_key in ("home", "contact"):
        offices = db.query(models.Office).order_by(models.Office.position, models.Office.id).all()
        contact_bits = []
        if brand and brand.phone.strip():
            contact_bits.append(f"<li>{'Phone' if lang == 'en' else 'تلفن'}: {esc(brand.phone.strip())}</li>")
        if brand and brand.email.strip():
            contact_bits.append(f"<li>{'Email' if lang == 'en' else 'ایمیل'}: {esc(brand.email.strip())}</li>")
        if brand and brand.address.strip():
            label = "Head office" if lang == "en" else "دفتر مرکزی"
            contact_bits.append(f"<li>{label}: {esc(brand.address.strip())}</li>")
        for o in offices:
            city = en(o.city, o.city_en)
            addr = en(o.address, o.address_en)
            hours = en(o.hours, o.hours_en)
            detail = addr if (city and city in addr) else f"{addr}، {city}" if addr and city else (addr or city)
            contact_bits.append(f"<li>{esc(detail)}" + (f" — {esc(hours)}" if hours else "") + "</li>")
        # موقعیت روی نقشه — خزنده‌های بدون جاوااسکریپت (ربات‌های AI) هم مختصات و پیوند را می‌بینند
        map_label = "Location on map" if lang == "en" else "موقعیت روی نقشه"
        contact_bits.append(
            f'<li>{map_label}: <a href="{OFFICE_MAPS_URL}">{OFFICE_GEO[0]}, {OFFICE_GEO[1]}</a></li>'
        )
        if contact_bits:
            parts.append(f"<h2>{'Contact' if lang == 'en' else 'تماس'}</h2><ul>{''.join(contact_bits)}</ul>")

    if not parts:
        return ""
    # h1 را پوستهٔ استاتیک خودش می‌گذارد (عنوان سئوی صفحه) — h1 دومی اینجا تکرار می‌شد
    return "".join(parts)


def _list_jsonld(db: Session, page_key: str, lang: str) -> dict | None:
    """اسکیمای ItemList برای صفحه‌های فهرست — همان آیتم‌هایی که خود صفحه نشان می‌دهد.
    مقاله‌ها و پروژه‌ها نشانی اختصاصی دارند؛ خدمات و مدل‌های سرمایه‌گذاری صفحهٔ
    اختصاصی ندارند، پس فقط نامشان می‌آید (فقط دادهٔ واقعی)."""
    def item(position: int, name: str, url: str = "") -> dict:
        entry_: dict = {"@type": "ListItem", "position": position, "name": name}
        if url:
            entry_["url"] = _absolute(url)
        return entry_

    elements: list[dict] = []
    if page_key == "blog":
        articles = (
            db.query(models.Article)
            .filter(models.Article.status == "published")
            .order_by(models.Article.position, models.Article.id)
            .all()
        )
        prefix = "/en/blog" if lang == "en" else "/blog"
        for i, a in enumerate(articles, 1):
            title = (a.title_en or a.title) if lang == "en" else a.title
            elements.append(item(i, title, f"{prefix}/{(a.slug_en or '').strip() or a.slug}" if lang == "en" else f"/blog/{a.slug}"))
    elif page_key == "projects":
        projects = db.query(models.Project).order_by(models.Project.position, models.Project.id).all()
        prefix = "/en/projects" if lang == "en" else "/projects"
        for i, p in enumerate(projects, 1):
            title = (p.title_en or p.title) if lang == "en" else p.title
            elements.append(item(i, title, f"{prefix}/{p.slug}"))
    elif page_key == "services":
        services = db.query(models.Service).order_by(models.Service.position, models.Service.id).all()
        for i, s in enumerate(services, 1):
            title = (s.title_en or s.title) if lang == "en" else s.title
            elements.append(item(i, title))
    elif page_key == "investment":
        rows = db.query(models.InvestmentModel).order_by(models.InvestmentModel.position).all()
        for i, m in enumerate(rows, 1):
            title = (m.title_en or m.title) if lang == "en" else m.title
            elements.append(item(i, title))
    if not elements:
        return None
    return {
        "@context": "https://schema.org",
        "@type": "ItemList",
        "numberOfItems": len(elements),
        "itemListElement": elements,
    }


def _static_shell(db: Session, *, path: str, page_key: str, lang: str = "fa") -> HTMLResponse:
    """پوستهٔ صفحات استاتیک — متا از seo_meta، اسکیمای اختصاصی هر صفحه."""
    title, description = _meta_for(db, page_key, lang)
    brand = _brand_name(db, lang)
    if not title:
        # عنوان پیش‌فرض از برچسب ناوبری همان صفحه
        label = _nav_label(db, f"/{page_key}", lang)
        title = f"{label} | {brand}" if label else brand
    jsonld: list[dict] = []
    if page_key == "faq":
        faq_schema = _faq_page_jsonld(db, lang)
        if faq_schema:
            jsonld.append(faq_schema)
    elif page_key in ("contact", "about"):
        business = _localbusiness_jsonld(db, lang, path)
        if business:
            jsonld.append(business)
    listing = _list_jsonld(db, page_key, lang)
    if listing:
        jsonld.append(listing)
    # noscript با محتوای واقعی — خزنده‌های بدون جاوااسکریپت (ربات‌های هوش مصنوعی)
    # هم عنوان، توضیح و کل محتوای معنایی صفحه را می‌بینند
    noscript = f"<h1>{html.escape(title)}</h1>"
    if description.strip():
        noscript += f"<p>{html.escape(description)}</p>"
    noscript += _site_content_html(db, page_key, lang)
    return _shell(
        db=db,
        title=title,
        description=description,
        path=path,
        lang=lang,
        has_en=_static_has_en(db, page_key),
        jsonld=jsonld or None,
        org_jsonld=_org_jsonld(db, lang),
        noscript=noscript,
    )


@router.get("/", response_class=HTMLResponse)
def home(db: Session = Depends(get_db)):
    return _static_shell(db, path="/", page_key="home")


@router.get("/about", response_class=HTMLResponse)
def about_page(db: Session = Depends(get_db)):
    return _static_shell(db, path="/about", page_key="about")


@router.get("/services", response_class=HTMLResponse)
def services_page(db: Session = Depends(get_db)):
    return _static_shell(db, path="/services", page_key="services")


@router.get("/investment", response_class=HTMLResponse)
def investment_page(db: Session = Depends(get_db)):
    return _static_shell(db, path="/investment", page_key="investment")


@router.get("/faq", response_class=HTMLResponse)
def faq_page(db: Session = Depends(get_db)):
    return _static_shell(db, path="/faq", page_key="faq")


@router.get("/contact", response_class=HTMLResponse)
def contact_page(db: Session = Depends(get_db)):
    return _static_shell(db, path="/contact", page_key="contact")


# ---------- صفحات وبلاگ ----------


@router.get("/blog", response_class=HTMLResponse)
def blog_list(db: Session = Depends(get_db)):
    return _static_shell(db, path="/blog", page_key="blog")


@router.get("/blog/{slug}", response_class=HTMLResponse)
def blog_detail(slug: str, db: Session = Depends(get_db)):
    article = (
        db.query(models.Article)
        .filter(models.Article.slug == slug, models.Article.status == "published")
        .first()
    )
    if article is None:
        # اسلاگ انگلیسی روی مسیر فارسی → نشانی canonical انگلیسی همان مقاله
        by_en = (
            db.query(models.Article)
            .filter(models.Article.slug_en == slug, models.Article.status == "published")
            .first()
        )
        if by_en is not None:
            return RedirectResponse(url=f"/en/blog/{by_en.slug_en}", status_code=301)
        # مقاله ناموجود یا پیش‌نویس — کد وضعیت ۴۰۴ تا خزنده صفحه را ایندکس نکند؛
        # SPA همان پیام «یافت نشد» را نشان می‌دهد
        return _shell(
            db=db,
            title=_brand_name(db), description="", path=f"/blog/{slug}",
            org_jsonld=_org_jsonld(db, "fa"), status_code=404,
        )

    brand = _brand_name(db)
    title = article.title
    first_text = _doc_text(article.body) if not isinstance(article.body, list) else " ".join(article.body[:2])
    faq_schema = _faq_jsonld(article, "fa")
    breadcrumb = _breadcrumb_jsonld([
        (_nav_label(db, "/", "fa") or "خانه", "/"),
        (_nav_label(db, "/blog", "fa") or "وبلاگ", "/blog"),
        (title, f"/blog/{article.slug}"),
    ])
    jsonld: list[dict] = [_article_jsonld(article, "fa", db), breadcrumb]
    if faq_schema:
        jsonld.append(faq_schema)
    noscript = f"<h1>{html.escape(title)}</h1><p>{html.escape(first_text)}</p>"
    return _shell(
        db=db,
        title=f"{title} | {brand}",
        description=_meta_desc_for(article, "fa"),
        path=f"/blog/{article.slug}",
        has_en=_article_has_en(article),
        # alternate انگلیسی با اسلاگ انگلیسی خودش — نه اسلاگ فارسی زیر /en
        # (خام پاس می‌شود؛ _url_escape خودش یک‌بار درصدگذاری می‌کند)
        alt_en=f"/en/blog/{(article.slug_en or '').strip() or article.slug}",
        og_image=article.image,
        og_image_alt=article.image_alt or title,
        og_type="article",
        jsonld=jsonld,
        org_jsonld=_org_jsonld(db, "fa"),
        noscript=noscript,
    )


def _project_schema(project: models.Project, lang: str, db: Session) -> dict:
    """اسکیمای پروژه — همهٔ تصاویر با نام و توضیح به خود پروژه گره می‌خورند.
    بدون این، سیستم‌های هوش مصنوعی فقط یک فایل تصویر بدون هویت می‌بینند و
    نمی‌توانند تصویر را به پروژه نسبت دهند."""
    brand = _brand_name(db, lang)
    title = (project.title_en or project.title) if lang == "en" else project.title
    schema: dict = {
        "@context": "https://schema.org",
        "@type": "CreativeWork",
        "name": title,
        "inLanguage": lang,
        "creator": {"@type": "Organization", "name": brand},
    }
    location = (project.location_en or project.location) if lang == "en" else project.location
    summary = (project.summary_en or project.summary) if lang == "en" else project.summary
    body_text = _doc_text(project.body, 2000) if isinstance(project.body, dict) else ""
    description = (summary or "").strip() or body_text
    if description:
        schema["description"] = description
    if location:
        schema["locationCreated"] = {"@type": "Place", "name": location.strip()}
    # مشخصات فنی پروژه — دادهٔ ساخت‌یافته تا موتورها/دستیارها بتوانند به آن استناد کنند
    def spec(fa_v: object, en_v: object, label: str) -> dict | None:
        val = (str(en_v).strip() if (lang == "en" and str(en_v or "").strip()) else str(fa_v or "").strip())
        return {"@type": "PropertyValue", "name": label, "value": val} if val else None

    specs = [
        spec(project.year, getattr(project, "year_en", ""), "Year" if lang == "en" else "سال"),
        spec(project.location, getattr(project, "location_en", ""), "Location" if lang == "en" else "موقعیت"),
        spec(project.land_area, getattr(project, "land_area_en", ""), "Land area" if lang == "en" else "مساحت زمین"),
        spec(project.area, getattr(project, "area_en", ""), "Built area" if lang == "en" else "زیربنا"),
        spec(project.floors, getattr(project, "floors_en", ""), "Floors" if lang == "en" else "طبقات"),
        spec(project.units_residential, getattr(project, "units_residential_en", ""), "Residential units" if lang == "en" else "واحد مسکونی"),
        spec(project.units_commercial, getattr(project, "units_commercial_en", ""), "Commercial units" if lang == "en" else "واحد تجاری"),
        spec(project.units_office, getattr(project, "units_office_en", ""), "Office units" if lang == "en" else "واحد اداری"),
        spec(project.client, getattr(project, "client_en", ""), "Client" if lang == "en" else "کارفرما"),
    ]
    specs = [s for s in specs if s]
    if specs:
        schema["additionalProperty"] = specs
    # همهٔ تصاویر (شاخص + گالری) به‌صورت ImageObject با نام — تا هر تصویر هویت داشته باشد
    paths = [project.image] if (project.image or "").strip() else []
    for g in (project.gallery or []):
        if isinstance(g, str) and g.strip() and g not in paths:
            paths.append(g)
    if paths:
        images = [
            {
                "@type": "ImageObject",
                "url": _absolute(p),
                "name": f"{title} — {'تصویر پروژه' if lang == 'fa' else 'project photo'}",
                "caption": (f"{title}" + (f"، {location.strip()}" if location else "")),
                "contentUrl": _absolute(p),
            }
            for p in paths[:12]
        ]
        schema["image"] = images if len(images) > 1 else images[0]
    return schema


def _project_content_html(project: models.Project, lang: str, brand: str) -> str:
    """محتوای خوانا صفحهٔ پروژه برای خزنده‌های بدون جاوااسکریپت + توضیح تصاویر."""
    def en(fa_value: str, en_value: str | None) -> str:
        return (en_value or "").strip() if (lang == "en" and (en_value or "").strip()) else (fa_value or "").strip()

    esc = html.escape
    title = en(project.title, project.title_en)
    parts = [f"<h1>{esc(title)}</h1>"]
    if en(project.summary, project.summary_en):
        parts.append(f"<p>{esc(en(project.summary, project.summary_en))}</p>")
    elif isinstance(project.body, dict):
        text = _doc_text(project.body, 2000)
        if text:
            parts.append(f"<p>{esc(text)}</p>")

    facts = []
    # مشخصات فنی — همهٔ فیلدهای عدسی که تیم در پنل پر می‌کند.
    # اعداد زبان‌مستقل‌اند؛ پس حتی وقتی ترجمهٔ انگلیسی نیست، مقدار فارسی
    # (ارقام فارسی) هم منتشر می‌شود تا داده گم نشود.
    def num(fa_v: object, en_v: object) -> str:
        if lang == "en" and str(en_v or "").strip():
            return str(en_v).strip()
        return str(fa_v or "").strip()

    for fa_v, en_v, label_fa, label_en in [
        (project.location, getattr(project, "location_en", ""), "موقعیت", "Location"),
        (project.year, getattr(project, "year_en", ""), "سال", "Year"),
        (project.project_type, getattr(project, "project_type_en", ""), "نوع پروژه", "Project type"),
        (project.usage, getattr(project, "usage_en", ""), "کاربری", "Usage"),
        (project.land_area, getattr(project, "land_area_en", ""), "مساحت زمین (مترمربع)", "Land area (m²)"),
        (project.area, getattr(project, "area_en", ""), "زیربنا (مترمربع)", "Built area (m²)"),
        (project.floors, getattr(project, "floors_en", ""), "تعداد طبقات", "Floors"),
        (project.pilot_floors, getattr(project, "pilot_floors_en", ""), "طبقات پیلوت", "Pilot floors"),
        (project.units_residential, getattr(project, "units_residential_en", ""), "واحد مسکونی", "Residential units"),
        (project.units_commercial, getattr(project, "units_commercial_en", ""), "واحد تجاری", "Commercial units"),
        (project.units_office, getattr(project, "units_office_en", ""), "واحد اداری", "Office units"),
        (project.client, getattr(project, "client_en", ""), "کارفرما", "Client"),
        (project.status, "", "وضعیت", "Status"),
    ]:
        val = num(fa_v, en_v)
        if val:
            facts.append(f"<li>{label_en if lang == 'en' else label_fa}: {esc(val)}</li>")
    if facts:
        parts.append(f"<ul>{''.join(facts)}</ul>")

    # نام و موقعیت هر تصویر — همان چیزی که سیستم‌های هوش مصنوعی برای اعتبارسنجی لازم دارند
    images = []
    if (project.image or "").strip():
        images.append(project.image)
    for g in (project.gallery or []):
        if isinstance(g, str) and g.strip() and g not in images:
            images.append(g)
    if images:
        label = "Project photos" if lang == "en" else "تصاویر پروژه"
        items = "".join(
            f'<li><img src="{esc(p)}" alt="{esc(title)}'
            + (f' — {esc(en(project.location, project.location_en))}' if en(project.location, project.location_en) else "")
            + f'" /> {esc(title)}</li>'
            for p in images[:12]
        )
        # پیوند واقعی به آرشیو ZIP — دستیارهای AI الگو نمی‌سازند؛ باید لینک صریح ببینند
        zip_url = _absolute(f"/projects/{urllib.parse.quote(project.slug)}/images.zip")
        archive_label = "Download all images (ZIP)" if lang == "en" else "دانلود همهٔ تصاویر (ZIP)"
        parts.append(
            f"<h2>{label}</h2>"
            f'<p><a href="{esc(zip_url)}">{esc(archive_label)}</a></p>'
            f"<ul>{items}</ul>"
        )
    return "".join(parts)


def _faq_jsonld(article: models.Article, lang: str) -> dict | None:
    """اسکیمای FAQPage از پرسش‌وپاسخ‌های پایان مقاله."""
    entities = _faq_entities(article.faqs, lang, article.faqs_en)
    if not entities:
        return None
    return {"@context": "https://schema.org", "@type": "FAQPage", "mainEntity": entities}


# ---------- صفحات پروژه ----------


@router.get("/projects", response_class=HTMLResponse)
def projects_list(db: Session = Depends(get_db)):
    return _static_shell(db, path="/projects", page_key="projects")


@router.get("/projects/{slug}", response_class=HTMLResponse)
def project_detail(slug: str, db: Session = Depends(get_db)):
    project = db.query(models.Project).filter(models.Project.slug == slug).first()
    if project is None:
        return _shell(
            db=db,
            title=_brand_name(db), description="", path=f"/projects/{slug}",
            org_jsonld=_org_jsonld(db, "fa"), status_code=404,
        )

    brand = _brand_name(db)
    jsonld = [
        _project_schema(project, "fa", db),
        _breadcrumb_jsonld([
            (_nav_label(db, "/", "fa") or "خانه", "/"),
            (_nav_label(db, "/projects", "fa") or "پروژه‌ها", "/projects"),
            (project.title, f"/projects/{project.slug}"),
        ]),
    ]
    return _shell(
        db=db,
        title=f"{project.title} | {brand}",
        description=project.summary,
        path=f"/projects/{project.slug}",
        has_en=_project_has_en(project),
        og_image=project.image,
        og_image_alt=project.title,
        jsonld=jsonld,
        org_jsonld=_org_jsonld(db, "fa"),
        noscript=_project_content_html(project, "fa", brand),
    )


# ---------- صفحات انگلیسی (/en/...) ----------


def _en_blog_detail(article: models.Article, db: Session) -> HTMLResponse:
    brand = _brand_name(db, "en")
    title = article.title_en or article.title
    body = article.body_en if isinstance(article.body_en, dict) else article.body
    first_text = _doc_text(body) if not isinstance(body, list) else " ".join(body[:2])
    faq_schema = _faq_jsonld(article, "en")
    breadcrumb = _breadcrumb_jsonld([
        (_nav_label(db, "/", "en") or "Home", "/"),
        (_nav_label(db, "/blog", "en") or "Blog", "/en/blog"),
        (title, f"/en/blog/{(article.slug_en or '').strip() or article.slug}"),
    ])
    jsonld: list[dict] = [_article_jsonld(article, "en", db), breadcrumb]
    if faq_schema:
        jsonld.append(faq_schema)
    noscript = f"<h1>{html.escape(title)}</h1><p>{html.escape(first_text)}</p>"
    return _shell(
        db=db,
        title=f"{title} | {brand}",
        description=_meta_desc_for(article, "en"),
        path=f"/en/blog/{(article.slug_en or '').strip() or article.slug}",
        lang="en",
        has_en=_article_has_en(article),
        # alternate فارسی با اسلاگ فارسی خودش — نه حذف پیشوند /en از مسیر انگلیسی
        # (خام پاس می‌شود؛ _url_escape خودش یک‌بار درصدگذاری می‌کند)
        alt_fa=f"/blog/{article.slug}",
        og_image=article.image,
        og_image_alt=article.image_alt or title,
        og_type="article",
        jsonld=jsonld,
        org_jsonld=_org_jsonld(db, "en"),
        noscript=noscript,
        noindex=not _article_has_en(article),
    )


@router.get("/en", response_class=HTMLResponse)
@router.get("/en/", response_class=HTMLResponse)
def en_home(db: Session = Depends(get_db)):
    return _static_shell(db, path="/en", page_key="home", lang="en")


@router.get("/en/blog", response_class=HTMLResponse)
def en_blog_list(db: Session = Depends(get_db)):
    return _static_shell(db, path="/en/blog", page_key="blog", lang="en")


@router.get("/en/blog/{slug}", response_class=HTMLResponse)
def en_blog_detail_route(slug: str, db: Session = Depends(get_db)):
    article = (
        db.query(models.Article)
        .filter(
            (models.Article.slug_en == slug)
            | ((models.Article.slug_en == "") & (models.Article.slug == slug)),
            models.Article.status == "published",
        )
        .first()
    )
    if article is None:
        # اسلاگ فارسی روی مسیر انگلیسی → مقالهٔ همان اسلاگ با slug_en → ۳۰۱ به canonical
        by_fa = (
            db.query(models.Article)
            .filter(models.Article.slug == slug, models.Article.status == "published")
            .first()
        )
        if by_fa is not None and (by_fa.slug_en or "").strip():
            return RedirectResponse(url=f"/en/blog/{by_fa.slug_en}", status_code=301)
        return _shell(
            db=db,
            title=_brand_name(db, "en"), description="", path=f"/en/blog/{slug}", lang="en",
            org_jsonld=_org_jsonld(db, "en"), status_code=404,
        )
    return _en_blog_detail(article, db)


@router.get("/en/projects", response_class=HTMLResponse)
def en_projects_list(db: Session = Depends(get_db)):
    return _static_shell(db, path="/en/projects", page_key="projects", lang="en")


@router.get("/en/projects/{slug}", response_class=HTMLResponse)
def en_project_detail(slug: str, db: Session = Depends(get_db)):
    project = db.query(models.Project).filter(models.Project.slug == slug).first()
    if project is None:
        return _shell(
            db=db,
            title=_brand_name(db, "en"), description="", path=f"/en/projects/{slug}", lang="en",
            org_jsonld=_org_jsonld(db, "en"), status_code=404,
        )

    brand = _brand_name(db, "en")
    title = project.title_en or project.title
    summary = project.summary_en or project.summary
    jsonld = [
        _project_schema(project, "en", db),
        _breadcrumb_jsonld([
            (_nav_label(db, "/", "en") or "Home", "/"),
            (_nav_label(db, "/projects", "en") or "Projects", "/en/projects"),
            (title, f"/en/projects/{project.slug}"),
        ]),
    ]
    return _shell(
        db=db,
        title=f"{title} | {brand}",
        description=summary,
        path=f"/en/projects/{project.slug}",
        lang="en",
        has_en=_project_has_en(project),
        og_image=project.image,
        og_image_alt=title,
        jsonld=jsonld,
        org_jsonld=_org_jsonld(db, "en"),
        noscript=_project_content_html(project, "en", brand),
        noindex=not _project_has_en(project),
    )


@router.get("/en/{path:path}", response_class=HTMLResponse)
def en_page(path: str, db: Session = Depends(get_db)):
    """بقیه مسیرهای انگلیسی (about، services، ...) — متا از seo_meta به انگلیسی.
    مسیرهای ناشناخته ۴۰۴ می‌گیرند — پوستهٔ ۲۰۰ با عنوان برند، خطای soft-404 است."""
    page_key = path.split("/")[0] if path else ""
    if page_key not in META_KEYS:
        return _shell(
            db=db,
            title=_brand_name(db, "en"), description="", path=f"/en/{path}".rstrip("/"), lang="en",
            org_jsonld=_org_jsonld(db, "en"), status_code=404,
        )
    return _static_shell(db, path=f"/en/{path}".rstrip("/"), page_key=page_key, lang="en")


# ---------- آرشیو ZIP تصاویر پروژه — برای دستیارهای AI و ابزارهای بیرونی ----------
# خزنده‌ها/دستیارها نمی‌توانند دکمه‌های UI را کلیک کنند؛ این مسیر هر پروژه را
# به‌صورت یک فایل ZIP با «manifest.json» ارائه می‌دهد: هر تصویر + مشخصات پروژه.
# آدرس قابل حدس: /projects/{slug}/images.zip — و فهرست کامل در /projects-images.json


def _project_images(project: models.Project) -> list[str]:
    paths: list[str] = []
    if (project.image or "").strip():
        paths.append(project.image.strip())
    for g in (project.gallery or []):
        if isinstance(g, str) and g.strip() and g.strip() not in paths:
            paths.append(g.strip())
    return paths


def _fetch_media(path: str) -> bytes | None:
    """خواندن فایل رسانه از MinIO با کلید S3 (کلید = همان مسیر /media/...).
    توجه: نام فایل‌ها فارسی‌اند؛ unquote روی کلیدِ از قبل دیکد‌شده نویسه‌ها را
    خراب می‌کند — پس هر دو شکل (خام و دیکد‌شده) امتحان می‌شود."""
    import urllib.request
    import urllib.parse

    key = path.split("/media/", 1)[-1].lstrip("/") if "/media/" in path else path.lstrip("/")
    candidates = [key]
    decoded = urllib.parse.unquote(key)
    if decoded != key:
        candidates.append(decoded)
    try:
        import boto3
        from botocore.config import Config as BotoConfig

        s3 = boto3.client(
            "s3",
            endpoint_url=settings.s3_endpoint,
            aws_access_key_id=settings.s3_access_key,
            aws_secret_access_key=settings.s3_secret_key,
            region_name="us-east-1",
            config=BotoConfig(connect_timeout=5, read_timeout=20, retries={"max_attempts": 2}),
        )
        for candidate in candidates:
            try:
                obj = s3.get_object(Bucket=settings.s3_bucket, Key=candidate)
                return obj["Body"].read()
            except Exception:
                continue
    except Exception:
        pass
    # پشتیبان: واکشی از خود سایت عمومی (مسیر کامل encode می‌شود)
    try:
        url = _absolute(urllib.parse.quote(path, safe="/"))
        req = urllib.request.Request(url, headers={"User-Agent": "ArameshArchive/1.0"})
        return urllib.request.urlopen(req, timeout=25).read()
    except Exception:
        return None


def _project_manifest(project: models.Project, files: list[tuple[str, str]]) -> dict:
    """اطلاعات هر تصویر + مشخصات پروژه — تا AI بداند هر فایل چیست."""
    title = project.title
    location = (project.location or "").strip()
    specs = {
        "سال": project.year, "موقعیت": location, "کاربری": project.usage,
        "مساحت زمین (مترمربع)": project.land_area, "زیربنا (مترمربع)": project.area,
        "تعداد طبقات": project.floors, "طبقات پیلوت": project.pilot_floors,
        "واحد مسکونی": project.units_residential, "واحد تجاری": project.units_commercial,
        "واحد اداری": project.units_office, "کارفرما": project.client,
        "وضعیت": project.status,
    }
    specs = {k: str(v).strip() for k, v in specs.items() if str(v or "").strip()}
    return {
        "project": title,
        "project_en": (project.title_en or "").strip() or None,
        "url": _absolute(f"/projects/{project.slug}"),
        "slug": project.slug,
        "specifications": specs,
        "description": (project.summary or "").strip() or None,
        "images": [
            {
                "file": fname,
                "source_url": _absolute(src),
                "caption": f"{title}" + (f"، {location}" if location else ""),
                "alt": f"{title} — {'تصویر پروژه' if True else ''}".strip(" —"),
            }
            for fname, src in files
        ],
        "license_note": "© گروه ساختمانی آرامش — تصاویر پروژههای واقعی این شرکت.",
    }


@router.get("/projects-images.json", response_class=Response)
def projects_images_index(db: Session = Depends(get_db)):
    """فهرست ماشین‌خوان همهٔ پروژه‌ها با لینک ZIP تصاویرشان — نقطهٔ ورود برای دستیارهای AI."""
    projects = db.query(models.Project).order_by(models.Project.position, models.Project.id).all()
    data = {
        "@context": "https://schema.org",
        "@type": "ItemList",
        "name": f"{_brand_name(db, 'fa')} — فهرست پروژه‌ها و تصاویر",
        "numberOfItems": len(projects),
        "itemListElement": [
            {
                "position": i + 1,
                "name": p.title,
                "page_url": _absolute(f"/projects/{p.slug}"),
                "images_zip": _absolute(f"/projects/{urllib.parse.quote(p.slug)}/images.zip"),
                "image_count": len(_project_images(p)),
                "location": (p.location or "").strip(),
                "area_m2": str(p.area) if p.area else None,
                "year": str(p.year) if p.year else None,
            }
            for i, p in enumerate(projects)
        ],
    }
    return Response(
        content=json.dumps(data, ensure_ascii=False, indent=1),
        media_type="application/json; charset=utf-8",
        headers={"Cache-Control": "no-store"},
    )


@router.get("/projects/{slug}/images.zip")
def project_images_zip(slug: str, db: Session = Depends(get_db)):
    """ZIP تصاویر یک پروژه (+ manifest.json) — برای دانلود و بررسی توسط ابزارها/AI."""
    project = db.query(models.Project).filter(models.Project.slug == slug).first()
    if project is None:
        return Response(status_code=404)

    paths = _project_images(project)
    buf = io.BytesIO()
    files: list[tuple[str, str]] = []
    seen_hashes: set[str] = set()
    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
        for src in paths:
            data = _fetch_media(src)
            if data is None:
                continue
            # تصویر تکراری (شاخص = اولین عکس گالری) دوباره در آرشیو نمی‌آید
            digest = hashlib.md5(data).hexdigest()
            if digest in seen_hashes:
                continue
            seen_hashes.add(digest)
            ext = Path(urllib.parse.unquote(src)).suffix.lower() or ".webp"
            fname = f"{len(files) + 1:02d}{ext}"
            zf.writestr(fname, data)
            files.append((fname, src))
        manifest = _project_manifest(project, files)
        zf.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=2))

    payload = buf.getvalue()
    # نام فایل ASCII امن — اسلاگ فارسی در هدر Content-Disposition نمی‌آید
    safe_name = re.sub(r"[^A-Za-z0-9._-]+", "-", project.slug).strip("-") or f"project-{project.id}"
    if not safe_name or safe_name == "-":
        safe_name = f"project-{project.id}"
    return Response(
        content=payload,
        media_type="application/zip",
        headers={
            "Content-Disposition": f'attachment; filename="{safe_name}-images.zip"',
            "Cache-Control": "public, max-age=3600",
        },
    )