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.life_insurance_repository import LifeInsuranceRepository
from app.schemas.LifeinsuranceSchema import (
    LifeInsuranceCreate, 
    LifeInsuranceResponse, 
    LifeInsuranceUpdate
)
from app.services.pdf_generator import generate_pdf

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

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

@router.post("/", response_model=LifeInsuranceResponse)
def create_life_insurance(
    policy_data: LifeInsuranceCreate,
    repository: LifeInsuranceRepository = Depends(get_repository)
):
    """Create a new life insurance quote"""
    return repository.create(policy_data)

@router.get("/{policy_id}", response_model=LifeInsuranceResponse)
def get_life_insurance(
    policy_id: int,
    repository: LifeInsuranceRepository = Depends(get_repository)
):
    """Get a life insurance quote by ID"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Life Insurance quote not found")
    return policy

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

@router.put("/{policy_id}", response_model=LifeInsuranceResponse)
def update_life_insurance(
    policy_id: int,
    policy_update: LifeInsuranceUpdate,
    repository: LifeInsuranceRepository = Depends(get_repository)
):
    """Update a life insurance quote"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Life Insurance quote not found")
    return repository.update(policy, policy_update)

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

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

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

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

@router.get("/filter/coverage", response_model=List[LifeInsuranceResponse])
def filter_by_coverage_amount(
    min_amount: float = Query(..., ge=0),
    max_amount: float = Query(..., ge=0),
    repository: LifeInsuranceRepository = Depends(get_repository)
):
    """Filter life insurance quotes by 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_life_insurance_pdf(
    policy_id: int,
    repository: LifeInsuranceRepository = Depends(get_repository)
):
    """Download life insurance quote as PDF"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Life Insurance quote not found")
    
    # Prepare context for PDF template
    context = {
        "life_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"life_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("pdflifeinsurance.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"
    )