"""Single demo seed: HR, Phonebook (contacts/orgs/donors), Projects, Events.

Replaces the old per-app seed zoo. Dependency-safe order:

  1. Companies (organizations + donors) and org departments.
  2. Users — creating a User auto-creates an Employee stub (hr.signals) which
     in turn auto-creates a Contact. We UPDATE those stubs, never re-create.
  3. Directors (link to employees).
  4. Standalone phonebook contacts (linked to organizations).
  5. Finance budget catalog (categories + items) — needed for fund allocations.
  6. Projects + funds + allocations + finance ledger + team + schedule.
  7. Events + invitations + speakers + schedule + registrations.

RBAC roles/permissions are NOT touched here — run `migrate` (data migrations)
and `seed_rbac` for those.

Usage:
    python manage.py seed_demo
    python manage.py seed_demo --reset    # wipe demo domain data first, then reseed
"""
from datetime import timedelta
from decimal import Decimal

from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from django.db import transaction
from django.utils import timezone

User = get_user_model()

ADMIN_EMAIL = "admin@gmail.com"
DEMO_PASSWORD = "demo12345"

DEPARTMENTS = [
    ("Politics & Security", "POL"),
    ("Economics", "ECO"),
    ("International Relations", "IR"),
    ("Operations", "OPS"),
    ("Finance & Admin", "FIN"),
]

# (name, position, department, employment_type)
PEOPLE = [
    ("Andi", "Wijaya", "Executive Director", "Operations", "staff"),
    ("Siti", "Nurhaliza", "Deputy Director", "Operations", "staff"),
    ("Budi", "Santoso", "Senior Researcher", "Politics & Security", "staff"),
    ("Dewi", "Lestari", "Researcher", "Politics & Security", "staff"),
    ("Eko", "Prasetyo", "Senior Economist", "Economics", "staff"),
    ("Fitri", "Handayani", "Economist", "Economics", "staff"),
    ("Gunawan", "Halim", "IR Analyst", "International Relations", "staff"),
    ("Hana", "Permata", "IR Analyst", "International Relations", "staff"),
    ("Indra", "Kusuma", "Finance Manager", "Finance & Admin", "staff"),
    ("Joko", "Susilo", "Accountant", "Finance & Admin", "staff"),
    ("Kartika", "Sari", "HR Officer", "Finance & Admin", "staff"),
    ("Lukman", "Hakim", "Operations Officer", "Operations", "staff"),
    ("Maya", "Anggraini", "Communications Officer", "Operations", "staff"),
    ("Nanda", "Pratama", "Research Fellow", "Economics", "fellow"),
    ("Oki", "Setiawan", "Research Fellow", "Politics & Security", "fellow"),
    ("Putri", "Maharani", "Research Fellow", "International Relations", "fellow"),
    ("Qori", "Ananda", "Program Intern", "Operations", "intern"),
    ("Rani", "Oktaviani", "Research Intern", "Economics", "intern"),
    ("Sandi", "Firmansyah", "Research Intern", "Politics & Security", "intern"),
    ("Tari", "Wulandari", "Comms Intern", "Operations", "intern"),
    ("Umar", "Salim", "Senior Researcher", "International Relations", "staff"),
    ("Vina", "Marlina", "Researcher", "Economics", "staff"),
    ("Wawan", "Hidayat", "IT Officer", "Finance & Admin", "staff"),
    ("Yuni", "Astuti", "Admin Officer", "Finance & Admin", "staff"),
    ("Zaki", "Ramadhan", "Researcher", "Politics & Security", "staff"),
]

