"""
Demo Data Seeder — Generates realistic data for the AI Adoption Tracker demo.

Run: python -m app.seed
Creates: 6 departments, 30 employees, 25+ activities, 200+ completions,
         quizzes, tracked links, sync configs, badges, levels, anomaly flags.
"""

import asyncio
import random
import uuid
from datetime import date, datetime, timedelta, timezone

from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession

from app.database import async_session, engine, Base
from app.models import *  # noqa


def utcnow():
    return datetime.now(timezone.utc)


def random_date(start_days_ago=90, end_days_ago=1):
    delta = random.randint(end_days_ago, start_days_ago)
    return utcnow() - timedelta(days=delta)


DEPARTMENTS = [
    {"name": "Engineering", "description": "Software engineering and platform teams"},
    {"name": "Marketing", "description": "Brand, growth, and communications"},
    {"name": "Operations", "description": "Business operations and process excellence"},
    {"name": "Finance", "description": "Financial planning and analysis"},
    {"name": "HR", "description": "People and culture"},
    {"name": "Product", "description": "Product management and design"},
]

EMPLOYEES = [
    # Engineering (8) - skew highest
    ("Sara Al-Mansoori", "Engineering"), ("Khalid Rahman", "Engineering"),
    ("Ahmed Bashir", "Engineering"), ("Rania Farouk", "Engineering"),
    ("Yusuf Qasim", "Engineering"), ("Noura Saeed", "Engineering"),
    ("Tariq Al-Hassan", "Engineering"), ("Dina Mahmoud", "Engineering"),
    # Marketing (5)
    ("Fatima Hassan", "Marketing"), ("Nadia Karim", "Marketing"),
    ("Salim Darwish", "Marketing"), ("Huda Nasser", "Marketing"),
    ("Zainab Othman", "Marketing"),
    # Operations (5)
    ("Omar Yusuf", "Operations"), ("Rami Saeed", "Operations"),
    ("Mariam Khalil", "Operations"), ("Faisal Al-Tamimi", "Operations"),
    ("Samira Jaber", "Operations"),
    # Finance (4)
    ("Layla Noor", "Finance"), ("Hassan Malik", "Finance"),
    ("Aisha Rashid", "Finance"), ("Bilal Hamdan", "Finance"),
    # HR (4)
    ("Mona El-Amin", "HR"), ("Jamal Barakat", "HR"),
    ("Wafa Suleiman", "HR"), ("Kareem Haddad", "HR"),
    # Product (4)
    ("Lina Taha", "Product"), ("Ammar Zakaria", "Product"),
    ("Rana Ismail", "Product"), ("Sami Al-Farsi", "Product"),
]

LEVELS_DATA = [
    {"name": "Novice", "min_xp": 0, "color": "#64748b", "icon": "🌱", "sort_order": 1},
    {"name": "Explorer", "min_xp": 150, "color": "#0ea5e9", "icon": "🔍", "sort_order": 2},
    {"name": "Practitioner", "min_xp": 400, "color": "#8b5cf6", "icon": "⚡", "sort_order": 3},
    {"name": "Advocate", "min_xp": 800, "color": "#f59e0b", "icon": "🔥", "sort_order": 4},
    {"name": "Champion", "min_xp": 1200, "color": "#ef4444", "icon": "🏆", "sort_order": 5},
    {"name": "Visionary", "min_xp": 2000, "color": "#ec4899", "icon": "👑", "sort_order": 6},
]

