"""One-off seed: registers translation_keys English source_text and hi/mr/hinglish
translation_values for the "roles-create" PageInfoButton content.

Usage: docker compose exec api python seed_translations_pageinfo_roles_create.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)
ROLES_CREATE = {
    "roles-create.title": (
        "Create Role",
        "Role बनाएं",
        "Role तयार करा",
        "Role Create Karein",
    ),
    "roles-create.subtitle": (
        "Define a role's name and the permissions it grants",
        "किसी Role का नाम और वह कौन-सी permissions देता है, यह परिभाषित करें",
        "एखाद्या Role चे नाव आणि तो कोणत्या permissions देतो, हे परिभाषित करा",
        "Kisi Role ka naam aur wo kaunsi permissions deta hai, define karein",
    ),
    "roles-create.body.0": (
        "A role bundles a set of permission keys under one name. Once saved, assign it to users from Administration → Users so they inherit exactly what's checked here — nothing more.",
        "एक Role, permission keys के एक समूह को एक नाम के अंतर्गत बंडल करता है। सेव करने के बाद, इसे Administration → Users से users को असाइन करें ताकि उन्हें ठीक वही मिले जो यहाँ चेक किया गया है — इससे ज़्यादा कुछ नहीं।",
        "एक Role, permission keys च्या संचाला एका नावाखाली बंडल करते. सेव केल्यानंतर, ते Administration → Users मधून users ला असाइन करा जेणेकरून त्यांना इथे नेमके जे चेक केले आहे तेच मिळेल — यापेक्षा जास्त काही नाही.",
        "Ek Role, permission keys ke ek set ko ek naam ke andar bundle karta hai. Save karne ke baad, ise Administration → Users se users ko assign karein taaki unhe exactly wahi mile jo yahan check kiya gaya hai — isse zyada kuch nahi.",
    ),
    "roles-create.body.1": (
        "Permissions load from the live catalog, grouped by module, so the list always matches what the backend actually enforces.",
        "Permissions live catalog से लोड होती हैं, module के अनुसार समूहीकृत, ताकि यह लिस्ट हमेशा वही दर्शाए जो backend वास्तव में लागू करता है।",
        "Permissions live catalog मधून लोड होतात, module नुसार गटबद्ध, जेणेकरून यादी नेहमी तेच दाखवते जे backend प्रत्यक्षात लागू करते.",
        "Permissions live catalog se load hoti hain, module ke hisaab se grouped, taaki list hamesha wahi dikhaye jo backend actually enforce karta hai.",
    ),
    "roles-create.stepsHeading": (
        "How creating a role works",
        "Role बनाना कैसे काम करता है",
        "Role तयार करणे कसे कार्य करते",
        "Role banana kaise kaam karta hai",
    ),
    "roles-create.steps.0.label": (
        "Name the Role",
        "Role को नाम दें",
        "Role ला नाव द्या",
        "Role ko naam dein",
    ),
    "roles-create.steps.0.caption": (
        "Short, unique label, e.g. \"Auditor\".",
        "छोटा, अद्वितीय लेबल, जैसे \"Auditor\"।",
        "लहान, अद्वितीय लेबल, उदा. \"Auditor\".",
        "Chota, unique label, jaise \"Auditor\".",
    ),
    "roles-create.steps.1.label": (
        "Browse Modules",
        "Modules ब्राउज़ करें",
        "Modules ब्राउझ करा",
        "Modules browse karein",
    ),
    "roles-create.steps.1.caption": (
        "Permissions grouped by module; search filters key, label, description.",
        "Permissions module के अनुसार समूहीकृत हैं; search key, label, description को फ़िल्टर करता है।",
        "Permissions module नुसार गटबद्ध आहेत; search key, label, description फिल्टर करते.",
        "Permissions module ke hisaab se grouped hain; search key, label, description ko filter karta hai.",
    ),
    "roles-create.steps.2.label": (
        "Select Permissions",
        "Permissions चुनें",
        "Permissions निवडा",
        "Permissions select karein",
    ),
    "roles-create.steps.2.caption": (
        "Check individual keys or toggle a whole module at once.",
        "अलग-अलग keys चेक करें या एक साथ पूरे module को टॉगल करें।",
        "वैयक्तिक keys चेक करा किंवा एकाच वेळी संपूर्ण module टॉगल करा.",
        "Individual keys check karein ya ek saath poore module ko toggle karein.",
    ),
    "roles-create.steps.3.label": (
        "Review Summary",
        "Summary की समीक्षा करें",
        "Summary चा आढावा घ्या",
        "Summary review karein",
    ),
    "roles-create.steps.3.caption": (
        "Right panel shows the role name and live selected-key count.",
        "दायाँ पैनल Role का नाम और लाइव सिलेक्टेड-key count दिखाता है।",
        "उजवा पॅनल Role चे नाव आणि लाइव्ह सिलेक्टेड-key count दाखवतो.",
        "Right panel Role ka naam aur live selected-key count dikhata hai.",
    ),
    "roles-create.steps.4.label": (
        "Save Role",
        "Role सेव करें",
        "Role सेव्ह करा",
        "Role Save karein",
    ),
    "roles-create.steps.4.caption": (
        "Submits name + selected keys, then returns to the Roles list.",
        "नाम + चुनी गई keys सबमिट करता है, फिर Roles लिस्ट पर वापस लौटता है।",
        "नाव + निवडलेल्या keys सबमिट करते, नंतर Roles यादीवर परत जाते.",
        "Naam + selected keys submit karta hai, phir Roles list par wapas le jaata hai.",
    ),
    "roles-create.fieldRules.0.name": (
        "Role Name",
        "Role का नाम",
        "Role चे नाव",
        "Role Name",
    ),
    "roles-create.fieldRules.0.description": (
        "Free-text label for the role; trimmed and required before Save is allowed.",
        "Role के लिए फ्री-टेक्स्ट लेबल; Save की अनुमति मिलने से पहले ट्रिम और अनिवार्य किया जाता है।",
        "Role साठी फ्री-टेक्स्ट लेबल; Save ला परवानगी देण्याआधी ट्रिम आणि अनिवार्य केले जाते.",
        "Role ke liye free-text label; Save allow hone se pehle trim aur required hota hai.",
    ),
    "roles-create.fieldRules.1.name": (
        "Permissions Matrix",
        "Permissions मैट्रिक्स",
        "Permissions मॅट्रिक्स",
        "Permissions Matrix",
    ),
    "roles-create.fieldRules.1.description": (
        "Checkboxes grouped by module; each checked key becomes a granted permission on the role.",
        "Checkboxes module के अनुसार समूहीकृत हैं; प्रत्येक चेक की गई key Role पर एक दी गई permission बन जाती है।",
        "Checkboxes module नुसार गटबद्ध आहेत; प्रत्येक चेक केलेली key Role वर एक दिलेली permission बनते.",
        "Checkboxes module ke hisaab se grouped hain; har checked key Role par ek granted permission ban jaati hai.",
    ),
    "roles-create.fieldRules.2.name": (
        "Module Group Checkbox",
        "Module ग्रुप चेकबॉक्स",
        "Module ग्रुप चेकबॉक्स",
        "Module Group Checkbox",
    ),
    "roles-create.fieldRules.2.description": (
        "Selects or clears every permission in that module at once; shows an indeterminate state when only some are checked.",
        "उस module की सभी permissions को एक साथ चुनता या साफ़ करता है; जब केवल कुछ चेक हों तो indeterminate स्थिति दिखाता है।",
        "त्या module मधील सर्व permissions एकाच वेळी निवडते किंवा साफ करते; फक्त काही चेक असल्यास indeterminate स्थिती दाखवते.",
        "Us module ki saari permissions ek saath select ya clear karta hai; jab sirf kuch check hon to indeterminate state dikhata hai.",
    ),
    "roles-create.fieldRules.3.name": (
        "Selection Summary",
        "सिलेक्शन सारांश",
        "सिलेक्शन सारांश",
        "Selection Summary",
    ),
    "roles-create.fieldRules.3.description": (
        "Live count of selected permission keys, shown before you submit.",
        "चुनी गई permission keys की लाइव गिनती, सबमिट करने से पहले दिखाई जाती है।",
        "निवडलेल्या permission keys ची लाइव्ह संख्या, सबमिट करण्यापूर्वी दाखवली जाते.",
        "Selected permission keys ka live count, submit karne se pehle dikhaya jaata hai.",
    ),
    "roles-create.tip.title": (
        "Empty roles save fine",
        "खाली Roles भी ठीक से सेव होते हैं",
        "रिकाम्या Roles देखील व्यवस्थित सेव्ह होतात",
        "Empty Roles bhi fine save ho jaate hain",
    ),
    "roles-create.tip.body": (
        "Unchecking every permission doesn't block Save — the form submits an empty permissions array and creates a role with zero access. Check the Selection Summary count before saving.",
        "हर permission को अनचेक करने से Save नहीं रुकता — फ़ॉर्म एक खाली permissions array सबमिट करता है और शून्य access वाला Role बना देता है। सेव करने से पहले Selection Summary count ज़रूर जाँचें।",
        "प्रत्येक permission अनचेक केल्याने Save अडत नाही — फॉर्म एक रिकामी permissions array सबमिट करतो आणि शून्य access असलेली Role तयार करतो. सेव्ह करण्यापूर्वी Selection Summary count नक्की तपासा.",
        "Har permission uncheck karne se Save block nahi hota — form ek empty permissions array submit karta hai aur zero access wala Role bana deta hai. Save karne se pehle Selection Summary count zaroor check karein.",
    ),
}


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 ROLES_CREATE.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(ROLES_CREATE)} roles-create keys.")


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