"""
database/seed_data.py
------------------------
Populates the database with a small synthetic sample dataset — fake users,
completed sessions, and AI predictions — so the dashboard and report views
have something to show without manually running dozens of chat sessions.

This data is entirely synthetic (randomly generated), not real participant
data. Run from the project root:

    python3 -m database.seed_data
"""

import random
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))

from backend.database import SessionLocal, init_db  # noqa: E402
from backend import db_models  # noqa: E402
from backend.auth import hash_password  # noqa: E402
from mindscreen import questionnaires as q  # noqa: E402
from mindscreen.risk_engine import RiskEngine  # noqa: E402

FAKE_NAMES = ["Alex", "Jordan", "Sam", "Taylor", "Casey", "Riley", "Morgan", "Jamie"]


def _random_responses(n_items: int, max_val: int) -> list:
    return [random.randint(0, max_val) for _ in range(n_items)]


def seed(num_users: int = 15):
    init_db()
    db = SessionLocal()
    engine = RiskEngine(use_ml_signal=True)

    try:
        for i in range(num_users):
            email = f"demo.user{i+1}@example.test"
            existing = db.query(db_models.User).filter(db_models.User.email == email).first()
            if existing:
                continue

            user = db_models.User(
                email=email,
                password_hash=hash_password("DemoPassword123"),
                display_name=random.choice(FAKE_NAMES),
                date_of_birth=datetime(2000, 1, 1).date(),
                is_email_verified=True,
                consent_given_at=datetime.now(timezone.utc),
            )
            db.add(user)
            db.flush()

            phq9_r = _random_responses(9, 3)
            gad7_r = _random_responses(7, 3)
            pss10_r = _random_responses(10, 4)

            phq9 = q.score_phq9(phq9_r)
            gad7 = q.score_gad7(gad7_r)
            pss10 = q.score_pss10(pss10_r)

            nlp_summary = {
                "message_count": random.randint(5, 15),
                "avg_sentiment": round(random.uniform(-0.8, 0.8), 2),
                "total_depression_markers": random.randint(0, 5),
                "total_anxiety_markers": random.randint(0, 5),
                "total_stress_markers": random.randint(0, 5),
                "avg_first_person_ratio": round(random.uniform(0.0, 0.2), 3),
                "avg_absolutist_count": round(random.uniform(0.0, 2.0), 2),
            }

            result = engine.assess(phq9, gad7, pss10, nlp_summary, 26, 26)
            started = datetime.now(timezone.utc) - timedelta(days=random.randint(0, 180))

            session = db_models.ChatSession(
                user_id=user.id, stage="complete", consent_given=True,
                started_at=started, completed_at=started + timedelta(minutes=random.randint(8, 25)),
            )
            db.add(session)
            db.flush()

            for instrument, responses in (("PHQ9", phq9_r), ("GAD7", gad7_r), ("PSS10", pss10_r)):
                for idx, val in enumerate(responses):
                    db.add(db_models.QuestionnaireResponse(
                        session_id=session.id, instrument=instrument,
                        item_index=idx, response_value=val,
                    ))

            db.add(db_models.AIPrediction(
                session_id=session.id,
                depression_score=result.depression.combined_score,
                depression_risk_level=result.depression.risk_level,
                anxiety_score=result.anxiety.combined_score,
                anxiety_risk_level=result.anxiety.risk_level,
                stress_score=result.stress.combined_score,
                stress_risk_level=result.stress.risk_level,
                overall_wellness_score=result.overall_wellness_score,
                confidence_score=result.confidence_score,
                ml_predicted_risk=(result.ml_signal or {}).get("predicted_risk"),
                explanation_json=result.to_dict(),
            ))

        db.commit()
        print(f"Seeded up to {num_users} synthetic demo users/sessions.")
    finally:
        db.close()


if __name__ == "__main__":
    seed()