import os
from fastapi import FastAPI, Request
from starlette.middleware.sessions import SessionMiddleware
from starlette.staticfiles import StaticFiles
from starlette.responses import FileResponse, RedirectResponse
from contextlib import asynccontextmanager

import models
from database import engine
import auth # Import the new auth module
from config import settings # Import settings to get the secret key

# --- Absolute Path Configuration ---
# Get the absolute path of the directory where this file is located
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
STATIC_DIR = os.path.join(BASE_DIR, "static")

@asynccontextmanager
async def lifespan(app: FastAPI):
    # This code runs on startup
    print("Application startup: Creating database tables...")
    models.Base.metadata.create_all(bind=engine)
    print("Application startup: Database tables created.")
    yield
    # Code below yield runs on shutdown, if needed

app = FastAPI(lifespan=lifespan)

# Mount the 'static' directory using an absolute path for reliability
app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")

# Add the authentication router
app.include_router(auth.router)

# Add session middleware. A secret key is required for signing the session cookie.
# We can reuse our encryption key for this, but in production you might want a separate key.
app.add_middleware(SessionMiddleware, secret_key=settings.ENCRYPTION_KEY)

@app.get("/")
async def read_root():
    return FileResponse(os.path.join(STATIC_DIR, "login.html"))

@app.get("/dashboard")
async def read_dashboard(request: Request):
    # This is our protected route. It checks if a user_id exists in the session.
    if not request.session.get('user_id'):
        # If not, redirect them to the login page.
        return RedirectResponse(url="/")
    return FileResponse(os.path.join(STATIC_DIR, "dashboard.html"))

@app.get("/logout")
async def logout(request: Request):
    # Clear the session cookie
    request.session.clear()
    return RedirectResponse(url="/")