"""One-off seed: registers translation_keys + hi/mr/hinglish translation_values
for the PageInfoButton content on the Platform Administration page (pageKey="platform-admin").

Usage: docker compose exec api python seed_translations_pageinfo_platform_admin.py
"""
import asyncio
import uuid
from datetime import datetime, timezone

from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine

from ams.core.config import settings

NAMESPACE = "help"

# key -> (english, hi, mr, hinglish)
PLATFORM_ADMIN = {
    "platform-admin.title": (
        "Platform Administration",
        "प्लेटफ़ॉर्म प्रशासन",
        "प्लॅटफॉर्म प्रशासन",
        "Platform Administration",
    ),
    "platform-admin.subtitle": (
        "How this register works and what each field controls",
        "यह रजिस्टर कैसे काम करता है और प्रत्येक फ़ील्ड क्या नियंत्रित करता है",
        "हे रजिस्टर कसे कार्य करते आणि प्रत्येक फील्ड काय नियंत्रित करते",
        "Ye register kaise kaam karta hai aur har field kya control karta hai",
    ),
    "platform-admin.body.0": (
        "Cross-tenant operations for platform operators: live health of the API, database, cache and storage, plus creating and looking up tenants. Most tenant admins never see this page.",
        "प्लेटफ़ॉर्म ऑपरेटर्स के लिए क्रॉस-टेनेंट कार्य: API, डेटाबेस, कैश और स्टोरेज की लाइव हेल्थ, साथ ही टेनेंट बनाना और खोजना। अधिकांश टेनेंट एडमिन कभी यह पेज नहीं देखते।",
        "प्लॅटफॉर्म ऑपरेटर्ससाठी क्रॉस-टेनंट कामकाज: API, डेटाबेस, कॅशे आणि स्टोरेजची लाइव्ह हेल्थ, तसेच टेनंट तयार करणे आणि शोधणे. बहुतांश टेनंट अ‍ॅडमिन हे पान कधीच पाहत नाहीत.",
        "Platform operators ke liye cross-tenant operations: API, database, cache aur storage ki live health, plus tenants create karna aur lookup karna. Zyada tar tenant admins ye page kabhi nahi dekhte.",
    ),
    "platform-admin.stepsHeading": (
        "What you can do here",
        "आप यहाँ क्या कर सकते हैं",
        "तुम्ही इथे काय करू शकता",
        "Aap yahan kya kar sakte hain",
    ),
    "platform-admin.steps.0.label": (
        "Check health",
        "स्वास्थ्य जाँचें",
        "आरोग्य तपासा",
        "Health check karein",
    ),
    "platform-admin.steps.0.caption": (
        "DB, cache, storage",
        "डेटाबेस, कैश, स्टोरेज",
        "डेटाबेस, कॅशे, स्टोरेज",
        "DB, cache, storage",
    ),
    "platform-admin.steps.1.label": (
        "Provision",
        "प्रोविज़न करें",
        "प्रोव्हिजन करा",
        "Provision karein",
    ),
    "platform-admin.steps.1.caption": (
        "Create a tenant",
        "एक टेनेंट बनाएँ",
        "एक टेनंट तयार करा",
        "Ek tenant create karein",
    ),
    "platform-admin.steps.2.label": (
        "Look up",
        "खोजें",
        "शोधा",
        "Lookup karein",
    ),
    "platform-admin.steps.2.caption": (
        "Find by tenant ID",
        "टेनेंट ID से खोजें",
        "टेनंट ID द्वारे शोधा",
        "Tenant ID se find karein",
    ),
    "platform-admin.fieldRules.0.name": (
        "Slug",
        "स्लग",
        "स्लग",
        "Slug",
    ),
    "platform-admin.fieldRules.0.description": (
        "The tenant's login identifier — must be unique across the whole platform.",
        "टेनेंट का लॉगिन पहचानकर्ता — पूरे प्लेटफ़ॉर्म में अद्वितीय होना चाहिए।",
        "टेनंटचा लॉगिन ओळखकर्ता — संपूर्ण प्लॅटफॉर्मवर अद्वितीय असणे आवश्यक आहे.",
        "Tenant ka login identifier — poore platform mein unique hona chahiye.",
    ),
    "platform-admin.fieldRules.1.name": (
        "Plan",
        "प्लान",
        "प्लॅन",
        "Plan",
    ),
    "platform-admin.fieldRules.1.description": (
        "Starter, Professional, or Enterprise — governs feature/usage limits.",
        "स्टार्टर, प्रोफेशनल, या एंटरप्राइज़ — फ़ीचर/उपयोग सीमाएँ तय करता है।",
        "स्टार्टर, प्रोफेशनल, किंवा एंटरप्राइझ — फीचर/वापर मर्यादा ठरवते.",
        "Starter, Professional, ya Enterprise — feature/usage limits decide karta hai.",
    ),
    "platform-admin.tip.title": (
        "This is cross-tenant",
        "यह क्रॉस-टेनेंट है",
        "हे क्रॉस-टेनंट आहे",
        "Ye cross-tenant hai",
    ),
    "platform-admin.tip.body": (
        "Unlike every other page in the app, actions here aren't scoped to one tenant — provisioning creates a brand new, fully isolated organization.",
        "ऐप के हर दूसरे पेज के विपरीत, यहाँ की गतिविधियाँ किसी एक टेनेंट तक सीमित नहीं हैं — प्रोविज़निंग एक बिल्कुल नया, पूरी तरह से अलग संगठन बनाती है।",
        "अ‍ॅपमधील इतर प्रत्येक पानाच्या विपरीत, इथल्या क्रिया एका टेनंटपुरत्या मर्यादित नाहीत — प्रोव्हिजनिंगमुळे एक अगदी नवीन, पूर्णपणे स्वतंत्र संस्था तयार होते.",
        "App ke har doosre page ke ulat, yahan ki actions ek tenant tak limited nahi hain — provisioning ek bilkul naya, poori tarah se isolated organization create karti hai.",
    ),
}


