main.py

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from typing import List

import models
import schemas
import auth
from database import engine, get_db

# Create database tables
models.Base.metadata.create_all(bind=engine)

# Initialize FastAPI app
app = FastAPI(
    title="Task Manager API",
    description="A task management API with JWT authentication",
    version="1.0.0"
)


#  ROOT ENDPOINT 

@app.get("/", tags=["Root"])
def root():
    """Welcome endpoint"""
    return {
        "message": "Welcome to Task Manager API!",
        "docs": "/docs",
        "endpoints": {
            "register": "POST /register",
            "login": "POST /login",
            "my_info": "GET /users/me",
            "create_task": "POST /tasks/",
            "get_tasks": "GET /tasks/",
            "update_task": "PUT /tasks/{task_id}",
            "delete_task": "DELETE /tasks/{task_id}"
        }
    }


# AUTHENTICATION ENDPOINTS 

@app.post("/register", response_model=schemas.UserResponse, status_code=status.HTTP_201_CREATED, tags=["Auth"])
def register(user: schemas.UserCreate, db: Session = Depends(get_db)):
    """
    Register a new user
    
    - **username**: Must be unique, 3-50 characters
    - **email**: Must be unique, valid email format
    - **password**: Minimum 6 characters
    
    Password is automatically hashed before storing!
    """
    # Check if username already exists
    db_user = db.query(models.User).filter(models.User.username == user.username).first()
    if db_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Username already registered"
        )
    
    # Check if email already exists
    db_user = db.query(models.User).filter(models.User.email == user.email).first()
    if db_user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Email already registered"
        )
    
    # Hash the password
    hashed_password = auth.get_password_hash(user.password)
    
    # Create new user
    new_user = models.User(
        username=user.username,
        email=user.email,
        hashed_password=hashed_password
    )
    
    db.add(new_user)
    db.commit()
    db.refresh(new_user)
    
    return new_user


@app.post("/login", response_model=schemas.Token, tags=["Auth"])
def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
    """
    Login to get access token
    
    - **username**: Your username
    - **password**: Your password
    
    Returns a JWT token that expires in 30 minutes.
    Use this token in the Authorization header for protected endpoints!
    """
    # Find user by username
    user = db.query(models.User).filter(models.User.username == form_data.username).first()
    
    # Check if user exists and password is correct
    if not user or not auth.verify_password(form_data.password, user.hashed_password):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    # Create access token
    access_token = auth.create_access_token(data={"sub": user.username})
    
    return {"access_token": access_token, "token_type": "bearer"}


# USER ENDPOINTS t
@app.get("/users/me", response_model=schemas.UserResponse, tags=["Users"])
def get_current_user_info(current_user: models.User = Depends(auth.get_current_user)):
    """
    Get current logged-in user's information
    
    Protected endpoint - requires valid JWT token!
    """
    return current_user


# ==================== TASK ENDPOINTS (ALL PROTECTED!) ====================

@app.post("/tasks/", response_model=schemas.TaskResponse, status_code=status.HTTP_201_CREATED, tags=["Tasks"])
def create_task(
    task: schemas.TaskCreate,
    current_user: models.User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Create a new task (Protected - requires login!)
    
    - **title**: Task title (required)
    - **description**: Task description (optional)
    - **status**: todo, in_progress, or done (default: todo)
    - **priority**: low, medium, or high (default: medium)
    
    Task is automatically assigned to the logged-in user!
    """
    # Create new task with current user's ID
    new_task = models.Task(
        **task.model_dump(),
        user_id=current_user.id  # ← Automatically use logged-in user's ID!
    )
    
    db.add(new_task)
    db.commit()
    db.refresh(new_task)
    
    return new_task


@app.get("/tasks/", response_model=List[schemas.TaskResponse], tags=["Tasks"])
def get_my_tasks(
    current_user: models.User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Get all tasks for the current logged-in user (Protected!)
    
    You can only see YOUR OWN tasks!
    Other users' tasks are hidden from you.
    """
    # Only return tasks belonging to current user
    tasks = db.query(models.Task).filter(
        models.Task.user_id == current_user.id
    ).all()
    
    return tasks


@app.get("/tasks/{task_id}", response_model=schemas.TaskResponse, tags=["Tasks"])
def get_task(
    task_id: int,
    current_user: models.User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Get a specific task by ID (Protected!)
    
    You can only access YOUR OWN tasks!
    """
    # Find task that belongs to current user
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.user_id == current_user.id  # ← Security check!
    ).first()
    
    if not task:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Task not found (or doesn't belong to you)"
        )
    
    return task


@app.put("/tasks/{task_id}", response_model=schemas.TaskResponse, tags=["Tasks"])
def update_task(
    task_id: int,
    task_update: schemas.TaskUpdate,
    current_user: models.User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Update a task (Protected!)
    
    Only update the fields you provide - others remain unchanged.
    You can only update YOUR OWN tasks!
    """
    # Find task that belongs to current user
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.user_id == current_user.id  # ← Security check!
    ).first()
    
    if not task:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Task not found (or doesn't belong to you)"
        )
    
    # Update only provided fields
    update_data = task_update.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        setattr(task, key, value)
    
    db.commit()
    db.refresh(task)
    
    return task


@app.delete("/tasks/{task_id}", status_code=status.HTTP_204_NO_CONTENT, tags=["Tasks"])
def delete_task(
    task_id: int,
    current_user: models.User = Depends(auth.get_current_user),
    db: Session = Depends(get_db)
):
    """
    Delete a task (Protected!)
    
    You can only delete YOUR OWN tasks!
    """
    # Find task that belongs to current user
    task = db.query(models.Task).filter(
        models.Task.id == task_id,
        models.Task.user_id == current_user.id  # ← Security check!
    ).first()
    
    if not task:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Task not found (or doesn't belong to you)"
        )
    
    db.delete(task)
    db.commit()
    
    return None