# (name, abbreviation, type, donor_category, industry, country)
ORGANIZATIONS = [
    ("Ford Foundation", "FORD", "donor", "regular", "Philanthropy", "United States"),
    ("Open Society Foundations", "OSF", "donor", "regular", "Philanthropy", "United States"),
    ("Konrad Adenauer Stiftung", "KAS", "donor", "regular", "Political Foundation", "Germany"),
    ("Friedrich Naumann Foundation", "FNF", "donor", "regular", "Political Foundation", "Germany"),
    ("The Asia Foundation", "TAF", "donor", "regular", "Development", "United States"),
    ("Australian DFAT", "DFAT", "donor", "project", "Government", "Australia"),
    ("USAID", "USAID", "donor", "project", "Government", "United States"),
    ("European Union Delegation", "EU", "donor", "project", "Government", "Belgium"),
    ("Hanns Seidel Foundation", "HSF", "donor", "regular", "Political Foundation", "Germany"),
    ("Japan Foundation", "JF", "donor", "regular", "Cultural", "Japan"),
    ("Bappenas", "BAPPENAS", "organization", "", "Government", "Indonesia"),
    ("Kementerian Luar Negeri", "KEMLU", "organization", "", "Government", "Indonesia"),
    ("Universitas Indonesia", "UI", "organization", "", "Academia", "Indonesia"),
    ("Gadjah Mada University", "UGM", "organization", "", "Academia", "Indonesia"),
    ("LIPI / BRIN", "BRIN", "organization", "", "Research", "Indonesia"),
    ("ASEAN Secretariat", "ASEAN", "organization", "", "Multilateral", "Indonesia"),
    ("World Bank Indonesia", "WB", "organization", "", "Multilateral", "Indonesia"),
    ("Tempo Media Group", "TEMPO", "organization", "", "Media", "Indonesia"),
    ("Kompas Gramedia", "KOMPAS", "organization", "", "Media", "Indonesia"),
    ("Bank Indonesia", "BI", "organization", "", "Government", "Indonesia"),
    ("Kadin Indonesia", "KADIN", "organization", "", "Business", "Indonesia"),
    ("CSIS Jakarta Partner", "CSISP", "organization", "", "Think Tank", "Indonesia"),
    ("Lowy Institute", "LOWY", "organization", "", "Think Tank", "Australia"),
    ("ISEAS Singapore", "ISEAS", "organization", "", "Think Tank", "Singapore"),
    ("Brookings Institution", "BROOK", "organization", "", "Think Tank", "United States"),
]

# Standalone phonebook contacts (external people), assigned to org by abbreviation.
EXTERNAL_CONTACTS = [
    ("Rachel Tan", "rachel.tan@asiafoundation.org", "Program Director", "TAF"),
    ("Michael Chen", "m.chen@fordfoundation.org", "Senior Program Officer", "FORD"),
    ("Anke Müller", "anke.mueller@kas.de", "Country Representative", "KAS"),
    ("Dr. Sarah Wong", "s.wong@iseas.edu.sg", "Senior Fellow", "ISEAS"),
    ("James O'Brien", "j.obrien@lowyinstitute.org", "Research Director", "LOWY"),
    ("Prof. Bambang Sutrisno", "bambang@ui.ac.id", "Dean", "UI"),
    ("Ibu Retno Lestari", "retno@kemlu.go.id", "Director of Policy", "KEMLU"),
    ("Pak Hendra Wijaya", "hendra@bappenas.go.id", "Senior Planner", "BAPPENAS"),
    ("Lisa Anderson", "l.anderson@usaid.gov", "Mission Director", "USAID"),
    ("Tomoko Yamada", "t.yamada@jpf.go.jp", "Program Manager", "JF"),
    ("David Smith", "d.smith@worldbank.org", "Country Economist", "WB"),
    ("Maria Santos", "m.santos@eeas.europa.eu", "Political Counsellor", "EU"),
    ("Peter Hartono", "peter@tempo.co.id", "Senior Editor", "TEMPO"),
    ("Nadia Rahman", "nadia@kompas.com", "Bureau Chief", "KOMPAS"),
    ("Dr. Agus Salim", "agus@brin.go.id", "Research Professor", "BRIN"),
    ("Grace Liu", "grace.liu@brookings.edu", "Fellow", "BROOK"),
    ("Hiro Tanaka", "hiro@asean.org", "Programme Officer", "ASEAN"),
    ("Sinta Dewi", "sinta@kadin.id", "Policy Advisor", "KADIN"),
    ("Robert Kim", "r.kim@dfat.gov.au", "Counsellor", "DFAT"),
    ("Farah Diba", "farah@bi.go.id", "Senior Analyst", "BI"),
]

