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.generalliabilityinsurance import GeneralLiability
from app.schemas.generalliabilityschema import GeneralLiabilityCreate, GeneralLiabilityUpdate
from app.services.pdf_generator import generate_pdf
from app.utils.transaction_generator import generate_transaction_number
from pydantic import BaseModel
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 = "General Liability insurance not found"

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

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

@router.post("/", response_model=GeneralLiabilityResponse)
def create_general_liability_product(
    product: GeneralLiabilityCreate, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    obj_data = product.model_dump()
    obj_data['transaction_no'] = generate_transaction_number('general_liability')
    obj_data['user_id'] = current_user["user_id"]
    
    # Enforce email address of the current user if they are a customer
    if current_user.get("role") == "customer":
        obj_data['email_address'] = current_user["email"]
        
    db_product = GeneralLiability(**obj_data)
    session.add(db_product)
    session.commit()    
    return GeneralLiabilityResponse(id=db_product.id, transaction_no=db_product.transaction_no)

@router.get("/", response_model=List[GeneralLiability])
def get_all_general_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(GeneralLiability)).all()
    else:
        products = session.exec(select(GeneralLiability).where(GeneralLiability.user_id == current_user["user_id"])).all()
    return products

@router.get("/{product_id}", response_model=GeneralLiability)
def get_general_liability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(GeneralLiability, 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=GeneralLiability)
def update_general_liability_product(
    product_id: int, 
    updated: GeneralLiabilityUpdate, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(GeneralLiability, product_id)
    if not product:
        raise HTTPException(status_code=404, detail=NOT_FOUND_MSG)
    verify_owner_or_admin(product, current_user)

    for field, value in updated.model_dump(exclude_unset=True).items():
        setattr(product, field, value)

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

@router.delete("/{product_id}")
def delete_general_liability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(GeneralLiability, 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": "General Liability insurance deleted successfully"}

@router.get("/{product_id}/download-pdf")
def download_general_liability_pdf(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    """Download General Liability quote as PDF"""
    product = session.get(GeneralLiability, 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"general_liability_{product_id}.pdf"
    pdf_path = os.path.join("uploads", pdf_filename)
    
    os.makedirs("uploads", exist_ok=True)
    
    if generate_pdf("pdf_general_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")

GeneralLiabilityRouter = router