from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi.responses import FileResponse
from sqlmodel import Session
from typing import List, Optional
from datetime import datetime
import os
from db import get_session
from app.repository.renters_insurance_repository import RentersInsuranceRepository
from app.schemas.RentersInsuranceSchema import (
    RentersInsuranceCreate, 
    RentersInsuranceResponse, 
    RentersInsuranceUpdate
)
from app.services.pdf_generator import generate_pdf

router = APIRouter(prefix="/api/v1/renters-insurance", tags=["Renters Insurance"])

def get_repository(session: Session = Depends(get_session)) -> RentersInsuranceRepository:
    return RentersInsuranceRepository(session)

@router.post("/", response_model=RentersInsuranceResponse)
def create_renters_insurance(
    policy_data: RentersInsuranceCreate,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Create a new renters insurance quote"""
    return repository.create(policy_data)

@router.get("/{policy_id}", response_model=RentersInsuranceResponse)
def get_renters_insurance(
    policy_id: int,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Get a renters insurance quote by ID"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Renters Insurance quote not found")
    return policy

@router.get("/", response_model=List[RentersInsuranceResponse])
def get_renters_insurance_quotes(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Get all renters insurance quotes with pagination"""
    return repository.get_multi(skip=skip, limit=limit)

@router.put("/{policy_id}", response_model=RentersInsuranceResponse)
def update_renters_insurance(
    policy_id: int,
    policy_update: RentersInsuranceUpdate,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Update a renters insurance quote"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Renters Insurance quote not found")
    return repository.update(policy, policy_update)

@router.delete("/{policy_id}")
def delete_renters_insurance(
    policy_id: int,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Delete a renters insurance quote"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Renters Insurance quote not found")
    repository.remove(policy_id)
    return {"message": "Renters Insurance quote deleted successfully"}

@router.get("/search/name/{name}", response_model=List[RentersInsuranceResponse])
def search_by_name(
    name: str,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Search renters insurance quotes by applicant name"""
    return repository.search_by_name(name)

@router.get("/search/email/{email}", response_model=List[RentersInsuranceResponse])
def search_by_email(
    email: str,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Search renters insurance quotes by email address"""
    return repository.search_by_email(email)

@router.get("/filter/status/{status}", response_model=List[RentersInsuranceResponse])
def filter_by_status(
    status: str,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Filter renters insurance quotes by status"""
    return repository.get_by_status(status)

@router.get("/filter/property-type/{property_type}", response_model=List[RentersInsuranceResponse])
def filter_by_property_type(
    property_type: str,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Filter renters insurance quotes by property type"""
    return repository.get_by_property_type(property_type)

@router.get("/filter/state/{state}", response_model=List[RentersInsuranceResponse])
def filter_by_state(
    state: str,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Filter renters insurance quotes by state"""
    return repository.get_by_state(state)

@router.get("/filter/coverage", response_model=List[RentersInsuranceResponse])
def filter_by_coverage_amount(
    min_amount: float = Query(..., ge=0),
    max_amount: float = Query(..., ge=0),
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Filter renters insurance quotes by personal property coverage amount range"""
    if min_amount > max_amount:
        raise HTTPException(status_code=400, detail="Minimum amount cannot be greater than maximum amount")
    return repository.get_by_coverage_amount_range(min_amount, max_amount)

@router.get("/{policy_id}/download-pdf")
def download_renters_insurance_pdf(
    policy_id: int,
    repository: RentersInsuranceRepository = Depends(get_repository)
):
    """Download renters insurance quote as PDF"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Renters Insurance quote not found")
    
    # Prepare context for PDF template
    context = {
        "renters_insurance": policy,
        "current_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "base_url": "https://insuranceexchange.com/"  # Update with your actual base URL
    }
    
    # Generate PDF
    pdf_filename = f"renters_insurance_quote_{policy_id}.pdf"
    pdf_path = os.path.join("uploads", pdf_filename)
    
    # Ensure uploads directory exists
    os.makedirs("uploads", exist_ok=True)
    
    success = generate_pdf("pdfrentersinsurance.html", context, pdf_path)
    
    if not success:
        raise HTTPException(status_code=500, detail="Failed to generate PDF")
    
    return FileResponse(
        path=pdf_path,
        filename=pdf_filename,
        media_type="application/pdf"
    )