main.py

from __future__ import annotations

import os
import socket
from datetime import datetime

from typing import Dict, List
from uuid import UUID

from fastapi import FastAPI, HTTPException
from fastapi import Query, Path
from typing import Optional

from models.person import PersonCreate, PersonRead, PersonUpdate
from models.address import AddressCreate, AddressRead, AddressUpdate
from models.author import AuthorCreate, AuthorRead, AuthorUpdate
from models.book import BookCreate, BookRead, BookUpdate
from models.health import Health

port = int(os.environ.get("FASTAPIPORT", 8000))

# -----------------------------------------------------------------------------
# Fake in-memory "databases"
# -----------------------------------------------------------------------------
persons: Dict[UUID, PersonRead] = {}
addresses: Dict[UUID, AddressRead] = {}
authors: Dict[UUID, AuthorRead] = {}
books: Dict[UUID, BookRead] = {}

app = FastAPI(
    title="Person/Address/Author/Book API",
    description="Demo FastAPI app using Pydantic v2 models for Person, Address, Author, and Book",
    version="0.1.0",
)

# -----------------------------------------------------------------------------
# Address endpoints
# -----------------------------------------------------------------------------

def make_health(echo: Optional[str], path_echo: Optional[str]=None) -> Health:
    return Health(
        status=200,
        status_message="OK",
        timestamp=datetime.utcnow().isoformat() + "Z",
        ip_address=socket.gethostbyname(socket.gethostname()),
        echo=echo,
        path_echo=path_echo
    )

@app.get("/health", response_model=Health)
def get_health_no_path(echo: str | None = Query(None, description="Optional echo string")):
    # Works because path_echo is optional in the model
    return make_health(echo=echo, path_echo=None)

@app.get("/health/{path_echo}", response_model=Health)
def get_health_with_path(
    path_echo: str = Path(..., description="Required echo in the URL path"),
    echo: str | None = Query(None, description="Optional echo string"),
):
    return make_health(echo=echo, path_echo=path_echo)

@app.post("/addresses", response_model=AddressRead, status_code=201)
def create_address(address: AddressCreate):
    if address.id in addresses:
        raise HTTPException(status_code=400, detail="Address with this ID already exists")
    addresses[address.id] = AddressRead(**address.model_dump())
    return addresses[address.id]

@app.get("/addresses", response_model=List[AddressRead])
def list_addresses(
    street: Optional[str] = Query(None, description="Filter by street"),
    city: Optional[str] = Query(None, description="Filter by city"),
    state: Optional[str] = Query(None, description="Filter by state/region"),
    postal_code: Optional[str] = Query(None, description="Filter by postal code"),
    country: Optional[str] = Query(None, description="Filter by country"),
):
    results = list(addresses.values())

    if street is not None:
        results = [a for a in results if a.street == street]
    if city is not None:
        results = [a for a in results if a.city == city]
    if state is not None:
        results = [a for a in results if a.state == state]
    if postal_code is not None:
        results = [a for a in results if a.postal_code == postal_code]
    if country is not None:
        results = [a for a in results if a.country == country]

    return results

@app.get("/addresses/{address_id}", response_model=AddressRead)
def get_address(address_id: UUID):
    if address_id not in addresses:
        raise HTTPException(status_code=404, detail="Address not found")
    return addresses[address_id]

@app.patch("/addresses/{address_id}", response_model=AddressRead)
def update_address(address_id: UUID, update: AddressUpdate):
    if address_id not in addresses:
        raise HTTPException(status_code=404, detail="Address not found")
    stored = addresses[address_id].model_dump()
    stored.update(update.model_dump(exclude_unset=True))
    addresses[address_id] = AddressRead(**stored)
    return addresses[address_id]

# -----------------------------------------------------------------------------
# Person endpoints
# -----------------------------------------------------------------------------
@app.post("/persons", response_model=PersonRead, status_code=201)
def create_person(person: PersonCreate):
    # Each person gets its own UUID; stored as PersonRead
    person_read = PersonRead(**person.model_dump())
    persons[person_read.id] = person_read
    return person_read

@app.get("/persons", response_model=List[PersonRead])
def list_persons(
    uni: Optional[str] = Query(None, description="Filter by Columbia UNI"),
    first_name: Optional[str] = Query(None, description="Filter by first name"),
    last_name: Optional[str] = Query(None, description="Filter by last name"),
    email: Optional[str] = Query(None, description="Filter by email"),
    phone: Optional[str] = Query(None, description="Filter by phone number"),
    birth_date: Optional[str] = Query(None, description="Filter by date of birth (YYYY-MM-DD)"),
    city: Optional[str] = Query(None, description="Filter by city of at least one address"),
    country: Optional[str] = Query(None, description="Filter by country of at least one address"),
):
    results = list(persons.values())

    if uni is not None:
        results = [p for p in results if p.uni == uni]
    if first_name is not None:
        results = [p for p in results if p.first_name == first_name]
    if last_name is not None:
        results = [p for p in results if p.last_name == last_name]
    if email is not None:
        results = [p for p in results if p.email == email]
    if phone is not None:
        results = [p for p in results if p.phone == phone]
    if birth_date is not None:
        results = [p for p in results if str(p.birth_date) == birth_date]

    # nested address filtering
    if city is not None:
        results = [p for p in results if any(addr.city == city for addr in p.addresses)]
    if country is not None:
        results = [p for p in results if any(addr.country == country for addr in p.addresses)]

    return results

