main.py

import jwt
import schedule
from time import sleep
from threading import Thread
from pony.orm import db_session, desc
from datetime import datetime, timedelta, timezone
from fastapi.middleware.cors import CORSMiddleware
from fastapi import FastAPI, HTTPException, Header, Query
from fastapi.responses import HTMLResponse, RedirectResponse

from modules.nocodb import NocoDB
from modules import settings, utils
from modules.database import PresenzaLab, TelemetryUser
from modules.models import TelemetryToken, EMQXAuthRequest, EMQXAuthResponse

app = FastAPI()
nocodb = NocoDB(
    base_url="https://nocodb.eagletrt.it",
    api_key=settings.NOCODB_API_TOKEN
)

# Fix CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["GET", "POST", "OPTIONS"],
    allow_headers=["*"]
)


@app.get("/lab/presenza", response_class=HTMLResponse, response_model=None)
async def lab_presenza(x_email: str=Header(default=None)):
    if not x_email:
        raise HTTPException(status_code=400, detail="Missing authentication")

    with db_session:
        presenze = PresenzaLab.select(lambda p: p.email == x_email)
        latest = presenze.order_by(desc(PresenzaLab.entrata)).first()
        today = presenze.filter(
            lambda p: p.entrata >= datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
        )

        ore = utils.timedelta_to_hours(latest.duration) if latest else 0
        ore_oggi = sum([utils.timedelta_to_hours(p.duration) for p in list(today)]) if latest else 0

        if latest and latest.isActive:
            return utils.orelab_uscita(ore, ore_oggi)
        else:
            return utils.orelab_entrata(ore_oggi)


@app.post("/lab/presenza/confirm", response_class=HTMLResponse, response_model=None)
async def lab_presenza_confirm(x_email: str=Header(default=None)):
    if not x_email:
        raise HTTPException(status_code=400, detail="Missing authentication")

    with db_session:
        latest = PresenzaLab.select(lambda p: p.email == x_email).order_by(desc(PresenzaLab.entrata)).first()
        if latest and latest.isActive:
            latest.uscita = datetime.now()
            utils.notify_exit(latest)
            return HTMLResponse(content="Uscita confermata.", status_code=200)
        else:
            latest = PresenzaLab(email=x_email, entrata=datetime.now())
            utils.notify_entry(latest)
            return HTMLResponse(content="Entrata confermata.", status_code=200)


@app.get("/lab/leaderboard")
async def lab_leaderboard(since: str="", until: str="", x_email: str=Header(default=None)) -> dict:
    if not x_email:
        raise HTTPException(status_code=400, detail="Missing authentication")

    now = datetime.now()
    if not since:
        since = now.strftime("%Y-%m-01") # default to the first day of the current month
    if not until:
        until = now.strftime("%Y-%m-%d") # default to today

    try:
        since_date = datetime.strptime(since, "%Y-%m-%d")
        until_date = datetime.strptime(until, "%Y-%m-%d")
    except ValueError:
        raise HTTPException(status_code=400, detail="Invalid date format(s). Use YYYY-MM-DD.")

    with db_session:
        presenze = PresenzaLab.select(lambda p: p.entrata >= since_date and p.entrata <= until_date + timedelta(days=1))
        leaderboard = {}
        for p in presenze:
            if p.email not in leaderboard:
                leaderboard[p.email] = 0
            leaderboard[p.email] += utils.timedelta_to_hours(p.duration)
        leaderboard = dict(sorted(leaderboard.items(), key=lambda i: i[1], reverse=True))

        return {
            "leaderboard": leaderboard,
            "since": since_date.strftime("%Y-%m-%d"),
            "until": until_date.strftime("%Y-%m-%d")
        }


@app.get("/forms/{form_type}/{form_uuid}")
async def forms(form_type: str, form_uuid: str, x_email: str=Header(default=None)) -> RedirectResponse:
    if not x_email:
        raise HTTPException(status_code=400, detail="Missing authentication")

    payload = {
        "email": x_email.replace("@eagletrt.it", "@studenti.unitn.it"),
        "type": form_type,
        "exp": datetime.now(timezone.utc) + timedelta(hours=4)
    }
    token = jwt.encode(payload, settings.JWT_SECRET_KEY, algorithm="HS256")
    redirect_url = f"{nocodb.base_url}/nc/form/{form_uuid}?form_jwt={token}"
    return RedirectResponse(url=redirect_url)


@app.get("/website/members")
async def website_members() -> dict:
    return {"members": nocodb.public_members()}


@app.get("/members")
async def members(x_email: str=Header(default=None)) -> dict:
    if not x_email:
        raise HTTPException(status_code=400, detail="Missing authentication")

    return {"members": nocodb.all_members()}


