from fastapi import APIRouter, Depends, Request, Query
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session, joinedload

from app.database import get_db
from app.models.user import User, UserAffiliation
from app.models.field import Field
from app.models.publication import Publication
from app.models.question import Question
from app.models.job import Job
from app.models.notification import Notification
from app.services.auth import get_current_user
from app.config import settings

router = APIRouter(tags=["pages"])
templates = Jinja2Templates(directory="app/templates")


def base_context(request: Request, user: User | None, db: Session):
    fields = db.query(Field).filter(Field.is_active == True).order_by(Field.name).all()
    unread_count = 0
    if user:
        unread_count = db.query(Notification).filter(Notification.user_id == user.id, Notification.is_read == False).count()
    return {
        "request": request, "user": user, "fields": fields,
        "unread_count": unread_count, "settings": settings,
    }


@router.get("/", response_class=HTMLResponse)
def home(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    fields = db.query(Field).filter(Field.is_active == True).order_by(Field.name).all()
    recent_pubs = db.query(Publication).options(joinedload(Publication.author), joinedload(Publication.field)).order_by(Publication.created_at.desc()).limit(6).all()
    recent_questions = db.query(Question).options(joinedload(Question.author), joinedload(Question.field)).order_by(Question.created_at.desc()).limit(6).all()
    ctx = base_context(request, user, db)
    ctx.update({"recent_pubs": recent_pubs, "recent_questions": recent_questions})
    return templates.TemplateResponse("home.html", ctx)


@router.get("/login", response_class=HTMLResponse)
def login_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    if user:
        from fastapi.responses import RedirectResponse
        return RedirectResponse("/", status_code=302)
    return templates.TemplateResponse("login.html", base_context(request, user, db))


@router.get("/register", response_class=HTMLResponse)
def register_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    if user:
        from fastapi.responses import RedirectResponse
        return RedirectResponse("/", status_code=302)
    return templates.TemplateResponse("register.html", base_context(request, user, db))


@router.get("/publications", response_class=HTMLResponse)
def publications_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    return templates.TemplateResponse("publications.html", base_context(request, user, db))


@router.get("/publications/new", response_class=HTMLResponse)
def new_publication_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    if not user:
        from fastapi.responses import RedirectResponse
        return RedirectResponse("/login", status_code=302)
    return templates.TemplateResponse("publication_form.html", base_context(request, user, db))


@router.get("/publications/{pub_id}", response_class=HTMLResponse)
def publication_detail_page(pub_id: int, request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    ctx = base_context(request, user, db)
    ctx["pub_id"] = pub_id
    return templates.TemplateResponse("publication_detail.html", ctx)


@router.get("/questions", response_class=HTMLResponse)
def questions_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    return templates.TemplateResponse("questions.html", base_context(request, user, db))


@router.get("/questions/new", response_class=HTMLResponse)
def new_question_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    if not user:
        from fastapi.responses import RedirectResponse
        return RedirectResponse("/login", status_code=302)
    return templates.TemplateResponse("question_form.html", base_context(request, user, db))


@router.get("/questions/{question_id}", response_class=HTMLResponse)
def question_detail_page(question_id: int, request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    ctx = base_context(request, user, db)
    ctx["question_id"] = question_id
    return templates.TemplateResponse("question_detail.html", ctx)


@router.get("/jobs", response_class=HTMLResponse)
def jobs_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    return templates.TemplateResponse("jobs.html", base_context(request, user, db))


@router.get("/jobs/new", response_class=HTMLResponse)
def new_job_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    if not user:
        from fastapi.responses import RedirectResponse
        return RedirectResponse("/login", status_code=302)
    return templates.TemplateResponse("job_form.html", base_context(request, user, db))


@router.get("/jobs/{job_id}", response_class=HTMLResponse)
def job_detail_page(job_id: int, request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    ctx = base_context(request, user, db)
    ctx["job_id"] = job_id
    return templates.TemplateResponse("job_detail.html", ctx)


@router.get("/profile/{username}", response_class=HTMLResponse)
def profile_page(username: str, request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    profile_user = db.query(User).options(joinedload(User.affiliations), joinedload(User.field)).filter(User.username == username).first()
    if not profile_user:
        from fastapi.responses import HTMLResponse as HR
        return HR("<h1>User not found</h1>", status_code=404)
    ctx = base_context(request, user, db)
    ctx["profile_user"] = profile_user
    ctx["pubs_count"] = db.query(Publication).filter(Publication.author_id == profile_user.id).count()
    ctx["questions_count"] = db.query(Question).filter(Question.author_id == profile_user.id).count()
    return templates.TemplateResponse("profile.html", ctx)


@router.get("/field/{slug}", response_class=HTMLResponse)
def field_page(slug: str, request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    field = db.query(Field).filter(Field.slug == slug, Field.is_active == True).first()
    if not field:
        from fastapi.responses import HTMLResponse as HR
        return HR("<h1>Field not found</h1>", status_code=404)
    ctx = base_context(request, user, db)
    ctx["field"] = field
    return templates.TemplateResponse("field.html", ctx)


@router.get("/search", response_class=HTMLResponse)
def search_page(request: Request, user: User | None = Depends(get_current_user), db: Session = Depends(get_db)):
    return templates.TemplateResponse("search.html", base_context(request, user, db))