"""Читання результатів оцінювання для UI і PDF — без Streamlit."""
from __future__ import annotations

from sqlmodel import Session, select

from db.session import get_engine
from models import (
    AssessmentResults,
    Assessments,
    Companies,
    Nonconformities,
    Requirements,
    TechnologyClasses,
)


def get_assessment_summary(assessment_id: int) -> dict | None:
    with Session(get_engine()) as s:
        assessment = s.get(Assessments, assessment_id)
        if not assessment:
            return None
        company = s.get(Companies, assessment.company_id)
        return {
            "id": assessment.id,
            "company": company.name if company else "?",
            "date": assessment.assessment_date,
            "expert": assessment.expert,
            "status": assessment.status,
            "certification_level": assessment.certification_level,
        }


def get_class_results(assessment_id: int) -> list[dict]:
    with Session(get_engine()) as s:
        classes = s.exec(select(TechnologyClasses).order_by(TechnologyClasses.code)).all()

        all_reqs = s.exec(select(Requirements)).all()
        reqs_by_class: dict[int, list[int]] = {}
        for r in all_reqs:
            reqs_by_class.setdefault(r.class_id, []).append(r.id)

        scored_rows = s.exec(
            select(AssessmentResults).where(
                AssessmentResults.assessment_id == assessment_id
            )
        ).all()
        scored_by_req = {r.requirement_id: r for r in scored_rows}

        result = []
        for tc in classes:
            req_ids = reqs_by_class.get(tc.id, [])
            if not req_ids:
                continue
            total = len(req_ids)
            met = sum(
                1
                for rid in req_ids
                if scored_by_req.get(rid) and scored_by_req[rid].meets
            )
            result.append({
                "class": tc.code,
                "name": tc.name,
                "total": total,
                "met": met,
                "index": met / total if total > 0 else 0.0,
            })
        return result


def get_nonconformities(assessment_id: int) -> list[dict]:
    with Session(get_engine()) as s:
        ncs = s.exec(
            select(Nonconformities)
            .where(Nonconformities.assessment_id == assessment_id)
            .order_by(Nonconformities.severity.desc())  # критичні — першими
        ).all()
        if not ncs:
            return []

        # Пакетне завантаження вимог (уникаємо N+1)
        req_ids = list({nc.requirement_id for nc in ncs})
        reqs = {
            r.id: r
            for r in s.exec(
                select(Requirements).where(Requirements.id.in_(req_ids))
            ).all()
        }
        return [
            {
                "code": reqs[nc.requirement_id].code if nc.requirement_id in reqs else "?",
                "severity": nc.severity,
                "deadline": nc.deadline,
                "recommendation": nc.recommendation or "",
                "is_critical": nc.severity >= 3,  # поріг §С.5.4
            }
            for nc in ncs
        ]