BADGES_DATA = [
    {"name": "First Steps", "icon": "🚀", "category": "completion", "condition_type": "activities_completed", "condition_value": {"count": 1}, "sort_order": 1},
    {"name": "Dedicated Learner", "icon": "📚", "category": "completion", "condition_type": "activities_completed", "condition_value": {"count": 10}, "sort_order": 2},
    {"name": "Bookworm", "icon": "📖", "category": "completion", "condition_type": "category_complete_all", "condition_value": {"category": "reading"}, "sort_order": 3},
    {"name": "Course Collector", "icon": "🎓", "category": "completion", "condition_type": "category_count", "condition_value": {"category": "course", "count": 5}, "sort_order": 4},
    {"name": "Hacker", "icon": "⚡", "category": "special", "condition_type": "hackathon_count", "condition_value": {"count": 1}, "sort_order": 5},
    {"name": "Hackathon Veteran", "icon": "🏅", "category": "special", "condition_type": "hackathon_count", "condition_value": {"count": 3}, "sort_order": 6},
    {"name": "Rising Star", "icon": "⭐", "category": "xp", "condition_type": "xp_threshold", "condition_value": {"threshold": 300}, "sort_order": 7},
    {"name": "AI Champion", "icon": "🏆", "category": "xp", "condition_type": "xp_threshold", "condition_value": {"threshold": 800}, "sort_order": 8},
    {"name": "Trailblazer", "icon": "🔥", "category": "xp", "condition_type": "xp_threshold", "condition_value": {"threshold": 1200}, "sort_order": 9},
    {"name": "Udemy Pro", "icon": "🎯", "category": "completion", "condition_type": "platform_count", "condition_value": {"platform": "udemy", "count": 3}, "sort_order": 10},
    {"name": "Multi-Tool Master", "icon": "🛠️", "category": "special", "condition_type": "multi_tool", "condition_value": {"min_tools": 3}, "sort_order": 11},
    {"name": "Copilot Power User", "icon": "🤖", "category": "special", "condition_type": "copilot_power_user", "condition_value": {"min_apps": 4}, "sort_order": 12},
    {"name": "Quiz Whiz", "icon": "🧠", "category": "completion", "condition_type": "quiz_perfect", "condition_value": {"count": 3}, "sort_order": 13},
    {"name": "Content Consumer", "icon": "👀", "category": "completion", "condition_type": "content_consumer", "condition_value": {"count": 10}, "sort_order": 14},
    {"name": "Agent Builder", "icon": "🏗️", "category": "special", "condition_type": "agent_builder", "condition_value": {}, "sort_order": 15},
    {"name": "Contributor", "icon": "🤝", "category": "special", "condition_type": "contributor", "condition_value": {"count": 5}, "sort_order": 16},
]

