from fastapi import APIRouter, HTTPException, Depends
from fastapi.responses import FileResponse
from sqlmodel import Session, select
from typing import List
import os
from datetime import datetime
from app.models.professionalliabilityinsurance import ProfessionalLiability
from app.schemas.professionalliabilityinsuranceschema import ProfessionalLiabilityCreate, ProfessionalLiabilityUpdate
from app.utils.transaction_generator import generate_transaction_number
from pydantic import BaseModel
from app.services.pdf_generator import generate_pdf
from db import get_session  # your DB session dependency
from app.core.security import get_current_user_info, verify_owner_or_admin

NOT_FOUND_MSG = "Professional Liability insurance not found"

class ProfessionalLiabilityResponse(BaseModel):
    id: int
    transaction_no: str

router = APIRouter(prefix="/api/v1/professionalliability", tags=["Professional Liability Insurance"])

@router.post("/", response_model=ProfessionalLiabilityResponse)
def create_professional_liability_product(
    product: ProfessionalLiabilityCreate, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    obj_data = product.model_dump()
    transaction_no = generate_transaction_number('professional_liability')
    obj_data['transaction_no'] = transaction_no
    obj_data['user_id'] = current_user["user_id"]
    if current_user.get("role") == "customer":
        obj_data['email_address'] = current_user["email"]
        
    # Map contracts_reviewed_by_legal to model field
    if 'contracts_reviewed_by_legal' in obj_data:
        obj_data['contracts_reviewed_legal'] = obj_data.pop('contracts_reviewed_by_legal')
        
    db_product = ProfessionalLiability(**obj_data)
    session.add(db_product)
    session.commit()    
    return ProfessionalLiabilityResponse(id=db_product.id, transaction_no=transaction_no)


@router.get("/", response_model=List[ProfessionalLiability])
def get_all_professional_liability_products(
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    if current_user.get("role") == "admin":
        products = session.exec(select(ProfessionalLiability)).all()
    else:
        products = session.exec(select(ProfessionalLiability).where(ProfessionalLiability.user_id == current_user["user_id"])).all()
    return products

@router.get("/{product_id}", response_model=ProfessionalLiability)
def get_professional_liability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(ProfessionalLiability, product_id)
    if not product:
        raise HTTPException(status_code=404, detail=NOT_FOUND_MSG)
    verify_owner_or_admin(product, current_user)
    return product

@router.put("/{product_id}", response_model=ProfessionalLiability)
def update_professional_liability_product(
    product_id: int, 
    updated: ProfessionalLiabilityUpdate, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(ProfessionalLiability, product_id)
    if not product:
        raise HTTPException(status_code=404, detail=NOT_FOUND_MSG)
    verify_owner_or_admin(product, current_user)

    update_data = updated.model_dump(exclude_unset=True)
    if 'contracts_reviewed_by_legal' in update_data:
        update_data['contracts_reviewed_legal'] = update_data.pop('contracts_reviewed_by_legal')

    for field, value in update_data.items():
        setattr(product, field, value)

    session.add(product)
    session.commit()
    session.refresh(product)
    
    return product

@router.delete("/{product_id}")
def delete_professional_liability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(ProfessionalLiability, product_id)
    if not product:
        raise HTTPException(status_code=404, detail=NOT_FOUND_MSG)
    verify_owner_or_admin(product, current_user)

    session.delete(product)
    session.commit()
    return {"message": "Professional Liability insurance deleted successfully"}

@router.get("/{product_id}/download-pdf")
def download_professional_liability_pdf(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    """Download Professional Liability quote as PDF"""
    product = session.get(ProfessionalLiability, product_id)
    if not product:
        raise HTTPException(status_code=404, detail=NOT_FOUND_MSG)
    verify_owner_or_admin(product, current_user)
    
    context = {
        "quote": product,
        "current_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "base_url": "http://localhost:8000/"
    }
    
    pdf_filename = f"professional_liability_{product_id}.pdf"
    pdf_path = os.path.join("uploads", pdf_filename)
    
    os.makedirs("uploads", exist_ok=True)
    
    if generate_pdf("pdf_professional_liability.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")

ProfessionalLiabilityRouter = router