import os
from fastapi import FastAPI, Request, Depends
from starlette.middleware.sessions import SessionMiddleware
from starlette.staticfiles import StaticFiles
from starlette.responses import FileResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
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")
TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")

@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)

# Configure Jinja2 templates
templates = Jinja2Templates(directory=TEMPLATES_DIR)

# 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, db: Session = Depends(auth.get_db)):
    # This is our protected route. It checks if a user_id exists in the session.
    user_id = request.session.get('user_id')
    if not user_id:
        # If not, redirect them to the login page.
        return RedirectResponse(url="/")
    
    user = db.query(models.User).filter(models.User.id == user_id).first()
    overlay_url = f"{settings.APP_BASE_URL}/overlay/{user.id}"

    return templates.TemplateResponse("dashboard.html", {"request": request, "user": user, "overlay_url": overlay_url})

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