from ninja import Schema, ModelSchema, File
from ninja.files import UploadedFile
from typing import List, Optional
from datetime import datetime
from uuid import UUID

from .models import Submission, PuzzleResponse, SubmissionFile, SteamCollectionItem


# Input Schemas
class SubmissionFileIn(Schema):
    """Schema for file upload data"""

    original_filename: str
    content_type: str
    ocr_data: Optional[dict] = None


class PuzzleResponseIn(Schema):
    """Schema for creating a puzzle response"""

    puzzle_id: int
    puzzle_name: str
    cost: Optional[str] = None
    cycles: Optional[str] = None
    area: Optional[str] = None
    needs_manual_validation: bool = False
    ocr_confidence_score: Optional[float] = None


class SubmissionIn(Schema):
    """Schema for creating a submission"""

    notes: Optional[str] = None
    responses: List[PuzzleResponseIn]


# Output Schemas
class SubmissionFileOut(ModelSchema):
    """Schema for submission file output"""

    file_url: Optional[str]

    class Meta:
        model = SubmissionFile
        fields = [
            "id",
            "original_filename",
            "file_size",
            "content_type",
            "ocr_processed",
            "ocr_raw_data",
            "ocr_error",
            "created_at",
        ]


class PuzzleResponseOut(ModelSchema):
    """Schema for puzzle response output"""

    files: List[SubmissionFileOut]
    final_cost: Optional[str]
    final_cycles: Optional[str]
    final_area: Optional[str]

    class Meta:
        model = PuzzleResponse
        fields = [
            "id",
            "puzzle",
            "puzzle_name",
            "cost",
            "cycles",
            "area",
            "needs_manual_validation",
            "ocr_confidence_score",
            "validated_cost",
            "validated_cycles",
            "validated_area",
            "created_at",
            "updated_at",
        ]


class SubmissionOut(ModelSchema):
    """Schema for submission output"""

    responses: List[PuzzleResponseOut]
    total_responses: int
    needs_validation: bool

    class Meta:
        model = Submission
        fields = [
            "id",
            "user",
            "notes",
            "is_validated",
            "validated_by",
            "validated_at",
            "created_at",
            "updated_at",
        ]


class SubmissionListOut(Schema):
    """Schema for submission list output"""

    id: UUID
    # user: int
    notes: Optional[str]
    total_responses: int
    needs_validation: bool
    is_validated: bool
    created_at: datetime
    updated_at: datetime


# Validation Schemas
class ValidationIn(Schema):
    """Schema for manual validation input"""

    validated_cost: Optional[str] = None
    validated_cycles: Optional[str] = None
    validated_area: Optional[str] = None


# Collection Schemas
class SteamCollectionItemOut(ModelSchema):
    """Schema for Steam collection item output"""

    steam_url: str

    class Meta:
        model = SteamCollectionItem
        fields = [
            "id",
            "steam_item_id",
            "title",
            "author_name",
            "description",
            "tags",
            "order_index",
            "created_at",
            "updated_at",
        ]


# Error Schemas
class ErrorOut(Schema):
    """Schema for error responses"""

    detail: str
    code: Optional[str] = None


class ValidationErrorOut(Schema):
    """Schema for validation error responses"""

    detail: str
    errors: dict


# User Schemas
class UserInfoOut(Schema):
    """Schema for user information output"""

    id: Optional[int] = None
    username: Optional[str] = None
    first_name: Optional[str] = None
    last_name: Optional[str] = None
    email: Optional[str] = None
    is_authenticated: bool
    is_staff: bool
    is_superuser: bool
    cas_groups: Optional[List[str]] = None