async def seed_for_session(session: AsyncSession) -> tuple[int, int]:
    now = datetime.now(timezone.utc)
    keys_upserted = 0
    values_upserted = 0
    for key, (en, hi, mr, hinglish) in PLATFORM_ADMIN.items():
        key_id = (await session.execute(
            text("SELECT id FROM translation_keys WHERE namespace = :ns AND key = :key"),
            {"ns": NAMESPACE, "key": key},
        )).scalar_one_or_none()
        if key_id:
            await session.execute(
                text("UPDATE translation_keys SET source_text = :src WHERE id = :id"),
                {"src": en, "id": key_id},
            )
        else:
            key_id = str(uuid.uuid4())
            await session.execute(
                text("""INSERT INTO translation_keys (id, namespace, key, source_text, created_at)
                        VALUES (:id, :ns, :key, :src, :now)"""),
                {"id": key_id, "ns": NAMESPACE, "key": key, "src": en, "now": now},
            )
            keys_upserted += 1

        for lang_code, value in (("hi", hi), ("mr", mr), ("hinglish", hinglish)):
            existing = (await session.execute(
                text("SELECT id FROM translation_values WHERE key_id = :kid AND language_code = :lc"),
                {"kid": key_id, "lc": lang_code},
            )).scalar_one_or_none()
            if existing:
                await session.execute(
                    text("UPDATE translation_values SET value = :val, updated_at = :now WHERE id = :id"),
                    {"val": value, "now": now, "id": existing},
                )
            else:
                await session.execute(
                    text("""INSERT INTO translation_values (id, key_id, language_code, value, updated_by, updated_at)
                            VALUES (:id, :kid, :lc, :val, NULL, :now)"""),
                    {"id": str(uuid.uuid4()), "kid": key_id, "lc": lang_code, "val": value, "now": now},
                )
                values_upserted += 1
    await session.commit()
    return keys_upserted, values_upserted


async def main() -> None:
    engine = create_async_engine(settings.DATABASE_URL, echo=False)
    Session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

    async with Session() as session:
        tenants = (await session.execute(
            text("SELECT id::text AS id, slug FROM public.tenants WHERE status != 'archived'")
        )).fetchall()

    for tenant in tenants:
        schema = f"tenant_{tenant.id.replace('-', '_')}"
        async with Session() as session:
            await session.execute(text(f"SET search_path TO {schema}, public"))
            try:
                k, v = await seed_for_session(session)
                print(f"  seeded {k} new keys, {v} new values: {tenant.slug}")
            except Exception as exc:
                print(f"  SKIPPED {tenant.slug}: {exc}")
                await session.rollback()

    await engine.dispose()
    print(f"Done — {len(tenants)} tenant(s) processed, {len(PLATFORM_ADMIN)} platform-admin keys.")


if __name__ == "__main__":
    asyncio.run(main())