admin / Bid-Sentinel

"""Pydantic request/response schemas."""
from datetime import datetime

from pydantic import BaseModel, ConfigDict, EmailStr

from app.models import BidOutcome, BidStatus, UserRole


# --- Auth -------------------------------------------------------------------
class Token(BaseModel):
    access_token: str
    token_type: str = "bearer"


class LoginRequest(BaseModel):
    email: EmailStr
    password: str


class SetupStatus(BaseModel):
    needs_setup: bool


class AdminSetup(BaseModel):
    email: EmailStr
    full_name: str | None = None
    password: str


# --- Users ------------------------------------------------------------------
class UserBase(BaseModel):
    email: EmailStr
    full_name: str | None = None
    role: UserRole = UserRole.standard


class UserCreate(UserBase):
    password: str


class UserUpdate(BaseModel):
    full_name: str | None = None
    role: UserRole | None = None
    is_active: bool | None = None
    password: str | None = None


class UserOut(UserBase):
    model_config = ConfigDict(from_attributes=True)

    id: int
    is_active: bool
    created_at: datetime


# --- Tenders ----------------------------------------------------------------
class TenderOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    reference: str | None
    url: str
    title: str
    description: str | None
    published_date: datetime | None
    closing_date: datetime | None
    value_amount: float | None
    value_text: str | None
    currency: str
    duration: str | None
    buyer: str | None
    source: str | None
    matched_keyword: str | None
    bid_status: BidStatus
    outcome: BidOutcome
    required_certs: str
    fit_score: int | None
    fit_matched: str
    tech_requirements: str
    ai_summary: str
    created_at: datetime
    updated_at: datetime


class TenderCreate(BaseModel):
    title: str
    buyer: str | None = None
    url: str | None = None  # optional; a placeholder is generated if blank
    description: str | None = None
    value: str | None = None  # free text, parsed into amount/text
    duration: str | None = None
    published_date: datetime | None = None
    closing_date: datetime | None = None


class TenderUpdate(BaseModel):
    """Edit an opportunity. All fields optional; only those sent are applied."""

    title: str | None = None
    buyer: str | None = None
    url: str | None = None
    description: str | None = None
    value: str | None = None
    duration: str | None = None
    published_date: datetime | None = None
    closing_date: datetime | None = None


class BulkDeleteRequest(BaseModel):
    ids: list[int]


class BulkDeleteResult(BaseModel):
    deleted: int
    suppressed: int  # how many are now blocked from future scrapes
    batch_id: str  # pass to POST /tenders/undo/{batch_id} to restore


class DeleteResult(BaseModel):
    """Returned by single delete so the deletion can be undone."""

    batch_id: str


class UndoResult(BaseModel):
    restored: int


class BidStatusUpdate(BaseModel):
    bid_status: BidStatus


class OutcomeUpdate(BaseModel):
    outcome: BidOutcome


# --- Comments ---------------------------------------------------------------
class CommentOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    tender_id: int
    author_email: str
    body: str
    created_at: datetime


class CommentCreate(BaseModel):
    body: str


# --- Audit trail ------------------------------------------------------------
class AuditOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    created_at: datetime
    actor: str
    action: str
    detail: str
    status_code: int | None
    ip: str | None


class PortalStat(BaseModel):
    name: str
    candidates: int
    note: str = ""


class ScrapeResult(BaseModel):
    inserted: int
    skipped: int
    sources: list[str]
    keywords: list[str] = []
    message: str
    candidates: int = 0
    used_sample: bool = False
    portals: list[PortalStat] = []
    skipped_breakdown: dict[str, int] = {}


# --- Portals ----------------------------------------------------------------
class PortalOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    key: str
    name: str
    url: str
    scope: str | None
    live: bool
    enabled: bool
    custom: bool


class PortalUpdate(BaseModel):
    enabled: bool


class PortalCreate(BaseModel):
    name: str
    url: str
    scope: str | None = None


# --- Keywords ---------------------------------------------------------------
class KeywordOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    keyword: str


class KeywordCreate(BaseModel):
    keyword: str


class KeywordList(BaseModel):
    builtin: list[str]
    custom: list[KeywordOut]


# --- Schedule ---------------------------------------------------------------
class ScheduleSlotOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    day_of_week: int
    hour: int
    minute: int
    enabled: bool


class ScheduleSlotCreate(BaseModel):
    """Bulk create: cartesian product of the chosen days and times."""

    days: list[int]  # 0=Mon .. 6=Sun
    times: list[str]  # "HH:MM"


class ScheduleSlotToggle(BaseModel):
    enabled: bool


class ScheduleInfo(BaseModel):
    timezone: str
    slots: list[ScheduleSlotOut]
    next_run: datetime | None


# --- Capability profile & analysis (deterministic, non-AI) ------------------
class CapabilityOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    term: str


class CapabilityCreate(BaseModel):
    term: str


class CapabilityList(BaseModel):
    terms: list[CapabilityOut]


class CapabilityUploadResult(BaseModel):
    filename: str
    extracted_chars: int
    suggested: list[str]  # capability terms generated from the document
    detected_certs: list[str]
    generated_by: str  # "AI" or "keyword extraction"


class RecomputeResult(BaseModel):
    updated: int
    message: str


# --- CPV codes (scrape criteria) --------------------------------------------
class CpvOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    code: str
    description: str
    enabled: bool


class CpvCreate(BaseModel):
    code: str
    description: str | None = None


class CpvUpdate(BaseModel):
    enabled: bool


class CpvStrictConfig(BaseModel):
    """Whether the CPV filter is strict (require a match from every notice) or
    lenient (only narrow notices that actually declare a CPV classification)."""

    strict: bool


# --- Tune-out list (negative filter) ----------------------------------------
class TuneOutOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    term: str


class TuneOutCreate(BaseModel):
    term: str


class TuneOutAddResult(BaseModel):
    """Result of adding a tune-out term: the stored term plus how many existing
    (non-cyber) opportunities were removed immediately."""

    term: TuneOutOut
    removed: int


# --- Accreditations held ----------------------------------------------------
class AccreditationOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    name: str


class AccreditationCreate(BaseModel):
    name: str


# --- Intelligence (analyst) -------------------------------------------------
class IntelSummary(BaseModel):
    opportunities: int
    pipeline_value: float
    win_rate: int | None
    capability_gaps: int
    cert_gaps: int
    target_buyers: int


class CapabilityGapItem(BaseModel):
    term: str
    opportunities: int
    total_value: float


class CertGapItem(BaseModel):
    name: str
    required_count: int
    demand_pct: int
    held: bool


class BuyerItem(BaseModel):
    buyer: str
    opportunities: int
    total_value: float
    avg_fit: int | None
    won: int
    lost: int
    bidding: int
    is_target: bool
    top_services: list[str]
    top_certs: list[str]


class WinLossBand(BaseModel):
    label: str
    won: int
    lost: int
    win_rate: int | None


class WinLoss(BaseModel):
    overall_win_rate: int | None
    won: int
    lost: int
    by_service: list[WinLossBand]
    by_fit: list[WinLossBand]


class TrendPoint(BaseModel):
    label: str
    count: int
    value: float


class SalesAngleItem(BaseModel):
    subject: str
    angle: str
    source: str  # "rules" or "AI"


# --- AI bolt-on -------------------------------------------------------------
class AiConfig(BaseModel):
    enabled: bool
    available: bool  # API key configured?
    model: str


class AiUpdate(BaseModel):
    enabled: bool