Untitled

# src/routers/case_router.py
from datetime import date as DateType
from typing import List, Optional

from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel, ConfigDict
from sqlalchemy.orm import Session

from src.database import get_db
from src.models.case_model import Case
from src.models.patient_model import Patient

router = APIRouter(prefix="/cases", tags=["cases"])


# ---------- Schemas ----------
class CaseCreate(BaseModel):
    date: DateType
    patient_id: int
    protocol: Optional[str] = None  # boş gelirse otomatik üretilecek
    doctor: str
    diagnosis: Optional[str] = None
    status: Optional[str] = "Bekliyor"
    stage: Optional[str] = "Pre-analitik"


class CaseOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    date: DateType
    patient_id: int
    patient: Optional[str] = None
    protocol: str
    doctor: str
    diagnosis: Optional[str] = None
    status: str
    stage: str
# -----------------------------


def _to_out(c: Case) -> CaseOut:
    return CaseOut(
        id=c.id,
        date=c.date,
        patient_id=c.patient_id,
        patient=(c.patient.full_name if c.patient else None),
        protocol=c.protocol,
        doctor=c.doctor,
        diagnosis=c.diagnosis,
        status=c.status,
        stage=c.stage,
    )


def _next_unique_protocol(db: Session, seed: str) -> str:
    """
    Verilen seed ile başlayarak, veritabanında çakışma oldukça
    -001, -002 ... ekleyerek benzersiz bir protocol üretir.
    """
    base = seed.strip() or "PRT"
    candidate = base
    counter = 1
    while db.query(Case).filter(Case.protocol == candidate).first():
        candidate = f"{base}-{counter:03d}"
        counter += 1
    return candidate


# --------- CREATE CASE ---------
@router.post("/", response_model=CaseOut)
def create_case(body: CaseCreate, db: Session = Depends(get_db)):
    # Hasta var mı?
    patient = db.get(Patient, body.patient_id)
    if not patient:
        raise HTTPException(status_code=400, detail="Geçersiz patient_id")

    # Protokol: verilmişse onu kullan, yoksa güvenli üret
    protocol = _next_unique_protocol(db, body.protocol or "PRT")

    case = Case(
        date=body.date,
        patient_id=body.patient_id,
        protocol=protocol,
        doctor=body.doctor.strip(),
        diagnosis=body.diagnosis,
        status=(body.status or "Bekliyor"),
        stage=(body.stage or "Pre-analitik"),
    )

    db.add(case)
    db.commit()
    db.refresh(case)
    return _to_out(case)


# --------- LIST CASES ---------
@router.get("", response_model=List[CaseOut])      # /cases
@router.get("/", response_model=List[CaseOut])     # /cases/
def list_cases(
    db: Session = Depends(get_db),
    patient_id: Optional[int] = Query(default=None, description="Hastaya göre filtrele"),
):
    q = db.query(Case)
    if patient_id is not None:
        q = q.filter(Case.patient_id == patient_id)
    cases = q.order_by(Case.id.desc()).all()
    return [_to_out(c) for c in cases]


# --------- GET SINGLE CASE ---------
@router.get("/{case_id}", response_model=CaseOut)
def get_case(case_id: int, db: Session = Depends(get_db)):
    c = db.get(Case, case_id)
    if not c:
        raise HTTPException(status_code=404, detail="Vaka bulunamadı")
    return _to_out(c)