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.annuity_insurance_repository import AnnuityInsuranceRepository
from app.schemas.AnnuityInsuranceSchema import (
    AnnuityInsuranceCreate, 
    AnnuityInsuranceResponse, 
    AnnuityInsuranceUpdate
)
from app.services.pdf_generator import generate_pdf

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

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

@router.post("/", response_model=AnnuityInsuranceResponse)
def create_annuity_insurance(
    policy_data: AnnuityInsuranceCreate,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Create a new annuity insurance quote"""
    return repository.create(policy_data)

@router.get("/{policy_id}", response_model=AnnuityInsuranceResponse)
def get_annuity_insurance(
    policy_id: int,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Get an annuity insurance quote by ID"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Annuity Insurance quote not found")
    return policy

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

@router.put("/{policy_id}", response_model=AnnuityInsuranceResponse)
def update_annuity_insurance(
    policy_id: int,
    policy_update: AnnuityInsuranceUpdate,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Update an annuity insurance quote"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Annuity Insurance quote not found")
    return repository.update(policy, policy_update)

@router.delete("/{policy_id}")
def delete_annuity_insurance(
    policy_id: int,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Delete an annuity insurance quote"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Annuity Insurance quote not found")
    repository.remove(policy_id)
    return {"message": "Annuity Insurance quote deleted successfully"}

@router.get("/search/name", response_model=List[AnnuityInsuranceResponse])
def search_by_name(
    first_name: Optional[str] = Query(None),
    last_name: Optional[str] = Query(None),
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Search annuity insurance quotes by applicant name"""
    if not first_name and not last_name:
        raise HTTPException(status_code=400, detail="At least one name parameter is required")
    return repository.search_by_name(first_name, last_name)

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

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

@router.get("/filter/investment", response_model=List[AnnuityInsuranceResponse])
def filter_by_investment_amount(
    min_amount: float = Query(..., ge=0),
    max_amount: float = Query(..., ge=0),
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Filter annuity insurance quotes by initial investment range"""
    if min_amount > max_amount:
        raise HTTPException(status_code=400, detail="Minimum amount cannot be greater than maximum amount")
    return repository.get_by_investment_range(min_amount, max_amount)

@router.get("/filter/payment-frequency/{frequency}", response_model=List[AnnuityInsuranceResponse])
def filter_by_payment_frequency(
    frequency: str,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Filter annuity insurance quotes by payment frequency"""
    return repository.get_by_payment_frequency(frequency)

@router.get("/filter/purchase-type/{purchase_type}", response_model=List[AnnuityInsuranceResponse])
def filter_by_purchase_type(
    purchase_type: str,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Filter annuity insurance quotes by purchase type"""
    return repository.get_by_purchase_type(purchase_type)

@router.get("/{policy_id}/download-pdf")
def download_annuity_insurance_pdf(
    policy_id: int,
    repository: AnnuityInsuranceRepository = Depends(get_repository)
):
    """Download annuity insurance quote as PDF"""
    policy = repository.get(policy_id)
    if not policy:
        raise HTTPException(status_code=404, detail="Annuity Insurance quote not found")
    
    context = {
        "annuity": policy,
        "current_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "base_url": "https://insuranceexchange.com/"
    }
    
    pdf_filename = f"annuity_insurance_quote_{policy_id}.pdf"
    pdf_path = os.path.join("uploads", pdf_filename)
    
    os.makedirs("uploads", exist_ok=True)
    
    if generate_pdf("pdfannuity.html", context, pdf_path):
        return FileResponse(
            path=pdf_path,
            filename=pdf_filename,
            media_type="application/pdf"
        )
    else:
        raise HTTPException(status_code=500, detail="Failed to generate PDF")