from __future__ import annotations

import uuid
from datetime import datetime
from typing import Any

from pydantic import Field

from app.schemas.common import BaseSchema


class DocumentUploadResponse(BaseSchema):
    """Response after document upload."""

    id: uuid.UUID
    filename: str
    original_filename: str
    content_type: str
    file_size: int
    checksum: str
    status: str
    created_at: datetime


class TextBlockResponse(BaseSchema):
    """Extracted text block."""

    id: uuid.UUID
    text: str
    x: float
    y: float
    width: float
    height: float
    confidence: float | None
    font_family: str | None
    font_size: float | None
    font_color: str | None
    font_style: str | None
    block_type: str
    sequence: int


class DocumentImageResponse(BaseSchema):
    """Extracted document image."""

    id: uuid.UUID
    x: float
    y: float
    width: float
    height: float
    image_path: str
    image_type: str


class DocumentTableResponse(BaseSchema):
    """Extracted document table."""

    id: uuid.UUID
    x: float
    y: float
    width: float
    height: float
    rows: int
    columns: int
    data: dict[str, Any] | None


class DocumentPageResponse(BaseSchema):
    """Document page with extracted content."""

    id: uuid.UUID
    page_number: int
    width: float
    height: float
    image_path: str | None
    text_content: str | None
    text_blocks: list[TextBlockResponse] = Field(default_factory=list)
    images: list[DocumentImageResponse] = Field(default_factory=list)
    tables: list[DocumentTableResponse] = Field(default_factory=list)


class DocumentResponse(BaseSchema):
    """Full document response."""

    id: uuid.UUID
    filename: str
    original_filename: str
    content_type: str
    file_size: int
    checksum: str
    storage_path: str
    status: str
    page_count: int | None
    is_scanned: bool | None
    document_metadata: dict[str, Any] | None
    error_message: str | None
    uploaded_by: uuid.UUID | None
    pages: list[DocumentPageResponse] = Field(default_factory=list)
    created_at: datetime
    updated_at: datetime


class DocumentListResponse(BaseSchema):
    """Minimal document response for lists."""

    id: uuid.UUID
    original_filename: str
    content_type: str
    file_size: int
    status: str
    page_count: int | None
    is_scanned: bool | None
    created_at: datetime


class TemplateMatchResponse(BaseSchema):
    """Template match result."""

    id: uuid.UUID
    document_id: uuid.UUID
    format_id: uuid.UUID
    confidence_score: float
    match_details: dict[str, Any] | None
    selected: bool
    template_name: str | None = None
    created_at: datetime


class TemplateMatchRequest(BaseSchema):
    """Request to match a document against templates."""

    document_id: uuid.UUID
    min_confidence: float = Field(default=0.75, ge=0.0, le=1.0)
    max_results: int = Field(default=5, ge=1, le=20)