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

Usage: docker compose exec api python seed_translations_pageinfo_validation_errors.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)
VALIDATION_ERRORS = {
    "validation-errors.title": (
        "Check a Bulk Upload",
        "बल्क अपलोड जाँचें",
        "बल्क अपलोड तपासा",
        "Bulk Upload Check Karein",
    ),
    "validation-errors.subtitle": (
        "Look up the row-by-row result of an asset spreadsheet upload",
        "asset spreadsheet अपलोड का row-by-row परिणाम देखें",
        "asset spreadsheet अपलोडचा row-by-row निकाल पहा",
        "Asset spreadsheet upload ka row-by-row result dekhein",
    ),
    "validation-errors.body.0": (
        "Uploaded a spreadsheet of assets? Paste its reference number below to see which rows went in and which had a problem, so you can fix and re-upload those rows.",
        "assets की कोई spreadsheet अपलोड की है? नीचे उसका reference number पेस्ट करें ताकि देख सकें कि कौन-सी rows सफलतापूर्वक जुड़ीं और किनमें समस्या आई, ताकि आप उन rows को ठीक करके फिर से अपलोड कर सकें।",
        "assets ची एखादी spreadsheet अपलोड केली आहे का? खाली तिचा reference number पेस्ट करा जेणेकरून कोणत्या rows यशस्वीरित्या जोडल्या गेल्या आणि कोणत्यामध्ये समस्या आली हे कळेल, जेणेकरून तुम्ही त्या rows दुरुस्त करून पुन्हा अपलोड करू शकाल.",
        "Assets ki koi spreadsheet upload ki hai? Neeche uska reference number paste karein taaki dekh sakein ki kaunsi rows successfully add hui aur kaunsi mein problem aayi, taaki aap un rows ko fix karke dobara upload kar sakein.",
    ),
    "validation-errors.stepsHeading": (
        "From upload to fixed rows",
        "अपलोड से लेकर rows ठीक होने तक",
        "अपलोडपासून rows दुरुस्त होईपर्यंत",
        "Upload se fixed rows tak",
    ),
    "validation-errors.steps.0.label": ("Upload", "अपलोड", "अपलोड", "Upload"),
    "validation-errors.steps.0.caption": (
        "Use Bulk Import on any asset list page to upload your spreadsheet.",
        "अपनी spreadsheet अपलोड करने के लिए किसी भी asset list page पर Bulk Import का उपयोग करें।",
        "तुमची spreadsheet अपलोड करण्यासाठी कोणत्याही asset list page वर Bulk Import वापरा.",
        "Apni spreadsheet upload karne ke liye kisi bhi asset list page par Bulk Import use karein.",
    ),
    "validation-errors.steps.1.label": ("Get reference", "reference प्राप्त करें", "reference मिळवा", "Reference number lein"),
    "validation-errors.steps.1.caption": (
        "The upload returns a reference number — copy it.",
        "अपलोड होने पर एक reference number मिलता है — उसे कॉपी करें।",
        "अपलोड झाल्यावर एक reference number मिळतो — तो कॉपी करा.",
        "Upload hone par ek reference number milta hai — use copy kar lein.",
    ),
    "validation-errors.steps.2.label": ("Check here", "यहाँ जाँचें", "इथे तपासा", "Yahan Check Karein"),
    "validation-errors.steps.2.caption": (
        "Paste it (or pick a recent one) to see what was added and what failed.",
        "यह देखने के लिए कि क्या जुड़ा और क्या असफल रहा, उसे पेस्ट करें (या किसी recent वाले को चुनें)।",
        "काय जोडले गेले आणि काय अयशस्वी झाले हे पाहण्यासाठी तो पेस्ट करा (किंवा एखादा recent निवडा).",
        "Kya add hua aur kya fail hua ye dekhne ke liye use paste karein (ya koi recent wala select karein).",
    ),
    "validation-errors.steps.3.label": ("Fix & re-upload", "ठीक करें और फिर से अपलोड करें", "दुरुस्त करा आणि पुन्हा अपलोड करा", "Fix Karein & Re-upload Karein"),
    "validation-errors.steps.3.caption": (
        "Correct the flagged rows in your spreadsheet and upload it again.",
        "अपनी spreadsheet में flag की गई rows को ठीक करें और इसे फिर से अपलोड करें।",
        "तुमच्या spreadsheet मधील flag केलेल्या rows दुरुस्त करा आणि ती पुन्हा अपलोड करा.",
        "Apni spreadsheet mein flag hui rows ko correct karein aur use dobara upload karein.",
    ),
    "validation-errors.fieldRules.0.name": (
        "Import reference number",
        "इम्पोर्ट रेफरेंस नंबर",
        "इम्पोर्ट रेफरन्स नंबर",
        "Import reference number",
    ),
    "validation-errors.fieldRules.0.description": (
        "The code returned right after upload; without it there's nothing to look up.",
        "यह वह code है जो अपलोड के तुरंत बाद मिलता है; इसके बिना कुछ भी देखा नहीं जा सकता।",
        "अपलोडनंतर लगेच मिळणारा हा code आहे; याशिवाय काहीही तपासता येणार नाही.",
        "Ye wo code hai jo upload ke turant baad milta hai; iske bina kuch bhi lookup nahi ho sakta.",
    ),
    "validation-errors.fieldRules.1.name": ("Which row", "कौन-सी row", "कोणती row", "Kaunsi row"),
    "validation-errors.fieldRules.1.description": (
        "The spreadsheet row number the problem was found on (matches your file's rows).",
        "spreadsheet की वह row number जिस पर समस्या मिली (आपकी file की rows से मेल खाती है)।",
        "spreadsheet मधील ती row number जिथे समस्या आढळली (तुमच्या file च्या rows शी जुळते).",
        "Spreadsheet ki wo row number jahan problem mili (aapki file ki rows se match karti hai).",
    ),
    "validation-errors.fieldRules.2.name": ("Which field", "कौन-सा field", "कोणते field", "Kaunsa field"),
    "validation-errors.fieldRules.2.description": (
        "The column/field on that row that failed validation, e.g. Funding Source or Location.",
        "उस row का column/field जिसने validation पास नहीं की, जैसे Funding Source या Location।",
        "त्या row मधील column/field ज्याने validation पास केली नाही, उदा. Funding Source किंवा Location.",
        "Us row ka column/field jisne validation fail ki, jaise Funding Source ya Location.",
    ),
    "validation-errors.fieldRules.3.name": ("What needs fixing", "क्या ठीक करना है", "काय दुरुस्त करायचे आहे", "Kya fix karna hai"),
    "validation-errors.fieldRules.3.description": (
        "Plain-English reason the row was rejected, straight from the server-side check.",
        "row के reject होने का सीधा कारण, server-side check से सीधे लिया गया।",
        "row नाकारली जाण्याचे थेट कारण, server-side check मधून थेट मिळालेले.",
        "Row reject hone ki seedhi wajah, server-side check se direct aayi hui.",
    ),
    "validation-errors.tip.title": (
        "Recent list is local to this browser",
        "Recent list सिर्फ इसी browser में स्थानीय है",
        "Recent list फक्त याच browser मध्ये स्थानिक आहे",
        "Recent list sirf isi browser tak local hai",
    ),
    "validation-errors.tip.body": (
        'The "Recent" shortcuts are saved only in this browser\'s storage — they won\'t show up on another device or for another user. Keep the reference number itself (from the upload confirmation) if you need to check it elsewhere.',
        'यह "Recent" shortcuts केवल इसी browser के storage में सेव होते हैं — ये किसी दूसरे device या दूसरे user के लिए नहीं दिखेंगे। अगर कहीं और जाँच करनी हो तो upload confirmation वाला reference number खुद संभालकर रखें।',
        'ही "Recent" shortcuts फक्त याच browser च्या storage मध्ये सेव्ह होतात — ती दुसऱ्या device वर किंवा दुसऱ्या user साठी दिसणार नाहीत. जर कुठे दुसरीकडे तपासायचे असेल तर upload confirmation मधील reference number स्वतः जपून ठेवा.',
        '"Recent" shortcuts sirf isi browser ke storage mein save hote hain — ye kisi doosre device ya doosre user ke liye nahi dikhenge. Agar kahin aur check karna ho to upload confirmation wala reference number khud sambhal kar rakhein.',
    ),
}


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 VALIDATION_ERRORS.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(VALIDATION_ERRORS)} validation-errors keys.")


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