from fastapi import APIRouter, HTTPException, UploadFile, File, Form
from typing import Dict, Any, Optional, List
from pydantic import BaseModel
from datetime import datetime
from ...core.document.processor import DocumentProcessor, ProcessedDocument, DocumentConfig
import json

router = APIRouter()

class ProcessingResponse(BaseModel):
    """Document processing response"""
    status: str
    document: ProcessedDocument
    processing_time: float

@router.post("/process", response_model=ProcessingResponse)
async def process_document(
    file: UploadFile = File(...),
    config: Optional[str] = Form(None)
):
    """Process document"""
    try:
        start_time = datetime.now()
        
        # Parse configuration
        proc_config = {}
        if config:
            proc_config = json.loads(config)
        
        # Initialize processor
        processor = DocumentProcessor(proc_config)
        await processor.initialize()
        
        # Process document
        result = await processor.process_document(file.file)
        
        # Calculate processing time
        processing_time = (datetime.now() - start_time).total_seconds()
        
        return ProcessingResponse(
            status="success",
            document=result,
            processing_time=processing_time
        )
        
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Document processing failed: {str(e)}"
        )

@router.post("/batch", response_model=Dict[str, ProcessingResponse])
async def batch_process(files: List[UploadFile] = File(...)):
    """Batch process documents"""
    try:
        # Initialize processor
        processor = DocumentProcessor()
        await processor.initialize()
        
        # Process documents
        results = {}
        for file in files:
            start_time = datetime.now()
            result = await processor.process_document(file.file)
            processing_time = (datetime.now() - start_time).total_seconds()
            
            results[file.filename] = ProcessingResponse(
                status="success",
                document=result,
                processing_time=processing_time
            )
        
        return results
        
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Batch processing failed: {str(e)}"
        )

@router.get("/supported-types")
async def get_supported_types():
    """Get supported document types"""
    processor = DocumentProcessor()
    return {
        "supported_types": processor.SUPPORTED_TYPES
    }

@router.get("/config/validate")
async def validate_config(config: Dict[str, Any]):
    """Validate document processing configuration"""
    try:
        processor = DocumentProcessor(config)
        is_valid = await processor.validate_config()
        
        return {
            "valid": is_valid,
            "config": config
        }
        
    except Exception as e:
        raise HTTPException(
            status_code=400,
            detail=f"Invalid configuration: {str(e)}"
        )

@router.get("/health")
async def health_check():
    """Check document processor health"""
    try:
        processor = DocumentProcessor()
        await processor.initialize()
        
        return {
            "status": "healthy",
            "timestamp": datetime.now()
        }
        
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Health check failed: {str(e)}"
        )