from fastapi import APIRouter, Depends, HTTPException, Query, UploadFile, File
from fastapi.responses import FileResponse
from sqlmodel import Session
from typing import List, Optional
import os, shutil, uuid
from datetime import datetime
from db import get_session
from app.repository.agriculture_insurance_repository import AgricultureInsuranceRepository
from app.schemas.AgricultureInsuranceSchema import (
    AgricultureInsuranceCreate, 
    AgricultureInsuranceResponse, 
    AgricultureInsuranceUpdate
)
from app.services.pdf_generator import generate_pdf

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

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

@router.post("/", response_model=AgricultureInsuranceResponse)
def create_agriculture_insurance(
    insurance_data: AgricultureInsuranceCreate,
    repository: AgricultureInsuranceRepository = Depends(get_repository)
):
    return repository.create(insurance_data)


@router.post("/{insurance_id}/upload-files")
def upload_agriculture_insurance_files(
    insurance_id: int,
    gps_field_map: Optional[UploadFile] = File(default=None, description="GPS Field Map (.kml, .shp, .geojson, .zip)"),
    vet_records: Optional[UploadFile] = File(default=None, description="Veterinary Records (.pdf, .jpg, .png)"),
    repository: AgricultureInsuranceRepository = Depends(get_repository)
):
    """Upload GPS Field Map and/or Veterinary Records for an Agriculture Insurance quote."""
    insurance = repository.get(insurance_id)
    if not insurance:
        raise HTTPException(status_code=404, detail="Agriculture Insurance not found")

    upload_dir = os.path.join("uploads", "agriculture", str(insurance_id))
    os.makedirs(upload_dir, exist_ok=True)

    updates = {}
    saved_files = {}

    # Save GPS Field Map
    if gps_field_map and gps_field_map.filename:
        allowed_gps_ext = {".kml", ".shp", ".geojson", ".zip", ".kmz", ".gpx"}
        ext = os.path.splitext(gps_field_map.filename)[1].lower()
        if ext not in allowed_gps_ext:
            raise HTTPException(
                status_code=400,
                detail=f"GPS Field Map must be one of: {', '.join(allowed_gps_ext)}"
            )
        safe_name = f"gps_{uuid.uuid4().hex}{ext}"
        file_path = os.path.join(upload_dir, safe_name)
        with open(file_path, "wb") as f:
            shutil.copyfileobj(gps_field_map.file, f)
        updates["gps_field_map_uploaded"] = True
        updates["gps_field_map_path"] = file_path.replace("\\", "/")
        saved_files["gps_field_map"] = {
            "filename": gps_field_map.filename,
            "path": updates["gps_field_map_path"],
            "size_bytes": os.path.getsize(file_path)
        }

    # Save Veterinary Records
    if vet_records and vet_records.filename:
        allowed_vet_ext = {".pdf", ".jpg", ".jpeg", ".png", ".docx", ".doc"}
        ext = os.path.splitext(vet_records.filename)[1].lower()
        if ext not in allowed_vet_ext:
            raise HTTPException(
                status_code=400,
                detail=f"Vet Records must be one of: {', '.join(allowed_vet_ext)}"
            )
        safe_name = f"vet_{uuid.uuid4().hex}{ext}"
        file_path = os.path.join(upload_dir, safe_name)
        with open(file_path, "wb") as f:
            shutil.copyfileobj(vet_records.file, f)
        updates["vet_records_uploaded"] = True
        updates["vet_records_path"] = file_path.replace("\\", "/")
        saved_files["vet_records"] = {
            "filename": vet_records.filename,
            "path": updates["vet_records_path"],
            "size_bytes": os.path.getsize(file_path)
        }

    if not updates:
        raise HTTPException(status_code=400, detail="No files provided. Send at least one file.")

    # Persist path + flag updates directly via SQLAlchemy to avoid re-encryption
    from sqlalchemy import text
    set_clauses = ", ".join(f"{k} = :{k}" for k in updates)
    updates["id"] = insurance_id
    repository.session.execute(
        text(f"UPDATE agriculture_insurance SET {set_clauses} WHERE id = :id"),
        updates
    )
    repository.session.commit()

    return {
        "message": "Files uploaded successfully",
        "insurance_id": insurance_id,
        "uploaded": saved_files
    }

@router.get("/{insurance_id}", response_model=AgricultureInsuranceResponse)
def get_agriculture_insurance(
    insurance_id: int,
    repository: AgricultureInsuranceRepository = Depends(get_repository)
):
    insurance = repository.get(insurance_id)
    if not insurance:
        raise HTTPException(status_code=404, detail="Agriculture Insurance not found")
    return insurance

@router.get("/", response_model=List[AgricultureInsuranceResponse])
def get_agriculture_insurances(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    repository: AgricultureInsuranceRepository = Depends(get_repository)
):
    return repository.get_multi(skip=skip, limit=limit)

# @router.put("/{insurance_id}", response_model=AgricultureInsuranceResponse)
# def update_agriculture_insurance(
#     insurance_id: int,
#     insurance_update: AgricultureInsuranceUpdate,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     insurance = repository.get(insurance_id)
#     if not insurance:
#         raise HTTPException(status_code=404, detail="Agriculture Insurance not found")
#     return repository.update(insurance, insurance_update)

# @router.delete("/{insurance_id}")
# def delete_agriculture_insurance(
#     insurance_id: int,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     insurance = repository.get(insurance_id)
#     if not insurance:
#         raise HTTPException(status_code=404, detail="Agriculture Insurance not found")
#     repository.remove(insurance_id)
#     return {"message": "Agriculture Insurance deleted successfully"}

# @router.get("/search/farm/{farm_name}", response_model=List[AgricultureInsuranceResponse])
# def search_by_farm_name(
#     farm_name: str,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     return repository.search_by_farm_name(farm_name)

# @router.get("/search/email/{email}", response_model=List[AgricultureInsuranceResponse])
# def search_by_email(
#     email: str,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     return repository.search_by_email(email)

# @router.get("/filter/state/{state}", response_model=List[AgricultureInsuranceResponse])
# def filter_by_state(
#     state: str,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     return repository.get_by_state(state)

# @router.get("/filter/status/{status}", response_model=List[AgricultureInsuranceResponse])
# def filter_by_status(
#     status: str,
#     repository: AgricultureInsuranceRepository = Depends(get_repository)
# ):
#     return repository.get_by_status(status)

@router.get("/{insurance_id}/download-pdf")
def download_agriculture_insurance_pdf(
    insurance_id: int,
    repository: AgricultureInsuranceRepository = Depends(get_repository)
):
    """Download Agriculture Insurance quote as PDF"""
    insurance = repository.get(insurance_id)
    if not insurance:
        raise HTTPException(status_code=404, detail="Agriculture Insurance not found")
    
    # Create context for PDF template
    context = {
        "quote": insurance,
        "current_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "base_url": "http://localhost:8000/"
    }
    
    # Generate PDF
    pdf_filename = f"agriculture_insurance_{insurance_id}.pdf"
    pdf_path = os.path.join("uploads", pdf_filename)
    
    if generate_pdf("pdf_agriculture_insurance.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")