from fastapi import APIRouter, HTTPException, Depends
from fastapi.responses import FileResponse
from sqlmodel import Session, select
from typing import List
from pydantic import BaseModel
import os
from datetime import datetime
from app.models.cyberliabilityinsurance import Cyberliability
from app.schemas.cyberliabilityinsuranceschema import CyberInsuranceCreate, CyberInsuranceUpdate
from app.services.pdf_generator import generate_pdf
from app.utils.transaction_generator import generate_transaction_number
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 = "Cyber Liability not found"

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

router = APIRouter(prefix="/api/v1/cyberliability", tags=["Cyberliability Insurance"])

@router.post("/", response_model=CyberliabilityResponse)
def create_cyberliability_product(
    product: CyberInsuranceCreate, 
    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('cyber_liability')
    obj_data['user_id'] = current_user["user_id"]
    if current_user.get("role") == "customer":
        obj_data['email_address'] = current_user["email"]
        
    # Convert HttpUrl to string if present
    if obj_data.get('website_url'):
        obj_data['website_url'] = str(obj_data['website_url'])
        
    # Map mismatch fields from schema to model
    pct = obj_data.pop('percentage_online', None)
    pct_bus = obj_data.pop('percentage_business_online', None)
    obj_data['percentage_business_online'] = pct if pct is not None else pct_bus

    pri_inc = obj_data.pop('prior_incidents', None)
    pri_cyb = obj_data.pop('prior_cyber_incidents', None)
    obj_data['prior_cyber_incidents'] = pri_cyb if pri_cyb is not None else (pri_inc if pri_inc is not None else False)

    tpv = obj_data.pop('third_party_vendors', None)
    tpv_acc = obj_data.pop('third_party_vendors_access', None)
    obj_data['third_party_vendors_access'] = tpv_acc if tpv_acc is not None else tpv

    nts = obj_data.pop('notes', None)
    spc_nts = obj_data.pop('special_coverage_notes', None)
    obj_data['special_coverage_notes'] = spc_nts if spc_nts is not None else nts

    pol_exp = obj_data.pop('policy_expiration_date', None)
    cur_exp = obj_data.pop('current_policy_expiration', None)
    obj_data['current_policy_expiration'] = cur_exp if cur_exp is not None else pol_exp

    inc_desc = obj_data.pop('incident_description', None)
    pst_desc = obj_data.pop('past_incidents_description', None)
    obj_data['past_incidents_description'] = pst_desc if pst_desc is not None else inc_desc

    valid_model_keys = set(Cyberliability.model_fields.keys())
    filtered_data = {k: v for k, v in obj_data.items() if k in valid_model_keys}
        
    db_product = Cyberliability(**filtered_data)
    session.add(db_product)
    session.commit()
    
    return CyberliabilityResponse(id=db_product.id, transaction_no=db_product.transaction_no)

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

@router.get("/{product_id}", response_model=Cyberliability)
def get_cyberliability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(Cyberliability, 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=Cyberliability)
def update_cyberliability_product(
    product_id: int, 
    updated: CyberInsuranceUpdate, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(Cyberliability, 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 'website_url' in update_data and update_data['website_url']:
        update_data['website_url'] = str(update_data['website_url'])
        
    # Map mismatch fields from schema to model
    if 'percentage_online' in update_data:
        update_data['percentage_business_online'] = update_data.pop('percentage_online')
    if 'prior_incidents' in update_data:
        update_data['prior_cyber_incidents'] = update_data.pop('prior_incidents')
    if 'third_party_vendors' in update_data:
        update_data['third_party_vendors_access'] = update_data.pop('third_party_vendors')
    if 'notes' in update_data:
        update_data['special_coverage_notes'] = update_data.pop('notes')

    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_cyberliability_product(
    product_id: int, 
    current_user: dict = Depends(get_current_user_info),
    session: Session = Depends(get_session)
):
    product = session.get(Cyberliability, 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": "Cyber Liability deleted successfully"}

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

CyberliabilityRouter = router