"""One-off seed: registers translation_keys + hi/mr/hinglish translation_values
for the System Configuration page's PageInfoButton content (title, subtitle,
body, steps, field rules, tip).

Usage: docker compose exec api python seed_translations_pageinfo_system_configuration.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)
SYSTEM_CONFIGURATION = {
    "system-configuration.title": (
        "System Configuration",
        "सिस्टम कॉन्फ़िगरेशन",
        "सिस्टम कॉन्फिगरेशन",
        "System Configuration",
    ),
    "system-configuration.subtitle": (
        "How this register works and what each field controls",
        "यह रजिस्टर कैसे काम करता है और प्रत्येक फ़ील्ड क्या नियंत्रित करता है",
        "हे रजिस्टर कसे कार्य करते आणि प्रत्येक फील्ड काय नियंत्रित करते",
        "Ye register kaise kaam karta hai aur har field kya control karta hai",
    ),
    "system-configuration.body.0": (
        "Tenant-wide settings: system parameters (branding, thresholds, SMTP), directory sync, GST/AI Copilot integration keys, notification channels, feature toggles, and lookup codes used across the app.",
        "टेनेंट-व्यापी सेटिंग्स: सिस्टम पैरामीटर (ब्रांडिंग, थ्रेशोल्ड, SMTP), डायरेक्टरी सिंक, GST/AI Copilot इंटीग्रेशन कीज़, नोटिफ़िकेशन चैनल, फ़ीचर टॉगल, और ऐप में इस्तेमाल होने वाले लुकअप कोड।",
        "टेनंट-व्यापी सेटिंग्ज: सिस्टम पॅरामीटर्स (ब्रँडिंग, थ्रेशोल्ड, SMTP), डिरेक्टरी सिंक, GST/AI Copilot इंटिग्रेशन की, नोटिफिकेशन चॅनेल्स, फीचर टॉगल्स आणि अ‍ॅपमध्ये वापरले जाणारे लुकअप कोड.",
        "Tenant-wide settings: system parameters (branding, thresholds, SMTP), directory sync, GST/AI Copilot integration keys, notification channels, feature toggles, aur app mein use hone wale lookup codes.",
    ),
    "system-configuration.stepsHeading": (
        "What lives on each tab",
        "हर टैब में क्या है",
        "प्रत्येक टॅबमध्ये काय आहे",
        "Har tab mein kya hai",
    ),
    "system-configuration.steps.0.label": (
        "Parameters",
        "पैरामीटर",
        "पॅरामीटर्स",
        "Parameters",
    ),
    "system-configuration.steps.0.caption": (
        "Branding, mail, limits",
        "ब्रांडिंग, मेल, सीमाएँ",
        "ब्रँडिंग, मेल, मर्यादा",
        "Branding, mail, limits",
    ),
    "system-configuration.steps.1.label": (
        "Directory sync",
        "डायरेक्टरी सिंक",
        "डिरेक्टरी सिंक",
        "Directory sync",
    ),
    "system-configuration.steps.1.caption": (
        "LDAP/AD import",
        "LDAP/AD आयात",
        "LDAP/AD इंपोर्ट",
        "LDAP/AD import",
    ),
    "system-configuration.steps.2.label": (
        "Integrations",
        "इंटीग्रेशन",
        "इंटिग्रेशन्स",
        "Integrations",
    ),
    "system-configuration.steps.2.caption": (
        "GST, AI Copilot",
        "GST, AI Copilot",
        "GST, AI Copilot",
        "GST, AI Copilot",
    ),
    "system-configuration.steps.3.label": (
        "Lookup codes",
        "लुकअप कोड",
        "लुकअप कोड",
        "Lookup codes",
    ),
    "system-configuration.steps.3.caption": (
        "Shared dropdown values",
        "साझा ड्रॉपडाउन मान",
        "सामायिक ड्रॉपडाउन व्हॅल्यूज",
        "Shared dropdown values",
    ),
    "system-configuration.fieldRules.0.name": (
        "Key",
        "की",
        "की",
        "Key",
    ),
    "system-configuration.fieldRules.0.description": (
        "The parameter's stable identifier — referenced by code, don't rename.",
        "पैरामीटर का स्थायी पहचानकर्ता — कोड द्वारा संदर्भित, इसका नाम न बदलें।",
        "पॅरामीटरचा स्थिर आयडेंटिफायर — कोडद्वारे संदर्भित, याचे नाव बदलू नका.",
        "Parameter ka stable identifier — code isse reference karta hai, iska naam mat badlo.",
    ),
    "system-configuration.fieldRules.1.name": (
        "Value",
        "मान",
        "व्हॅल्यू",
        "Value",
    ),
    "system-configuration.fieldRules.1.description": (
        "Secret-flagged parameters (like SMTP password) are masked on read.",
        "सीक्रेट के रूप में चिह्नित पैरामीटर (जैसे SMTP password) पढ़ने पर मास्क कर दिए जाते हैं।",
        "सीक्रेट म्हणून चिन्हांकित पॅरामीटर्स (जसे की SMTP password) वाचताना मास्क केले जातात.",
        "Secret-flagged parameters (jaise SMTP password) read karte waqt mask ho jaate hain.",
    ),
    "system-configuration.tip.title": (
        "Secrets stay masked",
        "सीक्रेट्स मास्क ही रहते हैं",
        "सीक्रेट्स मास्क्ड राहतात",
        "Secrets masked hi rehte hain",
    ),
    "system-configuration.tip.body": (
        "Editing a secret parameter (e.g. SMTP_PASSWORD) starts blank — leaving it blank keeps the existing value; you can't accidentally overwrite it with the mask.",
        "किसी सीक्रेट पैरामीटर (जैसे SMTP_PASSWORD) को एडिट करना खाली शुरू होता है — इसे खाली छोड़ने पर मौजूदा मान बना रहता है; आप गलती से मास्क के साथ इसे ओवरराइट नहीं कर सकते।",
        "एखादा सीक्रेट पॅरामीटर (उदा. SMTP_PASSWORD) संपादित करणे रिकाम्यापासून सुरू होते — तो रिकामा ठेवल्यास विद्यमान व्हॅल्यू कायम राहते; तुम्ही चुकून मास्कने तो ओव्हरराईट करू शकत नाही.",
        "Secret parameter (jaise SMTP_PASSWORD) edit karna blank se start hota hai — blank chhodne par existing value wahi rehti hai; aap galti se mask ke saath overwrite nahi kar sakte.",
    ),
}


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 SYSTEM_CONFIGURATION.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(SYSTEM_CONFIGURATION)} keys.")


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