ACTIVITIES_DATA = [
    # Courses
    {"title": "ChatGPT for Business Productivity", "category": "course", "platform": "udemy", "xp_value": 150, "estimated_duration_minutes": 240, "difficulty": "beginner", "trust_tier": 1, "tags": ["chatgpt", "productivity"]},
    {"title": "AI Fundamentals for Everyone", "category": "course", "platform": "linkedin_learning", "xp_value": 200, "estimated_duration_minutes": 360, "difficulty": "beginner", "trust_tier": 1, "tags": ["ai", "fundamentals"]},
    {"title": "Prompt Engineering Mastery", "category": "course", "platform": "udemy", "xp_value": 180, "estimated_duration_minutes": 300, "difficulty": "intermediate", "trust_tier": 1, "tags": ["prompts", "engineering"]},
    {"title": "AI in Project Management", "category": "course", "platform": "linkedin_learning", "xp_value": 120, "estimated_duration_minutes": 180, "difficulty": "beginner", "trust_tier": 1, "tags": ["pm", "ai"]},
    {"title": "Machine Learning Fundamentals", "category": "course", "platform": "coursera", "xp_value": 300, "estimated_duration_minutes": 480, "difficulty": "advanced", "trust_tier": 1, "tags": ["ml", "data-science"]},
    {"title": "Microsoft Copilot Deep Dive", "category": "course", "platform": "viva", "xp_value": 200, "estimated_duration_minutes": 300, "difficulty": "intermediate", "trust_tier": 1, "tags": ["copilot", "m365"]},
    # Readings (with quiz, split XP)
    {"title": "DWA AI Strategy 2026 (Slides)", "category": "reading", "platform": "internal", "xp_value": 50, "xp_open_pct": 30, "estimated_duration_minutes": 30, "trust_tier": 1, "tags": ["strategy"]},
    {"title": "AI Ethics Whitepaper", "category": "reading", "platform": "internal", "xp_value": 75, "xp_open_pct": 30, "estimated_duration_minutes": 45, "trust_tier": 1, "tags": ["ethics"]},
    {"title": "RAG Architecture Guide (PDF)", "category": "reading", "platform": "internal", "xp_value": 60, "xp_open_pct": 30, "estimated_duration_minutes": 40, "trust_tier": 1, "tags": ["rag", "architecture"]},
    {"title": "Prompt Library Best Practices", "category": "reading", "platform": "internal", "xp_value": 40, "xp_open_pct": 30, "estimated_duration_minutes": 20, "trust_tier": 1, "tags": ["prompts"]},
    # Videos
    {"title": "Intro to Copilot Studio (Stream)", "category": "video", "platform": "stream", "xp_value": 80, "estimated_duration_minutes": 45, "trust_tier": 1, "tags": ["copilot-studio"]},
    {"title": "Building AI Agents Tutorial", "category": "video", "platform": "stream", "xp_value": 100, "estimated_duration_minutes": 60, "trust_tier": 1, "tags": ["agents"]},
    # Hackathons
    {"title": "Q4 2025 AI Hackathon", "category": "hackathon", "platform": "internal", "xp_value": 300, "trust_tier": 1, "tags": ["hackathon"]},
    {"title": "Prompt-a-thon February 2026", "category": "hackathon", "platform": "internal", "xp_value": 200, "trust_tier": 1, "tags": ["hackathon", "prompts"]},
    {"title": "AI Innovation Day Q2 2026", "category": "hackathon", "platform": "internal", "xp_value": 250, "trust_tier": 1, "tags": ["hackathon", "innovation"]},
    # Workshops
    {"title": "Copilot in Teams Workshop", "category": "workshop", "platform": "internal", "xp_value": 100, "estimated_duration_minutes": 90, "trust_tier": 1, "tags": ["copilot", "teams"]},
    {"title": "AI for Non-Technical Staff", "category": "workshop", "platform": "internal", "xp_value": 75, "estimated_duration_minutes": 60, "trust_tier": 1, "tags": ["beginner"]},
    # Tool Usage (recurring monthly)
    {"title": "Microsoft 365 Copilot Active Usage", "category": "tool_usage", "platform": "m365_copilot", "xp_value": 30, "is_recurring": True, "recurrence_period": "monthly", "trust_tier": 1},
    {"title": "Claude Active Usage", "category": "tool_usage", "platform": "claude", "xp_value": 30, "is_recurring": True, "recurrence_period": "monthly", "trust_tier": 2},
    {"title": "GenSpark Active Usage", "category": "tool_usage", "platform": "genspark", "xp_value": 30, "is_recurring": True, "recurrence_period": "monthly", "trust_tier": 2},
    {"title": "GitHub Copilot Active Usage", "category": "tool_usage", "platform": "github", "xp_value": 30, "is_recurring": True, "recurrence_period": "monthly", "trust_tier": 1},
    # Certification
    {"title": "Google AI Essentials Certificate", "category": "certification", "platform": "coursera", "xp_value": 400, "trust_tier": 3, "tags": ["certification", "google"]},
    # Contributions
    {"title": "Prompt Library Contribution", "category": "contribution", "platform": "internal", "xp_value": 40, "trust_tier": 3},
    {"title": "Built Copilot Agent", "category": "agent_creation", "platform": "m365_copilot", "xp_value": 200, "trust_tier": 1},
]

DATA_SOURCES = [
    {"name": "m365_copilot", "display_name": "Microsoft 365 Copilot", "sync_type": "api", "sync_interval_minutes": 360},
    {"name": "purview_audit", "display_name": "Microsoft Purview Audit Logs", "sync_type": "api", "sync_interval_minutes": 360},
    {"name": "viva_learning", "display_name": "Microsoft Viva Learning", "sync_type": "api", "sync_interval_minutes": 360},
    {"name": "udemy", "display_name": "Udemy Business", "sync_type": "api", "sync_interval_minutes": 720},
    {"name": "linkedin_learning", "display_name": "LinkedIn Learning", "sync_type": "api", "sync_interval_minutes": 720},
    {"name": "github_copilot", "display_name": "GitHub Copilot", "sync_type": "api", "sync_interval_minutes": 1440},
    {"name": "genspark", "display_name": "GenSpark", "sync_type": "excel_import"},
    {"name": "claude", "display_name": "Claude (Anthropic)", "sync_type": "excel_import"},
]