@app.get("/persons/{person_id}", response_model=PersonRead)
def get_person(person_id: UUID):
    if person_id not in persons:
        raise HTTPException(status_code=404, detail="Person not found")
    return persons[person_id]

@app.patch("/persons/{person_id}", response_model=PersonRead)
def update_person(person_id: UUID, update: PersonUpdate):
    if person_id not in persons:
        raise HTTPException(status_code=404, detail="Person not found")
    stored = persons[person_id].model_dump()
    stored.update(update.model_dump(exclude_unset=True))
    persons[person_id] = PersonRead(**stored)
    return persons[person_id]

# -----------------------------------------------------------------------------
# Author endpoints
# -----------------------------------------------------------------------------
@app.get("/authors", response_model=List[AuthorRead])
def list_authors(
    name: Optional[str] = Query(None, description="Filter by name"),
    email: Optional[str] = Query(None, description="Filter by email"),
    birth_date: Optional[str] = Query(None, description="Filter by birth date"),
    nationality: Optional[str] = Query(None, description="Filter by nationality"),
):
    results = list(authors.values())

    if name is not None:
        results = [a for a in results if a.name == name]
    if email is not None:
        results = [a for a in results if a.email == email]
    if birth_date is not None:
        results = [a for a in results if a.birth_date == birth_date]
    if nationality is not None:
        results = [a for a in results if a.nationality == nationality]

    return results

@app.post("/authors", response_model=AuthorRead, status_code=201)
def create_author(author: AuthorCreate):
    author_read = AuthorRead(**author.model_dump())
    authors[author_read.name] = author_read
    return author_read

@app.get("/authors/{author_id}", response_model=AuthorRead)
def get_author(author_id: str):
    if author_id not in authors:
        raise HTTPException(status_code=404, detail="Author not found")
    return authors[author_id]

@app.put("/authors/{author_id}", response_model=AuthorRead)
def update_author(author_id: str, update: AuthorUpdate):
    if author_id not in authors:
        raise HTTPException(status_code=404, detail="Author not found")
    stored = authors[author_id].model_dump()
    stored.update(update.model_dump(exclude_unset=True))
    authors[author_id] = AuthorRead(**stored)
    return authors[author_id]

@app.delete("/authors/{author_id}", response_model=dict)
def delete_author(author_id: str):
    if author_id not in authors:
        raise HTTPException(status_code=404, detail="Author not found")
    del authors[author_id]
    return {f"Author {author_id} deleted"}

# -----------------------------------------------------------------------------
# Book endpoints
# -----------------------------------------------------------------------------
@app.get("/books", response_model=List[BookRead])
def list_books(
    title: Optional[str] = Query(None, description="Filter by title"),
    author: Optional[str] = Query(None, description="Filter by author"),
    published_year: Optional[str] = Query(None, description="Filter by published_year"),
    type: Optional[str] = Query(None, description="Filter by type"),

):
    results = list(books.values())

    if title is not None:
        results = [a for a in results if a.title == title]
    if author is not None:
        results = [a for a in results if a.author == author]
    if published_year is not None:
        results = [a for a in results if a.published_year == published_year]
    if type is not None:
        results = [a for a in results if a.type == type]

    return results

@app.post("/books", response_model=BookRead, status_code=201)
def create_book(book: BookCreate):
    book_read = BookRead(**book.model_dump())
    books[book_read.title] = book_read
    return book_read

@app.get("/books/{book_id}", response_model=BookRead)
def get_book(book_id: str):
    if book_id not in books:
        raise HTTPException(status_code=404, detail="Book not found")
    return books[book_id]

@app.put("/books/{book_id}", response_model=BookRead)
def update_book(book_id: str, update: BookUpdate):
    if book_id not in books:
        raise HTTPException(status_code=404, detail="Book not found")
    stored = books[book_id].model_dump()
    stored.update(update.model_dump(exclude_unset=True))
    books[book_id] = BookRead(**stored)
    return books[book_id]

@app.delete("/books/{book_id}", response_model=dict)
def delete_book(book_id: str):
    if book_id not in books:
        raise HTTPException(status_code=404, detail="Book not found")
    del books[book_id]
    return {f"Book {book_id} deleted"}

# -----------------------------------------------------------------------------
# Root
# -----------------------------------------------------------------------------
@app.get("/")
def root():
    return {"message": "Welcome to the Person/Address API. See /docs for OpenAPI UI."}

# -----------------------------------------------------------------------------
# Entrypoint for `python main.py`
# -----------------------------------------------------------------------------
if __name__ == "__main__":
    import uvicorn

    uvicorn.run("main:app", host="0.0.0.0", port=port, reload=True)