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

Usage: docker compose exec api python seed_translations_pageinfo_custody_acknowledgements.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)
CUSTODY_ACKNOWLEDGEMENTS = {
    "custody-acknowledgements.title": (
        "Pending Acknowledgements",
        "लंबित पावतियाँ",
        "प्रलंबित पावत्या",
        "Pending Acknowledgements",
    ),
    "custody-acknowledgements.subtitle": (
        "Confirm you still hold the assets assigned to you",
        "पुष्टि करें कि आपको सौंपे गए assets अभी भी आपके पास हैं",
        "तुम्हाला नियुक्त केलेल्या assets अजूनही तुमच्याकडे आहेत याची पुष्टी करा",
        "Confirm karein ki aapko assign kiye gaye assets abhi bhi aapke paas hain",
    ),
    "custody-acknowledgements.body.0": (
        "Assets not yet re-acknowledged by their custodian this fiscal year.",
        "वे assets जिन्हें इस fiscal year में उनके custodian द्वारा अभी तक दोबारा acknowledge नहीं किया गया है।",
        "ज्या assets ची या fiscal year मध्ये त्यांच्या custodian कडून अद्याप पुन्हा acknowledge केलेली नाही अशा assets.",
        "Wo assets jinhe is fiscal year mein unke custodian ne abhi tak dobara acknowledge nahi kiya hai.",
    ),
    "custody-acknowledgements.body.1": (
        "Managers and admins can select a different custodian above to review someone else's pending list, but the Acknowledge action always applies to your own logged-in account — that's enforced by the backend, not just the UI.",
        "Managers और admins ऊपर किसी अन्य custodian को चुनकर किसी और की pending list देख सकते हैं, लेकिन Acknowledge action हमेशा आपके अपने logged-in account पर ही लागू होता है — यह सिर्फ UI में नहीं बल्कि backend द्वारा भी सुनिश्चित किया जाता है।",
        "Managers आणि admins वर एखादा वेगळा custodian निवडून दुसऱ्याची pending list पाहू शकतात, पण Acknowledge action नेहमी तुमच्या स्वतःच्या logged-in account वरच लागू होते — हे फक्त UI मध्ये नाही तर backend कडूनही सुनिश्चित केले जाते.",
        "Managers aur admins upar koi different custodian select karke kisi aur ki pending list review kar sakte hain, lekin Acknowledge action hamesha aapke apne logged-in account par hi apply hota hai — ye sirf UI mein nahi, balki backend se bhi enforce hota hai.",
    ),
    "custody-acknowledgements.stepsHeading": (
        "How acknowledgement works",
        "Acknowledgement कैसे काम करता है",
        "Acknowledgement कसे कार्य करते",
        "Acknowledgement kaise kaam karta hai",
    ),
    "custody-acknowledgements.steps.0.label": (
        "Select Custodian",
        "Custodian चुनें",
        "Custodian निवडा",
        "Custodian select karein",
    ),
    "custody-acknowledgements.steps.0.caption": (
        "Managers/admins only — changes which list you view",
        "केवल Managers/admins के लिए — यह तय करता है कि आप कौन-सी list देखते हैं",
        "फक्त Managers/admins साठी — तुम्ही कोणती list पाहता हे बदलते",
        "Sirf Managers/admins ke liye — ye change karta hai ki aap kaunsi list dekhte hain",
    ),
    "custody-acknowledgements.steps.1.label": (
        "Review List",
        "List की समीक्षा करें",
        "List चा आढावा घ्या",
        "List review karein",
    ),
    "custody-acknowledgements.steps.1.caption": (
        "Assets not yet re-acknowledged this fiscal year",
        "इस fiscal year में अभी तक दोबारा acknowledge न किए गए assets",
        "या fiscal year मध्ये अद्याप पुन्हा acknowledge न केलेल्या assets",
        "Is fiscal year mein abhi tak dobara acknowledge na hue assets",
    ),
    "custody-acknowledgements.steps.2.label": (
        "Select Assets",
        "Assets चुनें",
        "Assets निवडा",
        "Assets select karein",
    ),
    "custody-acknowledgements.steps.2.caption": (
        "Check each asset you still physically hold",
        "हर उस asset को चेक करें जो अभी भी आपके पास भौतिक रूप से है",
        "जी asset अजूनही तुमच्याकडे प्रत्यक्षात आहे ती प्रत्येक asset चेक करा",
        "Har us asset ko check karein jo abhi bhi aapke paas physically hai",
    ),
    "custody-acknowledgements.steps.3.label": (
        "Acknowledge",
        "Acknowledge करें",
        "Acknowledge करा",
        "Acknowledge karein",
    ),
    "custody-acknowledgements.steps.3.caption": (
        "Confirms possession for the current fiscal year",
        "वर्तमान fiscal year के लिए कब्ज़े की पुष्टि करता है",
        "सध्याच्या fiscal year साठी ताब्याची पुष्टी करते",
        "Current fiscal year ke liye possession confirm karta hai",
    ),
    "custody-acknowledgements.fieldRules.0.name": (
        "Custodian",
        "Custodian",
        "Custodian",
        "Custodian",
    ),
    "custody-acknowledgements.fieldRules.0.description": (
        "Filters which custodian's pending list is shown; only visible with manager/admin permissions.",
        "यह तय करता है कि किस custodian की pending list दिखाई जाए; यह केवल manager/admin permissions होने पर ही दिखता है।",
        "कोणत्या custodian ची pending list दाखवायची हे हे ठरवते; हे फक्त manager/admin permissions असल्यासच दिसते.",
        "Ye filter karta hai ki kis custodian ki pending list dikhayi jaaye; ye sirf manager/admin permissions hone par hi dikhta hai.",
    ),
    "custody-acknowledgements.fieldRules.1.name": (
        "Asset checkbox",
        "Asset checkbox",
        "Asset checkbox",
        "Asset checkbox",
    ),
    "custody-acknowledgements.fieldRules.1.description": (
        "At least one must be checked to enable the Acknowledge button.",
        "Acknowledge बटन को सक्षम करने के लिए कम से कम एक checkbox चेक होना चाहिए।",
        "Acknowledge बटण सक्षम करण्यासाठी किमान एक checkbox चेक केलेला असावा.",
        "Acknowledge button enable karne ke liye kam se kam ek checkbox check hona chahiye.",
    ),
    "custody-acknowledgements.fieldRules.2.name": (
        "Since",
        "कब से",
        "केव्हापासून",
        "Since",
    ),
    "custody-acknowledgements.fieldRules.2.description": (
        "Date the asset became due for re-acknowledgement this fiscal year.",
        "वह तारीख जब asset इस fiscal year में दोबारा acknowledge किए जाने के लिए due हुआ।",
        "ज्या तारखेला asset या fiscal year मध्ये पुन्हा acknowledge करण्यासाठी due झाली ती तारीख.",
        "Wo date jab asset is fiscal year mein dobara acknowledge hone ke liye due hua.",
    ),
    "custody-acknowledgements.tip.title": (
        "Viewing another custodian's list",
        "किसी अन्य custodian की list देखना",
        "दुसऱ्या custodian ची list पाहणे",
        "Kisi aur custodian ki list dekhna",
    ),
    "custody-acknowledgements.tip.body": (
        "Checkboxes are disabled and the Acknowledge button won't submit while you're viewing someone else's list — switch the Custodian picker back to your own name to actually acknowledge assets.",
        "जब तक आप किसी और की list देख रहे हैं, checkboxes disabled रहते हैं और Acknowledge बटन submit नहीं होगा — assets को वास्तव में acknowledge करने के लिए Custodian picker को वापस अपने नाम पर सेट करें।",
        "तुम्ही दुसऱ्याची list पाहत असताना checkboxes disabled असतात आणि Acknowledge बटण submit होणार नाही — assets प्रत्यक्षात acknowledge करण्यासाठी Custodian picker तुमच्या स्वतःच्या नावावर परत सेट करा.",
        "Jab tak aap kisi aur ki list dekh rahe hain, checkboxes disabled rehte hain aur Acknowledge button submit nahi hoga — assets ko actually acknowledge karne ke liye Custodian picker ko wapas apne naam par switch 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 CUSTODY_ACKNOWLEDGEMENTS.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(CUSTODY_ACKNOWLEDGEMENTS)} custody-acknowledgements keys.")


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