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

Usage: docker compose exec api python seed_translations_pageinfo_verification_cycles.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)
VERIFICATION_CYCLES = {
    "verification-cycles.title": (
        "Verification Cycles",
        "सत्यापन चक्र",
        "पडताळणी चक्र",
        "Verification Cycles",
    ),
    "verification-cycles.subtitle": (
        "Plan and certify the annual physical asset count",
        "वार्षिक भौतिक asset गणना की योजना बनाएं और प्रमाणित करें",
        "वार्षिक भौतिक asset मोजणीचे नियोजन करा आणि प्रमाणित करा",
        "Annual physical asset count ko plan karein aur certify karein",
    ),
    "verification-cycles.body.0": (
        "Annual physical verification of fixed assets (GFR 2017, Rule 190).",
        "स्थिर assets (fixed assets) का वार्षिक भौतिक सत्यापन (GFR 2017, Rule 190)।",
        "स्थिर assets (fixed assets) ची वार्षिक भौतिक पडताळणी (GFR 2017, Rule 190).",
        "Fixed assets ka annual physical verification (GFR 2017, Rule 190).",
    ),
    "verification-cycles.body.1": (
        "Create a cycle here, run the fieldwork on the Verification Plans workflow, then come back to generate the signed Physical Verification Report.",
        "यहाँ एक cycle बनाएं, Verification Plans workflow पर fieldwork चलाएं, फिर हस्ताक्षरित (signed) Physical Verification Report जनरेट करने के लिए वापस आएं।",
        "येथे एक cycle तयार करा, Verification Plans workflow वर fieldwork चालवा, नंतर स्वाक्षरीकृत (signed) Physical Verification Report तयार करण्यासाठी परत या.",
        "Yahan ek cycle create karein, Verification Plans workflow par fieldwork run karein, phir signed Physical Verification Report generate karne ke liye wapas aayein.",
    ),
    "verification-cycles.stepsHeading": (
        "Cycle lifecycle",
        "Cycle जीवनचक्र",
        "Cycle जीवनचक्र",
        "Cycle lifecycle",
    ),
    "verification-cycles.steps.0.label": ("Draft", "ड्राफ्ट", "ड्राफ्ट", "Draft"),
    "verification-cycles.steps.0.caption": (
        "Cycle created; fieldwork not started",
        "Cycle बनाया गया; fieldwork अभी शुरू नहीं हुआ",
        "Cycle तयार केले गेले; fieldwork अद्याप सुरू झाले नाही",
        "Cycle create ho gaya hai; fieldwork abhi start nahi hua",
    ),
    "verification-cycles.steps.1.label": ("In Progress", "प्रगति में", "प्रगतीपथावर", "In Progress"),
    "verification-cycles.steps.1.caption": (
        "Assets being scanned and verified",
        "Assets scan और verify किए जा रहे हैं",
        "Assets scan आणि verify केल्या जात आहेत",
        "Assets scan aur verify ho rahe hain",
    ),
    "verification-cycles.steps.2.label": ("Completed", "पूर्ण", "पूर्ण", "Completed"),
    "verification-cycles.steps.2.caption": (
        "Fieldwork done; discrepancies logged",
        "Fieldwork पूरा हुआ; discrepancies दर्ज की गईं",
        "Fieldwork पूर्ण झाले; discrepancies नोंदवल्या गेल्या",
        "Fieldwork ho gaya hai; discrepancies log ho gayi hain",
    ),
    "verification-cycles.steps.3.label": ("Closed", "बंद", "बंद", "Closed"),
    "verification-cycles.steps.3.caption": (
        "Finalized; report available",
        "अंतिम रूप दिया गया; report उपलब्ध है",
        "अंतिम रूप दिले गेले; report उपलब्ध आहे",
        "Finalize ho gaya hai; report available hai",
    ),
    "verification-cycles.fieldRules.0.name": ("Cycle Name", "साइकल नाम", "सायकल नाव", "Cycle Name"),
    "verification-cycles.fieldRules.0.description": (
        "Free text label, e.g. an FY name; blocks submission if empty.",
        "स्वतंत्र (free text) लेबल, जैसे कोई FY नाम; खाली होने पर submission को रोकता है।",
        "मुक्त मजकूर (free text) लेबल, उदा. एखादे FY नाव; रिकामे असल्यास submission अडवते.",
        "Free text label hai, jaise koi FY naam; agar empty hai to submission block ho jaata hai.",
    ),
    "verification-cycles.fieldRules.1.name": ("Verification Method", "सत्यापन विधि", "पडताळणी पद्धत", "Verification Method"),
    "verification-cycles.fieldRules.1.description": (
        "Census, Sample, or Risk-based — must match one of these three values exactly, or the API rejects it.",
        "Census, Sample, या Risk-based — इन तीन values में से किसी एक से बिल्कुल मेल खाना चाहिए, अन्यथा API इसे reject कर देता है।",
        "Census, Sample, किंवा Risk-based — या तीन values पैकी एकाशी तंतोतंत जुळले पाहिजे, अन्यथा API ते reject करते.",
        "Census, Sample, ya Risk-based — in teen values mein se kisi ek se exactly match hona chahiye, warna API ise reject kar deta hai.",
    ),
    "verification-cycles.fieldRules.2.name": ("Planned Date", "नियोजित तिथि", "नियोजित तारीख", "Planned Date"),
    "verification-cycles.fieldRules.2.description": (
        "Target date for the count; blocks submission if empty.",
        "गिनती के लिए target date; खाली होने पर submission को रोकता है।",
        "मोजणीसाठी target date; रिकामे असल्यास submission अडवते.",
        "Count ke liye target date; agar empty hai to submission block ho jaata hai.",
    ),
    "verification-cycles.fieldRules.3.name": ("Status", "स्थिति", "स्थिती", "Status"),
    "verification-cycles.fieldRules.3.description": (
        "Draft, In Progress, Completed, or Closed — controls whether the Report link is shown.",
        "Draft, In Progress, Completed, या Closed — यह नियंत्रित करता है कि Report link दिखाया जाए या नहीं।",
        "Draft, In Progress, Completed, किंवा Closed — हे नियंत्रित करते की Report link दाखवायचे की नाही.",
        "Draft, In Progress, Completed, ya Closed — ye control karta hai ki Report link dikhega ya nahi.",
    ),
    "verification-cycles.tip.title": (
        "Two separate screens",
        "दो अलग-अलग screens",
        "दोन स्वतंत्र screens",
        "Do separate screens",
    ),
    "verification-cycles.tip.body": (
        "This page only creates cycles and prints the final report. The actual fieldwork — scanning assets, resolving discrepancies — happens on the Verification Plans workflow; click Open on any row to jump there. The Report link only appears once a cycle reaches Completed or Closed.",
        "यह page केवल cycles बनाता है और अंतिम report प्रिंट करता है। वास्तविक fieldwork — assets को scan करना, discrepancies को resolve करना — Verification Plans workflow पर होता है; वहाँ जाने के लिए किसी भी row पर Open पर क्लिक करें। Report link तभी दिखाई देता है जब कोई cycle Completed या Closed स्थिति तक पहुँचता है।",
        "हे page फक्त cycles तयार करते आणि अंतिम report प्रिंट करते. प्रत्यक्ष fieldwork — assets स्कॅन करणे, discrepancies सोडवणे — Verification Plans workflow वर घडते; तिथे जाण्यासाठी कोणत्याही row वर Open वर क्लिक करा. Report link तेव्हाच दिसते जेव्हा एखादे cycle Completed किंवा Closed स्थितीत पोहोचते.",
        "Ye page sirf cycles create karta hai aur final report print karta hai. Actual fieldwork — assets ko scan karna, discrepancies resolve karna — Verification Plans workflow par hota hai; wahan jaane ke liye kisi bhi row par Open par click karein. Report link tabhi dikhta hai jab koi cycle Completed ya Closed tak pahunchta 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 VERIFICATION_CYCLES.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(VERIFICATION_CYCLES)} verification-cycles keys.")


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