# (name, status, lead_index_into_staff, donor_abbrev, fund_amount, currency)
PROJECTS = [
    ("Indo-Pacific Maritime Security Study", "active", 2, "DFAT", 850000, "AUD"),
    ("ASEAN Economic Integration Outlook", "active", 4, "USAID", 1200000, "USD"),
    ("Democratic Resilience in Southeast Asia", "active", 3, "FORD", 600000, "USD"),
    ("Digital Economy Policy Lab", "planning", 5, "EU", 950000, "EUR"),
    ("Climate Diplomacy Initiative", "active", 6, "KAS", 400000, "EUR"),
    ("Regional Trade Architecture Review", "completed", 4, "TAF", 350000, "USD"),
    ("Election Integrity Monitoring", "on_hold", 14, "OSF", 500000, "USD"),
    ("Youth Leadership Forum", "active", 12, "FNF", 200000, "EUR"),
    ("Defense Modernization Watch", "active", 20, "DFAT", 700000, "AUD"),
    ("Indonesia 2045 Foresight", "planning", 0, "FORD", 1500000, "USD"),
    ("Maritime Boundary Dialogue", "active", 7, "JF", 300000, "JPY"),
    ("Green Investment Tracker", "active", 5, "EU", 800000, "EUR"),
]

EVENT_TYPES = ["conference", "seminar", "workshop", "webinar", "dissemination", "meeting"]

EVENTS = [
    ("CSIS Annual Conference 2026", "conference", "Hotel Mulia Jakarta", "published", 300),
    ("Indo-Pacific Security Forum", "conference", "Shangri-La Jakarta", "published", 200),
    ("ASEAN Economic Outlook Launch", "dissemination", "CSIS Auditorium", "published", 120),
    ("Digital Economy Policy Workshop", "workshop", "CSIS Meeting Room A", "published", 40),
    ("Climate Diplomacy Roundtable", "seminar", "CSIS Meeting Room B", "published", 30),
    ("Trade Architecture Webinar", "webinar", "Online (Zoom)", "published", 500),
    ("Democratic Resilience Seminar", "seminar", "CSIS Auditorium", "completed", 80),
    ("Youth Leadership Forum 2026", "conference", "Bali Convention Center", "draft", 150),
    ("Maritime Security Expert Meeting", "meeting", "CSIS Board Room", "published", 20),
    ("Green Investment Dissemination", "dissemination", "CSIS Auditorium", "draft", 100),
    ("Defense Modernization Briefing", "seminar", "CSIS Meeting Room A", "published", 50),
    ("Indonesia 2045 Foresight Workshop", "workshop", "CSIS Meeting Room B", "draft", 35),
    ("Regional Trade Webinar Series", "webinar", "Online (Teams)", "published", 400),
    ("ASEAN Connectivity Conference", "conference", "Hotel Indonesia Kempinski", "published", 250),
    ("Policy Communications Training", "workshop", "CSIS Training Room", "completed", 25),
]

BUDGET_CATALOG = [
    ("A", "Personnel", ["Salaries", "Honoraria", "Benefits"]),
    ("B", "Activities", ["Workshops", "Field Research", "Travel", "Publications"]),
    ("C", "Operations", ["Office Rent", "Utilities", "Equipment"]),
    ("D", "Overhead", ["Administrative", "Audit & Compliance"]),
]