async def seed():
    """Main seed function."""
    from passlib.context import CryptContext
    pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.drop_all)
        await conn.run_sync(Base.metadata.create_all)

    async with async_session() as db:
        print("🌱 Seeding departments...")
        dept_map = {}
        for d in DEPARTMENTS:
            dept = Department(**d)
            db.add(dept)
            dept_map[d["name"]] = dept
        await db.flush()

        print("🌱 Seeding levels...")
        for l in LEVELS_DATA:
            db.add(Level(**l))
        await db.flush()

        print("🌱 Seeding badges...")
        for b in BADGES_DATA:
            db.add(Badge(**b, description=f"Earn the {b['name']} badge"))
        await db.flush()

        print("🌱 Seeding employees...")
        user_map = {}
        for i, (name, dept_name) in enumerate(EMPLOYEES):
            first = name.split()[0].lower()
            last = name.split()[-1].lower()
            email = f"{first}.{last}@dwa.ae"
            user = User(
                employee_id=f"DWA-{1000+i}",
                email=email,
                full_name=name,
                department_id=dept_map[dept_name].id,
                role="admin" if i == 0 else ("team_lead" if i < 6 else "employee"),
                password_hash=pwd_context.hash("demo123"),
                is_active=True,
            )
            db.add(user)
            user_map[name] = user
        await db.flush()

        print("🌱 Seeding activities...")
        activity_map = {}
        for a in ACTIVITIES_DATA:
            act = Activity(**{k: v for k, v in a.items()})
            db.add(act)
            activity_map[a["title"]] = act
        await db.flush()

        print("🌱 Seeding tracked links...")
        reading_activities = [a for a in ACTIVITIES_DATA if a["category"] == "reading"]
        for i, a in enumerate(reading_activities):
            act = activity_map[a["title"]]
            link = TrackedLink(
                activity_id=act.id,
                short_code=f"read{i+1:03d}",
                destination_url=f"https://dwa.sharepoint.com/sites/ai-hub/docs/{act.title.lower().replace(' ', '-')}.pdf",
                title=act.title,
                content_type="pdf" if "PDF" in act.title else "pptx" if "Slides" in act.title else "article",
                shared_in_channel="AI Adoption",
                shared_at=random_date(60, 30),
                click_count=random.randint(5, 25),
            )
            db.add(link)
        await db.flush()

        print("🌱 Seeding quizzes...")
        quiz_data = [
            {"title": "AI Strategy 2026 Quiz", "activity": "DWA AI Strategy 2026 (Slides)", "questions": [
                {"question": "What is DWA's primary AI adoption goal for 2026?", "options": ["Cost cutting", "Enterprise-wide AI fluency", "Replace all jobs", "Build AGI"], "correct_index": 1},
                {"question": "Which tool is DWA's primary AI assistant?", "options": ["ChatGPT", "Microsoft Copilot", "Gemini", "Claude"], "correct_index": 1},
                {"question": "What metric tracks AI adoption success?", "options": ["Revenue only", "Active usage + skill growth", "Headcount reduction", "Prompt count"], "correct_index": 1},
            ]},
            {"title": "AI Ethics Quiz", "activity": "AI Ethics Whitepaper", "questions": [
                {"question": "What is the main concern with AI bias?", "options": ["Speed", "Unfair outcomes for groups", "Cost", "Complexity"], "correct_index": 1},
                {"question": "Who is responsible for ethical AI use at DWA?", "options": ["Only IT", "Only legal", "Everyone", "Only management"], "correct_index": 2},
                {"question": "What should you do if AI output seems biased?", "options": ["Ignore it", "Report and review", "Use it anyway", "Delete it"], "correct_index": 1},
            ]},
            {"title": "RAG Architecture Quiz", "activity": "RAG Architecture Guide (PDF)", "questions": [
                {"question": "What does RAG stand for?", "options": ["Rapid AI Generation", "Retrieval Augmented Generation", "Real-time AI Gateway", "Random Answer Generator"], "correct_index": 1},
                {"question": "What is the main benefit of RAG?", "options": ["Faster training", "Grounded responses with less hallucination", "Lower cost", "Better UI"], "correct_index": 1},
                {"question": "What feeds into the RAG pipeline?", "options": ["Only the prompt", "A vector database of documents", "Random internet data", "User history only"], "correct_index": 1},
                {"question": "RAG is best suited for which use case?", "options": ["Image generation", "Enterprise knowledge Q&A", "Music composition", "Video editing"], "correct_index": 1},
            ]},
        ]
        for qd in quiz_data:
            act = activity_map.get(qd["activity"])
            if act:
                quiz = Quiz(
                    activity_id=act.id,
                    title=qd["title"],
                    passing_score_pct=70,
                    questions=qd["questions"],
                )
                db.add(quiz)
                await db.flush()
                act.quiz_id = quiz.id

        print("🌱 Seeding completions...")
        all_users = list(user_map.values())
        non_recurring = [a for a in ACTIVITIES_DATA if not a.get("is_recurring")]
        recurring = [a for a in ACTIVITIES_DATA if a.get("is_recurring")]

        # Distribute non-recurring completions
        for user in all_users:
            dept = [d for n, d in EMPLOYEES if n == user.full_name][0]
            # Engineering/Product complete more
            completion_rate = 0.65 if dept in ("Engineering", "Product") else 0.35 if dept in ("Marketing", "Operations") else 0.2
            activities_to_complete = random.sample(non_recurring, k=int(len(non_recurring) * completion_rate))

            for a_data in activities_to_complete:
                act = activity_map[a_data["title"]]
                status = random.choices(["completed", "in_progress"], weights=[0.8, 0.2])[0]
                comp_date = random_date(90, 5)
                trust = a_data.get("trust_tier", 1)

                xp = act.xp_value if status == "completed" else 0
                if status == "completed" and act.xp_open_pct < 100:
                    xp = act.xp_value  # Assume they did the quiz too in seed

                comp = ActivityCompletion(
                    user_id=user.id,
                    activity_id=act.id,
                    status=status,
                    progress_pct=100 if status == "completed" else random.randint(20, 80),
                    started_at=comp_date - timedelta(days=random.randint(1, 14)),
                    completed_at=comp_date if status == "completed" else None,
                    xp_awarded=xp,
                    source="api_sync" if trust <= 2 else "self_reported",
                    trust_tier=trust,
                )
                db.add(comp)

        # Distribute recurring tool usage (last 3 months)
        for month_offset in range(3):
            period = (utcnow() - timedelta(days=30 * month_offset)).strftime("%Y-%m")
            for a_data in recurring:
                act = activity_map[a_data["title"]]
                usage_rate = 0.7 if "Copilot" in a_data["title"] else 0.4
                active_users = random.sample(all_users, k=int(len(all_users) * usage_rate))
                for user in active_users:
                    comp = ActivityCompletion(
                        user_id=user.id,
                        activity_id=act.id,
                        status="completed",
                        progress_pct=100,
                        completed_at=random_date(30 * (month_offset + 1), 30 * month_offset + 1),
                        xp_awarded=act.xp_value,
                        source="api_sync" if a_data.get("trust_tier") == 1 else "excel_import",
                        trust_tier=a_data.get("trust_tier", 1),
                        period_key=period,
                    )
                    db.add(comp)
        await db.flush()

        # Calculate total XP per user
        print("🌱 Calculating XP totals...")
        for user in all_users:
            from sqlalchemy import func, select
            result = await db.execute(
                select(func.coalesce(func.sum(ActivityCompletion.xp_awarded), 0)).where(
                    ActivityCompletion.user_id == user.id,
                    ActivityCompletion.status == "completed",
                )
            )
            total = result.scalar()
            user.total_xp = total

            result2 = await db.execute(
                select(func.coalesce(func.sum(ActivityCompletion.xp_awarded), 0)).where(
                    ActivityCompletion.user_id == user.id,
                    ActivityCompletion.status == "completed",
                    ActivityCompletion.trust_tier <= 2,
                )
            )
            user.verified_xp = result2.scalar()

            # Set level
            for lvl in reversed(LEVELS_DATA):
                if total >= lvl["min_xp"]:
                    user.current_level = lvl["name"]
                    break
        await db.flush()

        print("🌱 Seeding hackathon details...")
        hack_activities = [a for a in ACTIVITIES_DATA if a["category"] == "hackathon"]
        hackathon_data = [
            {"name": "Q4 2025 AI Hackathon", "event_date": date(2025, 11, 15), "status": "completed", "duration_hours": 16},
            {"name": "Prompt-a-thon February 2026", "event_date": date(2026, 2, 20), "status": "completed", "duration_hours": 8},
            {"name": "AI Innovation Day Q2 2026", "event_date": date(2026, 6, 12), "status": "upcoming", "duration_hours": 16},
        ]
        for i, hd in enumerate(hackathon_data):
            act = activity_map.get(hack_activities[i]["title"])
            hack = Hackathon(
                activity_id=act.id if act else None,
                location="DWA HQ, Ajman",
                max_participants=50,
                **hd,
            )
            db.add(hack)
        await db.flush()

        print("🌱 Seeding data source configs...")
        for ds in DATA_SOURCES:
            config = DataSourceConfig(
                name=ds["name"],
                display_name=ds["display_name"],
                sync_type=ds["sync_type"],
                is_enabled=True,
                sync_interval_minutes=ds.get("sync_interval_minutes", 360),
                last_sync_at=random_date(3, 0) if ds["sync_type"] == "api" else None,
                last_sync_status="success" if ds["sync_type"] == "api" else "never",
                last_sync_records=random.randint(10, 50) if ds["sync_type"] == "api" else 0,
            )
            db.add(config)
        await db.flush()

        print("🌱 Seeding demo sync jobs...")
        configs_result = await db.execute(select(DataSourceConfig).where(DataSourceConfig.sync_type == "api"))
        api_configs = configs_result.scalars().all()
        for config in api_configs[:4]:
            for j in range(2):
                job = SyncJob(
                    data_source_id=config.id,
                    status=random.choice(["success", "success", "success", "partial"]),
                    started_at=random_date(7, 1),
                    completed_at=random_date(7, 1),
                    records_processed=random.randint(15, 40),
                    records_created=random.randint(2, 10),
                    records_updated=random.randint(5, 15),
                    triggered_by="scheduled",
                )
                db.add(job)

        print("🌱 Seeding anomaly flags...")
        flagged_user = all_users[random.randint(15, 25)]
        db.add(AnomalyFlag(
            user_id=flagged_user.id,
            flag_type="speed_violation",
            severity="warning",
            description=f"{flagged_user.full_name} completed 'Machine Learning Fundamentals' (8hr course) in 12 minutes.",
        ))
        db.add(AnomalyFlag(
            user_id=flagged_user.id,
            flag_type="burst_violation",
            severity="warning",
            description=f"{flagged_user.full_name} completed 7 activities on a single day.",
        ))
        resolved_user = all_users[random.randint(5, 14)]
        admin_user = all_users[0]
        db.add(AnomalyFlag(
            user_id=resolved_user.id,
            flag_type="speed_violation",
            severity="warning",
            description=f"{resolved_user.full_name} completed a 4hr course in 45 minutes — reviewed and approved (attended in-person session).",
            resolved=True,
            resolved_by=admin_user.id,
            resolved_at=random_date(5, 1),
            resolution_note="Attended instructor-led session, course auto-marked as complete.",
        ))

        print("🌱 Seeding verification requests...")
        cert_activity = activity_map.get("Google AI Essentials Certificate")
        if cert_activity:
            pending_user = all_users[random.randint(10, 20)]
            comp = ActivityCompletion(
                user_id=pending_user.id,
                activity_id=cert_activity.id,
                status="pending_verification",
                progress_pct=100,
                completed_at=random_date(10, 2),
                xp_awarded=0,
                source="self_reported",
                trust_tier=3,
                evidence_url="https://coursera.org/verify/DEMO12345",
            )
            db.add(comp)
            await db.flush()
            db.add(VerificationRequest(
                completion_id=comp.id,
                user_id=pending_user.id,
                evidence_url="https://coursera.org/verify/DEMO12345",
                evidence_type="certificate",
                notes="Completed Google AI Essentials on Coursera.",
            ))

        print("🌱 Seeding activity feed...")
        for _ in range(50):
            user = random.choice(all_users)
            event_type = random.choices(
                ["completion", "badge_earned", "level_up"],
                weights=[0.7, 0.2, 0.1],
            )[0]
            act = random.choice(list(activity_map.values()))
            feed = ActivityFeed(
                user_id=user.id,
                event_type=event_type,
                event_data={
                    "activity_title": act.title if event_type == "completion" else None,
                    "badge_name": random.choice([b["name"] for b in BADGES_DATA]) if event_type == "badge_earned" else None,
                    "new_level": random.choice([l["name"] for l in LEVELS_DATA]) if event_type == "level_up" else None,
                },
                created_at=random_date(30, 0),
            )
            db.add(feed)

        await db.commit()
        print(f"✅ Seeded {len(all_users)} employees, {len(ACTIVITIES_DATA)} activities, data sources, badges, levels, and more!")
        print(f"   Admin login: sara.al-mansoori@dwa.ae / demo123")


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