backend/app/routes/travels_route.py

from fastapi import APIRouter, HTTPException
from typing import List
from fastapi.responses import JSONResponse
from backend.app.schemas.travels import (
    TravelCreate,
    TravelUpdate
)
from backend.app.helper.dependencies import  travel_db , travels_vector_db , embedding_model

router = APIRouter()


@router.post("/get/")
async def get_travels(item_ids: List[str]):
    try:
        travels = travel_db.get_travels(item_ids)
        
        return JSONResponse(
            status_code=200,
            content={
                "message": f"Found {len(travels)} travels",
                "data": travels,
            }
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

@router.post("/add/")
async def add_travels(items: List[TravelCreate]):
    try:
        input_ids = {str(item.id) for item in items}
        duplicates = travel_db.get_existing_travel_ids(input_ids)
        
        valid_items = []
        for item in items:
            if str(item.id) not in duplicates:
                    valid_items.append(item.to_dict())
        
        if not valid_items:
            return JSONResponse(
                status_code=400,
                content={
                    "message": "No valid travels to create",
                }
            )
            
        created_items = travel_db.create_travels(valid_items)
        travels_vector_db.store_embeddings(valid_items, embedding_model)
        
        return JSONResponse(
            status_code=201,
            content={
                "message": f"Successfully created travels",
                "created_travels": [item['id'] for item in created_items],
            }
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

@router.put("/update/")
async def update_travels(items: List[TravelUpdate]):
    try:
        input_ids = {str(item.id) for item in items}
        existing_ids = set(travel_db.get_existing_travel_ids(input_ids))
        
        valid_items = []
        for item in items:
            if str(item.id) in existing_ids:
                    valid_items.append(item.to_dict())
                    
        if not valid_items:
            return JSONResponse(
                status_code=400,
                content={
                    "message": "No valid input to update",
                }
            )
            
        updated_items = travel_db.update_travels(valid_items)
        travels_vector_db.update_embeddings(valid_items, embedding_model)
        
        return JSONResponse(
            status_code=200,
            content={
                "message": f"Successfully updated travels",
                "updated_travels": [item['id'] for item in updated_items],
            }
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

@router.delete("/delete/")
async def delete_travels(item_ids: List[str]):
    try:
        items_to_delete = travel_db.get_travels(item_ids)        
        valid_travels = { item['id'] for item in items_to_delete }
        if not valid_travels:
            return JSONResponse(
                status_code=400,
                content={
                    "message": "No valid travels to delete",
                }
            )
            
        deleted = travel_db.delete_travels(list(valid_travels))
        travels_vector_db.delete_items(list(valid_travels))
            
        return JSONResponse(
            status_code=200,
            content={
                "message": f"Successfully deleted travels",
                "deleted_travels": [item['id'] for item in items_to_delete],
            }
        )
    except Exception as e:
        raise HTTPException(status_code=404, detail=str(e))