class Command(BaseCommand):
    help = "Seed demo data for HR, Phonebook, Projects, and Events (one command)."

    def add_arguments(self, parser):
        parser.add_argument(
            "--reset", action="store_true",
            help="Wipe demo domain data (keeps superusers + RBAC) before reseeding.",
        )

    @transaction.atomic
    def handle(self, *args, **opts):
        if opts["reset"]:
            self._reset()

        self.today = timezone.now().date()
        admin = self._ensure_admin()

        companies = self._seed_companies()
        self._seed_departments()
        employees = self._seed_people()
        self._seed_directors(employees)
        self._seed_contacts(companies)
        budget_items = self._seed_budget_catalog()
        self._seed_projects(employees, companies, budget_items)
        self._seed_events(admin, employees)

        self._summary()

    # ------------------------------------------------------------------ reset
    def _reset(self):
        from apps.companies.models import Company, Director, Department
        from apps.contacts.models import Contact
        from apps.projects.models import Project, ProjectFund
        from apps.events.models import Event
        from apps.finance.models import BudgetCategory
        from apps.hr.models import Employee

        self.stdout.write(self.style.WARNING("Resetting demo domain data…"))
        Event.objects.all().delete()
        Project.objects.all().delete()
        ProjectFund.objects.all().delete()
        BudgetCategory.objects.all().delete()
        Director.objects.all().delete()
        Department.objects.all().delete()
        Contact.objects.all().delete()
        Company.objects.all().delete()
        # Drop non-superuser users → cascades Employees + their Contacts.
        User.objects.filter(is_superuser=False).delete()
        Employee.objects.exclude(user__is_superuser=True).delete()

    # ------------------------------------------------------------------ admin
    def _ensure_admin(self):
        admin = User.objects.filter(email=ADMIN_EMAIL).first()
        if not admin:
            admin = User.objects.create_superuser(
                email=ADMIN_EMAIL, password="687654",
                first_name="Admin", last_name="KnowledgeHub",
            )
            self.stdout.write(self.style.SUCCESS(f"Created superuser {ADMIN_EMAIL}"))
        return admin

    # -------------------------------------------------------------- companies
    def _seed_companies(self):
        from apps.companies.models import Company

        companies = {}
        for name, abbr, ctype, dcat, industry, country in ORGANIZATIONS:
            company, _ = Company.objects.update_or_create(
                name=name,
                defaults=dict(
                    abbreviation=abbr,
                    company_type=ctype,
                    donor_category=dcat,
                    industry=industry,
                    country=country,
                    email=f"info@{abbr.lower()}.org",
                    website=f"https://www.{abbr.lower()}.org",
                ),
            )
            companies[abbr] = company
        self.stdout.write(f"  companies: {len(companies)}")
        return companies

    def _seed_departments(self):
        from apps.companies.models import Department

        for name, code in DEPARTMENTS:
            Department.objects.update_or_create(name=name, defaults={"code": code})
        self.stdout.write(f"  departments: {len(DEPARTMENTS)}")

    # ------------------------------------------------------------------- people
    def _seed_people(self):
        """Create users; the post_save signal auto-creates Employee stubs which
        we then update with real position/department. Returns staff Employees."""
        from apps.hr.models import Employee

        employees = []
        for i, (first, last, position, dept, etype) in enumerate(PEOPLE):
            email = f"{first.lower()}.{last.lower()}@csis.or.id"
            user = User.objects.filter(email=email).first()
            if not user:
                user = User.objects.create_user(
                    email=email, password=DEMO_PASSWORD,
                    first_name=first, last_name=last,
                    phone=f"+6281{200000000 + i}",
                )
            # Employee auto-created by signal — update the stub.
            emp = Employee.objects.get(user=user)
            emp.position = position
            emp.department = dept
            emp.employment_type = etype
            emp.hire_date = self.today - timedelta(days=365 * (i % 6) + 30)
            emp.status = "active"
            emp.salary = Decimal(15_000_000 + (i % 10) * 2_000_000)
            emp.save()
            employees.append(emp)
        self.stdout.write(f"  users + employees: {len(employees)}")
        return employees

    def _seed_directors(self, employees):
        from apps.companies.models import Director

        # First two staff are directors.
        for order, (emp, title) in enumerate([
            (employees[0], "Executive Director"),
            (employees[1], "Deputy Director"),
        ]):
            Director.objects.update_or_create(
                employee=emp,
                defaults={"title": title, "order": order, "is_active": True,
                          "bio": f"{emp.user.get_full_name()} serves as {title}."},
            )
        self.stdout.write("  directors: 2")

    # ----------------------------------------------------------------- contacts
    def _seed_contacts(self, companies):
        from apps.contacts.models import Contact

        n = 0
        for name, email, position, abbr in EXTERNAL_CONTACTS:
            Contact.objects.update_or_create(
                email=email,
                defaults=dict(
                    name=name, position=position, type="individual",
                    company=companies.get(abbr),
                    phone="+62215299000",
                ),
            )
            n += 1
        self.stdout.write(f"  external contacts: {n}")

    # ------------------------------------------------------------------ finance
    def _seed_budget_catalog(self):
        from apps.finance.models import BudgetCategory, BudgetItem

        items = []
        for code, cat_name, item_names in BUDGET_CATALOG:
            category, _ = BudgetCategory.objects.update_or_create(
                code=code, defaults={"name": cat_name},
            )
            for n, item_name in enumerate(item_names, start=1):
                item, _ = BudgetItem.objects.get_or_create(
                    category=category, name=item_name,
                    defaults={"code": f"{code}.{n}"},
                )
                items.append(item)
        self.stdout.write(f"  budget items: {len(items)}")
        return items

    # ------------------------------------------------------------------ projects
    def _seed_projects(self, employees, companies, budget_items):
        from apps.projects.models import (
            Project, ProjectFund, ProjectFundAllocation, ProjectFinance,
            ProjectTeamMember, ProjectSchedule,
        )

        n_proj = n_fund = n_alloc = n_fin = 0
        for i, (name, status, lead_idx, donor_abbr, amount, currency) in enumerate(PROJECTS):
            lead = employees[lead_idx % len(employees)]
            start = self.today - timedelta(days=180 + i * 20)
            end = start + timedelta(days=540)
            project, _ = Project.objects.update_or_create(
                name=name,
                defaults=dict(
                    status=status, lead=lead, start_date=start, end_date=end,
                    description=f"{name} — a CSIS research and policy engagement project.",
                    tags=["research", "policy"],
                ),
            )
            n_proj += 1

            fund, _ = ProjectFund.objects.update_or_create(
                project=project, source=companies[donor_abbr].name,
                defaults=dict(
                    fund_type="grant", donor=companies[donor_abbr],
                    amount=Decimal(amount), currency=currency,
                    status="received", agreement_date=start,
                    received_date=start + timedelta(days=15),
                ),
            )
            n_fund += 1

            # Allocate the fund across a realistic spread of budget items, then
            # book expenses against those SAME items so every expense maps to a
            # budget line. Utilization is varied per line: some under budget,
            # some near the cap, one deliberately over (proves the ratio chart).
            by_code = {bi.code: bi for bi in budget_items}
            # (budget code, unit, qty, freq, unit_cost_share, utilization, expense_label)
            #   unit_cost_share: fraction of `amount` this line's unit cost is sized to.
            #   utilization: spent / allocated for this line.
            ALLOC_PLAN = [
                ("A.1", "person-month", 6, 1, Decimal("0.030"), Decimal("0.92"), "Researcher salaries"),
                ("A.2", "honorarium", 4, 1, Decimal("0.015"), Decimal("0.75"), "Expert honoraria"),
                ("A.3", "person", 6, 1, Decimal("0.008"), Decimal("0.60"), "Staff benefits"),
                ("B.1", "workshop", 3, 1, Decimal("0.025"), Decimal("1.15"), "Workshop costs"),
                ("B.2", "trip", 4, 1, Decimal("0.020"), Decimal("0.85"), "Field research"),
                ("B.3", "trip", 5, 1, Decimal("0.012"), Decimal("1.00"), "Research travel"),
                ("B.4", "report", 2, 1, Decimal("0.018"), Decimal("0.40"), "Publication & printing"),
                ("C.1", "month", 12, 1, Decimal("0.006"), Decimal("0.95"), "Office rent share"),
                ("C.3", "unit", 3, 1, Decimal("0.010"), Decimal("0.50"), "Equipment purchase"),
                ("D.1", "lumpsum", 1, 1, Decimal("0.050"), Decimal("0.70"), "Administrative overhead"),
            ]
            # Vary which lines a project funds so the dataset isn't uniform.
            plan = ALLOC_PLAN[: 6 + (i % 5)]
            amt = Decimal(amount)

            # Grant disbursement(s) — income on the grant ledger.
            ProjectFinance.objects.get_or_create(
                project=project, description=f"Grant disbursement — {fund.source}", type="income",
                defaults=dict(
                    amount=amt, currency=currency, ledger="grant",
                    date=fund.received_date or (start + timedelta(days=15)),
                ),
            )
            n_fin += 1

            for j, (code, unit, qty, freq, cost_share, util, label) in enumerate(plan):
                bi = by_code.get(code)
                if bi is None:
                    continue
                unit_cost = (amt * cost_share).quantize(Decimal("0.01"))
                alloc, created = ProjectFundAllocation.objects.get_or_create(
                    fund=fund, budget_item=bi,
                    defaults=dict(
                        unit=unit, quantity=Decimal(qty), frequency=Decimal(freq),
                        unit_cost=unit_cost, unit_cost_currency=currency,
                    ),
                )
                if created:
                    n_alloc += 1
                # Expense booked against the same budget item, sized to the line's
                # allocated amount × utilization. Split lines >100% into two entries.
                allocated = alloc.amount or (unit_cost * Decimal(qty) * Decimal(freq))
                spent = (allocated * util).quantize(Decimal("0.01"))
                parts = [spent] if util <= 1 else [
                    (allocated).quantize(Decimal("0.01")),
                    (spent - allocated).quantize(Decimal("0.01")),
                ]
                for p, part in enumerate(parts):
                    if part <= 0:
                        continue
                    ProjectFinance.objects.get_or_create(
                        project=project, budget_item=bi,
                        description=f"{label}{' (overrun)' if p else ''}", type="expense",
                        defaults=dict(
                            amount=part, currency=currency, ledger="expense",
                            date=start + timedelta(days=45 + 25 * j + 10 * p),
                        ),
                    )
                    n_fin += 1

            # Team: lead as owner + 2 members.
            ProjectTeamMember.objects.get_or_create(
                project=project, user=lead.user, defaults={"role": "owner"})
            for emp in employees[(i + 1) % len(employees):(i + 3) % len(employees) + 1][:2]:
                ProjectTeamMember.objects.get_or_create(
                    project=project, user=emp.user, defaults={"role": "member"})

            # Schedule milestones.
            for k, phase in enumerate(["Inception", "Field Work", "Reporting"]):
                ProjectSchedule.objects.get_or_create(
                    project=project, title=phase,
                    defaults=dict(
                        start_date=start + timedelta(days=180 * k),
                        end_date=start + timedelta(days=180 * (k + 1)),
                    ),
                )
        self.stdout.write(f"  projects: {n_proj} | funds: {n_fund} | allocations: {n_alloc} | finance: {n_fin}")

    # -------------------------------------------------------------------- events
    def _seed_events(self, admin, employees):
        from apps.events.models import (
            Event, EventTeam, EventSpeaker, EventScheduleItem,
            EventInvitation, EventRegistration,
        )
        from apps.contacts.models import Contact

        speakers_pool = list(Contact.objects.filter(type="individual")[:10])
        n_evt = n_inv = n_reg = 0
        for i, (name, etype, location, status, capacity) in enumerate(EVENTS):
            start = timezone.now() + timedelta(days=(i - 5) * 14)
            event, _ = Event.objects.update_or_create(
                name=name,
                defaults=dict(
                    event_type=etype, location=location, status=status,
                    capacity=capacity, organizer=admin,
                    description=f"{name} hosted by CSIS.",
                    start_date=start, end_date=start + timedelta(hours=6),
                    tags=[etype],
                ),
            )
            n_evt += 1

            # Team: 2 staff.
            for emp in employees[i % len(employees):i % len(employees) + 2]:
                EventTeam.objects.get_or_create(
                    event=event, user=emp.user,
                    defaults={"role": "coordinator", "is_lead": False})

            # Speakers from contact pool.
            for s, contact in enumerate(speakers_pool[i % 5:i % 5 + 2]):
                EventSpeaker.objects.get_or_create(
                    event=event, name=contact.name,
                    defaults=dict(
                        contact=contact, title=contact.position or "Speaker",
                        organization=contact.company.name if contact.company_id else "",
                        session_type="keynote" if s == 0 else "panel",
                        session_title=f"Session {s + 1}",
                    ),
                )

            # Schedule items.
            for k, (title, stype) in enumerate([
                ("Opening Remarks", "ceremony"),
                ("Keynote Address", "keynote"),
                ("Panel Discussion", "panel"),
            ]):
                EventScheduleItem.objects.get_or_create(
                    event=event, title=title,
                    defaults=dict(
                        session_type=stype,
                        start_time=(timezone.datetime(2026, 1, 1, 9 + k * 2)).time(),
                        end_time=(timezone.datetime(2026, 1, 1, 10 + k * 2)).time(),
                    ),
                )

            # Invitations + registrations from external contacts.
            for c in Contact.objects.exclude(email="")[i % 8:i % 8 + 5]:
                _, created = EventInvitation.objects.get_or_create(
                    event=event, email=c.email,
                    defaults=dict(name=c.name, contact=c,
                                  status="accepted" if n_inv % 2 else "pending",
                                  invited_by=admin),
                )
                if created:
                    n_inv += 1
                _, rcreated = EventRegistration.objects.get_or_create(
                    event=event, email=c.email,
                    defaults=dict(name=c.name, contact=c, phone=c.phone,
                                  company=c.company.name if c.company_id else "",
                                  status="registered"),
                )
                if rcreated:
                    n_reg += 1
        self.stdout.write(f"  events: {n_evt} | invitations: {n_inv} | registrations: {n_reg}")

    # ------------------------------------------------------------------ summary
    def _summary(self):
        from apps.hr.models import Employee
        from apps.contacts.models import Contact
        from apps.companies.models import Company
        from apps.projects.models import Project, ProjectFund
        from apps.events.models import Event

        self.stdout.write(self.style.MIGRATE_HEADING("\n═══ SEED DEMO SUMMARY ═══"))
        rows = [
            ("Users", User.objects.count()),
            ("Employees", Employee.objects.count()),
            ("Contacts", Contact.objects.count()),
            ("Companies (orgs+donors)", Company.objects.count()),
            ("  of which donors", Company.objects.filter(company_type="donor").count()),
            ("Projects", Project.objects.count()),
            ("Project funds", ProjectFund.objects.count()),
            ("Events", Event.objects.count()),
        ]
        for label, count in rows:
            self.stdout.write(f"  {label:<26} {count}")
        self.stdout.write(self.style.SUCCESS("\nDone. Login: admin@gmail.com / 687654"))