@app.get("/telemetry/login")
async def telemetry_login(x_email: str=Header(default=None), callback: str=Query(default=None)) -> dict:
    if not x_email:
        return {"success": False, "message": "Missing authentication"}

    with db_session:
        if not (user := TelemetryUser.get(email=x_email)):
            user = TelemetryUser(email=x_email)

        if not user.hasValidToken:
            user.generateToken()

        payload = {
            "success": True,
            "email": user.email,
            "role": user.role,
            "token": str(user.token),
            "expiry": int(user.expiry.timestamp())
        }

        return utils.telemetry_login_html(callback, payload) if callback else payload


@app.post("/telemetry/refresh")
async def telemetry_refresh(body: TelemetryToken) -> dict:
    with db_session:
        try:
            if not (user := TelemetryUser.get(token=body.token)):
                return {"success": False, "message": "Token not found"}
            if not user.hasValidToken:
                return {"success": False, "message": "Token expired"}
        except ValueError:
            return {"success": False, "message": "Invalid token"}

        user.refreshToken()
        return {
            "success": True,
            "expiry": int(user.expiry.timestamp())
        }


@app.post("/telemetry/whoami")
async def telemetry_whoami(body: TelemetryToken) -> dict:
    with db_session:
        try:
            if not (user := TelemetryUser.get(token=body.token)):
                return {"success": False, "message": "Token not found"}
            if not user.hasValidToken:
                return {"success": False, "message": "Token expired"}
        except ValueError:
            return {"success": False, "message": "Invalid token"}
        return {
            "success": True,
            "email": user.email,
            "role": user.role,
            "expiry": int(user.expiry.timestamp())
        }


@app.post("/emqx/auth")
async def emqx_auth(body: EMQXAuthRequest, Authorization: str=Header(default=None)) -> EMQXAuthResponse:
    def generate_acls_from_user_role(user_role: str) -> list[EMQXAuthResponse.AclItem]:
        if not isinstance(user_role, str):
            user_role = str(user_role)

        acls = []
        topics = utils.mqtt_topics_to_emqx(utils.MQTT_TOPICS)
        for topic in topics:
            acls.append(
                EMQXAuthResponse.AclItem(
                    permission=EMQXAuthResponse.Permission.ALLOW.value if user_role in topic["subscribe_roles"] else EMQXAuthResponse.Permission.DENY.value,
                    action=EMQXAuthResponse.Action.SUBSCRIBE.value,
                    topic=topic["topic"],
                    qos=[topic["qos"]]
                )
            )
            acls.append(
                EMQXAuthResponse.AclItem(
                    permission=EMQXAuthResponse.Permission.ALLOW.value if user_role in topic["publish_roles"] else EMQXAuthResponse.Permission.DENY.value,
                    action=EMQXAuthResponse.Action.PUBLISH.value,
                    topic=topic["topic"],
                    qos=[topic["qos"]]
                )
            )

        acls.append(
            EMQXAuthResponse.AclItem(
                permission=EMQXAuthResponse.Permission.ALLOW.value,
                action=EMQXAuthResponse.Action.SUBSCRIBE.value,
                topic="#",
                qos=[0, 1, 2]
            )
        )
        acls.append(
            EMQXAuthResponse.AclItem(
                permission=EMQXAuthResponse.Permission.ALLOW.value,
                action=EMQXAuthResponse.Action.PUBLISH.value,
                topic="#",
                qos=[0, 1, 2]
            )
        )
        return acls

    empty_response = EMQXAuthResponse(
        result=EMQXAuthResponse.Result.DENY,
        is_superuser=False,
        client_attrs=EMQXAuthResponse.ClientAttribute(role="unknown", sn=""),
        acl=[]
    )

    if Authorization != f"Bearer {settings.EMQX_BEARER_TOKEN}":
        return empty_response

    with db_session:
        try:
            if not (user := TelemetryUser.get(token=body.token)):
                return empty_response
            if not user.hasValidToken:
                return empty_response
        except ValueError:
            return empty_response

        acl_items = generate_acls_from_user_role(user.role)
        auth_response = EMQXAuthResponse(
            result=EMQXAuthResponse.Result.ALLOW,
            is_superuser=False,
            client_attrs=EMQXAuthResponse.ClientAttribute(role=str(user.role), sn=body.sub or ""),
            acl=acl_items
        )
        return auth_response


def deleteActivePresenze():
    with db_session:
        to_delete = PresenzaLab.select(lambda p: p.isActive)
        for p in to_delete:
            p.uscita = datetime.now()
            p.isValid = False
            p.note = "Closed due to inactivity"


def run_schedules():
    while True:
        schedule.run_pending()
        sleep(10)


if __name__ == "__main__":
    import uvicorn
    schedule.every().day.at("04:00").do(deleteActivePresenze)
    schedule.every(15).minutes.do(utils.update_mqtt_topics)
    Thread(target=run_schedules, daemon=True).start()
    utils.update_mqtt_topics()
    uvicorn.run(app, host=settings.API_HOST, port=settings.API_PORT, root_path=settings.API_PATH)