routes.py

from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session

from database import get_db
import crud
import schemas
from auth import create_access_token
from redis_client import redis_client
import json

router = APIRouter()

@router.post("/user",response_model=schemas.UserResponse)
def create_user(user:schemas.UserCreate,db:Session=Depends(get_db)):
    return crud.create_user(db,user)

@router.get("/users",response_model=list[schemas.UserResponse])
def get_users(db:Session = Depends(get_db)):
    return crud.get_users(db)

@router.get("/user/{user_id}",response_model=schemas.UserResponse)
def get_user(user_id:int,db:Session = Depends(get_db)):
    return crud.get_user(db,user_id)

@router.delete("/user/{user_id}")
def delete_user(user_id:int,db:Session = Depends(get_db)):
    return crud.delete_user(db,user_id)

@router.post("/login")
def login(
    user: schemas.UserLogin,
    db: Session = Depends(get_db)
):
    db_user = crud.authenticate_user(
        db,
        user.name,
        user.password
    )

    if not db_user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid username or password"
        )

    access_token = create_access_token({
        "sub": str(db_user.id)
    })

    return {
        "access_token": access_token,
        "token_type": "bearer"
    }

@router.post("/book", response_model=schemas.BookResponse)
def create_book(
    book: schemas.BookCreate,
    db: Session = Depends(get_db)
):
    new_book = crud.create_book(db, book)

    # Database changed → old cache is no longer valid
    redis_client.delete("books")

    return new_book


@router.get("/books", response_model=list[schemas.BookResponse])
def get_books(db: Session = Depends(get_db)):

    # 1. Check Redis first
    cached_books = redis_client.get("books")

    if cached_books:
        return json.loads(cached_books)

    # 2. Cache miss → get data from PostgreSQL
    books = crud.get_books(db)

    books_data = [
        {
            "id": book.id,
            "title": book.title,
            "user_id": book.user_id
        }
        for book in books
    ]

    # 3. Store result in Redis for 60 seconds
    redis_client.set(
        "books",
        json.dumps(books_data),
        ex=60
    )

    return books_data


@router.get("/book/{book_id}", response_model=schemas.BookResponse)
def get_book(
    book_id: int,
    db: Session = Depends(get_db)
):
    book = crud.get_book(db, book_id)

    if not book:
        raise HTTPException(
            status_code=404,
            detail="Book not found"
        )

    return book


@router.put("/book/{book_id}", response_model=schemas.BookResponse)
def update_book(
    book_id: int,
    book: schemas.BookCreate,
    db: Session = Depends(get_db)
):
    updated_book = crud.update_book(db, book_id, book)

    if not updated_book:
        raise HTTPException(
            status_code=404,
            detail="Book not found"
        )

    # Database changed → invalidate cache
    redis_client.delete("books")

    return updated_book


@router.delete("/book/{book_id}")
def delete_book(
    book_id: int,
    db: Session = Depends(get_db)
):
    deleted_book = crud.delete_book(db, book_id)

    if not deleted_book:
        raise HTTPException(
            status_code=404,
            detail="Book not found"
        )

    # Database changed → invalidate cache
    redis_client.delete("books")

    return {
        "message": "Book deleted successfully"
    }