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: Optional[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