import math
import os
import shutil
from urllib.parse import quote
from datetime import date, datetime, timezone

import jwt
from fastapi import APIRouter, Request, Depends, Form, File, UploadFile, BackgroundTasks, HTTPException, status
from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
from sqlalchemy import or_
from sqlalchemy.orm import Session

import models
from security import EMELOGEP_SZEREPKOROK
from database import get_db
from config import SECRET_KEY, ALGORITHM
from security import (
    is_safe_extension, safe_json_for_script, sanitize_filename, get_current_user, get_working_company_id,
    is_company_allowed, is_company_active, is_machine_allowed, apply_user_data_scope_filter, require_modul,
    get_current_user_optional, napi_ellenorzes_aktiv_e,
    tartalom_illeszkedik_e_kiterjesztesre
)
from msz_logic import check_uzemora_drift_and_escalate
from email_utils import send_alert_email_task
import email_sor
import email_feliratkozas
from image_utils import kep_e, tomorit_kepet
from berles_utils import is_gep_allowed_berlo_szamara, ertesitesi_emailek_berlet_miatt
from templates_env import templates

router = APIRouter()


@router.get("/q/{uuid}")
def smart_qr_router(request: Request, uuid: str, db: Session = Depends(get_db)):
    """
    Ez az 'agy'. Ide fut be a QR kód leolvasása.
    Eldönti a jogosultság alapján, hogy hova irányítsa az embert.
    """
    gep = db.query(models.Machine).filter(models.Machine.uuid == uuid).first()
    if not gep:
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Érvénytelen vagy törölt QR kód!</h1>", status_code=404)

    # Finom (Soft) bejelentkezés ellenőrzés
    # 2FA 2. fázis (külső átnézés): a közös get_current_user_optional()-t használjuk - ugyanazok az ellenőrzések
    # (aktív/aktivált fiók, jelszóváltás utáni visszavonás, átmeneti token elutasítása, kötelező 2FA kikényszerítése),
    # nem egy külön, gyengébb token-dekódolás.
    user = get_current_user_optional(request, db)

    # Ha nincs bejelentkezve -> Publikus marketing adatlap
    if not user:
        return RedirectResponse(url=f"/publikus/{uuid}")

    # Ha be van jelentkezve, de ez nem a cége gépe (IDOR védelem) -> Publikus adatlap
    # JAVÍTVA (2026-09-24-i külső audit): a korábbi `user.role != "Admin"` minta bármely cég
    # Admin-ját átengedte más cégek gépeihez is (nem csak a valódi rendszeradminisztrátort) -
    # ugyanaz a hibaosztály, mint a 2026-09-10-i kritikus cég-izolációs hiba (l.
    # [[project_kritikus_ceg_izolacio_hiba_2026_09_10]]), csak ezen az egy, akkor kimaradt
    # végponton. A megosztott, már helyesen javított is_company_allowed()-ra cserélve.
    if not is_company_allowed(user, gep.company_id):
        return RedirectResponse(url=f"/publikus/{uuid}")

    # Ha Gépkezelő (Felhasználó) -> Napi Mobil Csekklista
    if user.role == "Felhasználó":
        return RedirectResponse(url=f"/mobil-csekklista/{uuid}")

    # Ha Emelőgép szakértő/vizsgáló -> dedikált mobil "QR Gépmenü" (vizsgálat indítás / csatolmányok / teljes napló)
    if user.role in ("Emelőgép szakértő", "Emelőgép vizsgáló"):
        return RedirectResponse(url=f"/qr-gepmenu/{uuid}")

    # Ha EÜI vagy Admin -> Egyből az Adatlap (Szerkesztő) nézet
    return RedirectResponse(url=f"/szerkesztes/{gep.uuid}")


# --- ALTERNATÍV GÉPAZONOSÍTÁS (gyári szám / leltári szám begépelésével) ---
# Olyan telephelyeken hasznos, ahol a telefon kamerája (és így a QR-kód beolvasása) nem használható.

@router.get("/gep-kereses", response_class=HTMLResponse)
def gep_kereses_oldal(
    request: Request,
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    return templates.TemplateResponse(
        request=request,
        name="gep-kereses.html",
        context={"user": current_user, "hiba": "", "talalatok": None}
    )


@router.get("/gep-kereses-eredmeny", response_class=HTMLResponse)
def gep_kereses_eredmeny(
    request: Request,
    azonosito: str = "",
    db: Session = Depends(get_db),
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    working_company_id = get_working_company_id(current_user, request)
    tiszta_azonosito = azonosito.strip()

    if not tiszta_azonosito:
        return templates.TemplateResponse(
            request=request,
            name="gep-kereses.html",
            context={"user": current_user, "hiba": "Kérlek adj meg egy gyári vagy leltári számot!", "talalatok": None}
        )

    query = db.query(models.Machine).filter(
        models.Machine.company_id == working_company_id,
        models.Machine.statusz.notin_(["Végleg kivonva/Selejtezve", "Eladva", "Bérleti idő lejárt / Visszaadva"]),
        or_(models.Machine.gyari_szam == tiszta_azonosito, models.Machine.leltari_szam == tiszta_azonosito)
    )
    query = apply_user_data_scope_filter(query, current_user)
    talalatok = query.all()

    if len(talalatok) == 0:
        return templates.TemplateResponse(
            request=request,
            name="gep-kereses.html",
            context={
                "user": current_user,
                "hiba": f"Nem található gép '{tiszta_azonosito}' gyári vagy leltári számmal.",
                "talalatok": None
            }
        )

    if len(talalatok) == 1:
        return RedirectResponse(url=f"/q/{talalatok[0].uuid}", status_code=status.HTTP_303_SEE_OTHER)

    return templates.TemplateResponse(
        request=request,
        name="gep-kereses.html",
        context={"user": current_user, "hiba": "", "talalatok": talalatok, "kereset_azonosito": tiszta_azonosito}
    )


@router.get("/qr-gepmenu/{uuid}", response_class=HTMLResponse)
def qr_gepmenu(
    request: Request,
    uuid: str,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    """Dedikált mobil menü Emelőgép szakértőknek/vizsgálóknak QR-kód beolvasása után."""
    gep = db.query(models.Machine).filter(models.Machine.uuid == uuid).first()
    if not gep:
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Érvénytelen vagy törölt QR kód!</h1>", status_code=404)

    if not is_company_allowed(current_user, gep.company_id):
        return RedirectResponse(url=f"/publikus/{uuid}")

    return templates.TemplateResponse(
        request=request,
        name="qr-gepmenu.html",
        context={"gep": gep, "user": current_user}
    )


@router.get("/publikus/{uuid}", response_class=HTMLResponse)
def publikus_adatlap(request: Request, uuid: str, db: Session = Depends(get_db)):
    """
    A 'Csak olvasható', elegáns adatlap a külsősöknek.
    """
    gep = db.query(models.Machine).filter(models.Machine.uuid == uuid).first()
    if not gep:
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Érvénytelen QR kód!</h1>", status_code=404)

    return templates.TemplateResponse(
        request=request,
        name="publikus.html",
        context={"gep": gep, "host_url": str(request.base_url)}
    )


# --- IPAR 4.0: GÉPKEZELŐI MOBIL CSEKKLISTA ÉS MENTÉS ---

def napi_ellenorzes_tiltas_url(gep, db):
    """J-14 (v75): None, ha a gépen / a cégben végezhető napi ellenőrzés; különben a /lista átirányítási címe (a "napi_tiltas"
    paramétert a list.html sávja jeleníti meg). Az ok: (1) a gép nem "Aktív" státuszú - egy selejtezett / eladott / kivont
    gépen a napi ellenőrzés nem rögzíthető (különben egy LETILTÁS-válasz felülírná a végleges státuszt, a hibajegy-feloldás
    pedig újra Aktívvá tehetné); (2) a gép cége kikapcsolta a napi ellenőrzést. Átirányítás (nem 4xx), mert a mobil oldal
    JS-e a nem-OK választ offline mentésnek venné."""
    if gep.statusz != "Aktív":
        return f"/lista?napi_tiltas=statusz&napi_gep={quote(gep.megnevezes or gep.gyari_szam or str(gep.id))}&napi_statusz={quote(gep.statusz or '-')}"
    if not napi_ellenorzes_aktiv_e(gep.company_id, db):
        return "/lista?napi_tiltas=kikapcsolva"
    return None


@router.get("/mobil-csekklista/{uuid}", response_class=HTMLResponse)
def mobil_csekklista(
    request: Request,
    uuid: str,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    gep = db.query(models.Machine).filter(models.Machine.uuid == uuid).first()
    if not gep:
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Érvénytelen QR kód!</h1>", status_code=404)

    # J-25 (v76): pozitív szerepkör-lista (Admin, ügyintéző, szakértő, vizsgáló, gépkezelő)
    if current_user.role not in EMELOGEP_SZEREPKOROK:
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Nincs jogosultságod ehhez a művelethez!</h1>", status_code=403)

    # KÖZEPES (2026-10-03-i külső biztonsági audit, 2. kör): korábban csak is_company_allowed()
    # futott, ami egy TELEPHELY-re korlátozott felhasználónak is engedte a cégnél BÁRMELYIK
    # (más telephelyi) gép QR-kódját beolvasni - is_machine_allowed() ugyanazt a cég-ellenőrzést
    # elvégzi, PLUSZ a telephely-/gép-szintű korlátozást is.
    if not is_machine_allowed(gep, current_user) and not is_gep_allowed_berlo_szamara(gep, current_user, db):
        return HTMLResponse("<h1 style='text-align:center; margin-top:50px;'>Nincs jogosultságod ehhez a géphez!</h1>", status_code=403)

    # J-14 (v75): nem Aktív gépen / kikapcsolt napi ellenőrzésnél a csekklista sem nyílik meg
    tiltas_url = napi_ellenorzes_tiltas_url(gep, db)
    if tiltas_url:
        return RedirectResponse(url=tiltas_url)

    # FONTOS: itt SZÁNDÉKOSAN a teljes céges kérdéslista kerül lekérdezésre (geptipus_lista taggel
    # együtt), NEM géptípusra szűrve - a gép-géptípus szerinti szűrés a kliens oldali JS-ben történik
    # (lásd mobil-csekklista.html formKirajzolasa()), mert ugyanez a lista kerül az IndexedDB
    # gyorsítótárba `elmentGepetHelyi()`-vel, közös 'kerdesek_<company_id>' kulcs alatt - ha itt már
    # csak erre az egy gépre szűrt listát mentenénk el, az felülírná (leszűkítené) a gyorsítótárat
    # minden MÁS géptípusú gép offline ellenőrzéséhez is.
    kerdesek = db.query(models.DailyCheckQuestion).filter(
        models.DailyCheckQuestion.company_id == gep.company_id
    ).all()

    # A gépkezelő számára elérhetővé tett kezelési/használati utasítás - ha van ilyen fájl
    # feltöltve a géphez, a napi ellenőrzés oldalon egy letöltés gomb jelenik meg hozzá.
    hasznalati_utasitas_fajlok = [f for f in gep.fajlok if f.file_type == "Használati utasítás"]
    hasznalati_utasitas_url = (
        max(hasznalati_utasitas_fajlok, key=lambda f: f.uploaded_at).file_path
        if hasznalati_utasitas_fajlok else None
    )

    # A gép és kérdés adatok JSON-ban is átadásra kerülnek: ez teszi lehetővé, hogy ugyanez az oldal
    # a Service Worker által kiszolgált, gép-független "héj" formájában (offline mód) is működjön -
    # ilyenkor a kliens JS ugyanezt az adatszerkezetet a helyi IndexedDB gyorsítótárból olvassa vissza.
    szerver_adat = {
        "gep": {
            "uuid": gep.uuid,
            "megnevezes": gep.megnevezes,
            "gyari_szam": gep.gyari_szam,
            "uzemora": gep.uzemora,
            "company_id": gep.company_id,
            "geptipus": gep.geptipus,
            "hasznalati_utasitas_url": hasznalati_utasitas_url,
        },
        "kerdesek": [
            {"id": k.id, "szoveg": k.szoveg, "kovetkezmeny": k.kovetkezmeny, "geptipus_lista": k.geptipus_lista}
            for k in kerdesek
        ],
    }

    return templates.TemplateResponse(
        request=request,
        name="mobil-csekklista.html",
        context={
            "gep": gep,
            "kerdesek": kerdesek,
            "user": current_user,
            "szerver_adat_json": safe_json_for_script(szerver_adat),
        }
    )


@router.post("/napi-ellenorzes-mentes")
async def napi_ellenorzes_mentes(
    request: Request,
    background_tasks: BackgroundTasks,
    machine_uuid: str = Form(...),
    uzemora: float = Form(...),
    megjegyzes: str = Form(""),
    fenykep: UploadFile = File(None),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    # J-25 (v76): pozitív szerepkör-lista (Admin, ügyintéző, szakértő, vizsgáló, gépkezelő)
    if current_user.role not in EMELOGEP_SZEREPKOROK:
        return RedirectResponse(url="/lista")

    gep = db.query(models.Machine).filter(models.Machine.uuid == machine_uuid).first()
    if not gep:
        return RedirectResponse(url="/lista")

    # KÖZEPES (2026-10-03-i külső biztonsági audit, 2. kör) - l. mobil_csekklista() fenti
    # megjegyzését: is_machine_allowed() a telephely-/gép-szintű korlátozást is érvényesíti.
    if not is_machine_allowed(gep, current_user) and not is_gep_allowed_berlo_szamara(gep, current_user, db):
        return RedirectResponse(url="/lista")

    if not is_company_active(gep.company_id, db):
        return RedirectResponse(url="/lista?inaktiv_ceg=1")

    if current_user.csak_olvasas:
        return RedirectResponse(url="/lista?csak_olvasas=1")

    # J-14 (v75): csak Aktív státuszú gépen és bekapcsolt napi ellenőrzésű cégben rögzíthető (semmi sem mentődik)
    tiltas_url = napi_ellenorzes_tiltas_url(gep, db)
    if tiltas_url:
        return RedirectResponse(url=tiltas_url)

    # J-14 (v75): az üzemóra véges, nemnegatív szám (a float a "nan"/"inf" szöveget is elfogadja)
    if not math.isfinite(uzemora) or uzemora < 0:
        return RedirectResponse(url="/lista?napi_tiltas=uzemora")

    # 1. Üzemóra frissítése
    regi_uzemora = gep.uzemora
    gep.uzemora = uzemora

    # Ha a tényleges használat jelentősen meghaladja a tervezett napi átlagot,
    # a rendszer automatikusan szigorítja a besorolást és értesít.
    check_uzemora_drift_and_escalate(gep, db, background_tasks)

    # 2. Kérdések kiértékelése
    form_data = await request.form()
    hiba_talalva = False
    sulyossag = "NINCS"
    hibas_kerdesek = []

    # Csak a gép géptípusához illeszkedő napi kérdések - ha egy kérdésnél a geptipus_lista üres/
    # hiányzik, az minden géptípusnál megjelenik (visszamenőleg minden meglévő kérdésre igaz).
    kerdesek = [
        k for k in db.query(models.DailyCheckQuestion).filter(
            models.DailyCheckQuestion.company_id == gep.company_id
        ).all()
        if not k.geptipus_lista or gep.geptipus in [g.strip() for g in k.geptipus_lista.split(",")]
    ]

    for k in kerdesek:
        valasz = form_data.get(f"kerdes_{k.id}")
        if valasz == "NEM":
            hiba_talalva = True
            hibas_kerdesek.append(k.szoveg)
            if k.kovetkezmeny == "LETILTAS":
                sulyossag = "LETILTAS"
            elif sulyossag != "LETILTAS":
                sulyossag = "FIGYELMEZTETES"

    # 3. Fénykép (Bizonyíték) mentése
    fenykep_path = None
    if fenykep and getattr(fenykep, "filename", "") != "":
        if not is_safe_extension(fenykep.filename):
            return RedirectResponse(url="/lista?hiba=fajlformatum")

        mappa = f"uploads/{gep.company_id}/{gep.id}/napi_kepek"
        os.makedirs(mappa, exist_ok=True)
        safe_filename = sanitize_filename(fenykep.filename)
        kep_bytes = tomorit_kepet(await fenykep.read())
        if kep_bytes is None:
            return RedirectResponse(url="/lista?hiba=fajlformatum")
        safe_filename = safe_filename.rsplit(".", 1)[0] + ".jpg"
        file_loc = f"{mappa}/{date.today().strftime('%Y%m%d')}_{safe_filename}"
        with open(file_loc, "wb+") as f:
            f.write(kep_bytes)
        fenykep_path = "/" + file_loc

        # A fotó bekerül a gép hivatalos Csatolmányai közé is
        napi_fajl = models.File(
            machine_id=gep.id,
            file_path=fenykep_path,
            file_type="Napi ellenőrzés fotó"
        )
        db.add(napi_fajl)

    # 4. Hibajegy (Ticket) és Letiltás generálása
    if hiba_talalva or megjegyzes or fenykep_path:
        hiba_leiras = ""
        if hiba_talalva:
            hiba_leiras += "Hiba a csekklistánál: " + "; ".join(hibas_kerdesek) + ".\n"
        if megjegyzes:
            hiba_leiras += f"Kezelői megjegyzés: {megjegyzes}"

        ticket = models.MaintenanceTicket(
            machine_id=gep.id,
            bejelento_nev=current_user.username,
            hiba_leirasa=hiba_leiras,
            fenykep_path=fenykep_path,
            sulyossag=sulyossag,
            statusz="Nyitott"
        )
        db.add(ticket)

        if sulyossag == "LETILTAS":
            gep.letiltva_napi_hiba_miatt = True
            gep.statusz = "Kivonva (javításra vár)"
            gep.statusz_oka = "Napi ellenőrzés során automatikusan letiltva!"

        # C szelet: a címzetteket a céges szabály + a felhasználói feliratkozás adja (gep_riasztas kategória).
        cimek = email_feliratkozas.cimzettek(db, gep.company_id, "gep_riasztas")
        # Ha a gép aktív bérlet alatt áll, a bérlő cég "berlet" kategóriát kapó felhasználói is értesüljenek -
        # függetlenül attól, hogy "ki hívja a szerelőt" beállítás melyik felet jelöli.
        cimek = list(dict.fromkeys(cimek + ertesitesi_emailek_berlet_miatt(gep, db)))

        if cimek:
            gep_ad = {
                "nev": gep.megnevezes or 'Ismeretlen gép',
                "gyari_szam": gep.gyari_szam or '-',
                "tipus": gep.tipus or '-',
                "gep_id": gep.id,
                "company_id": gep.company_id
            }
            background_tasks.add_task(
                send_alert_email_task,
                cimek, gep_ad, hiba_leiras, sulyossag == "LETILTAS", current_user.username
            )

    # 5. Gépnapló bejegyzés (Részletes hiba és fotó jelzéssel)
    hibak_szovege = " | Hibák: " + ", ".join(hibas_kerdesek) if hiba_talalva else ""
    foto_szovege = " (Fotó csatolva az adatlaphoz!)" if fenykep_path else ""

    log = models.AuditLog(
        machine_id=gep.id,
        user_id=current_user.id,
        field_name="Napi Gépnapló",
        old_value=f"Előző üzemóra: {regi_uzemora} h",
        new_value=f"Új: {uzemora} h | Állapot: {'LETILTVA' if sulyossag == 'LETILTAS' else 'FIGYELMEZTETÉS' if hiba_talalva else 'RENDBEN'}{hibak_szovege}{foto_szovege}"
    )
    db.add(log)
    db.commit()

    return RedirectResponse(url=f"/mobil-siker/{gep.uuid}?status={sulyossag}", status_code=status.HTTP_303_SEE_OTHER)


@router.get("/mobil-siker/{uuid}", response_class=HTMLResponse)
def mobil_siker(request: Request, uuid: str, status: str = "NINCS", db: Session = Depends(get_db)):
    gep = db.query(models.Machine).filter(models.Machine.uuid == uuid).first()
    return templates.TemplateResponse(
        request=request,
        name="mobil-siker.html",
        context={"gep": gep, "status": status}
    )


@router.post("/ticket-feloldas")
async def ticket_feloldas(
    request: Request,
    ticket_id: int = Form(...),
    javitas_indoklas: str = Form(...),
    munkalap_file: UploadFile = File(None),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(require_modul("EMELOGEP"))
):
    if current_user.role not in ["Admin", "Emelőgép ügyintéző"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod a gép feloldására!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return JSONResponse(status_code=403, content={"message": "Ez a cég inaktív státuszú, hibajegy nem oldható fel!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})

    ticket = db.query(models.MaintenanceTicket).filter(models.MaintenanceTicket.id == ticket_id).first()
    if not ticket or ticket.machine.company_id != working_company_id:
        return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)

    gep = ticket.machine

    # J-14 (v75): a telephely-/gép-szintű korlátozás a feloldásra is vonatkozik (J-02 után az ügyintézőre is)
    if not is_machine_allowed(gep, current_user):
        return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)

    # J-14 (v75): a már lezárt hibajegy nem oldható fel újra (a lezáró, az indoklás és a munkalap véglegesen rögzül)
    if ticket.statusz == "Lezárva":
        return JSONResponse(status_code=409, content={"message": "Ez a hibajegy már le van zárva, újra nem oldható fel!"})

    # Javítási munkalap (PDF/Kép) mentése, ha töltöttek fel
    munkalap_path = None
    if munkalap_file and munkalap_file.filename:
        # >>> ÚJ BIZTONSÁGI ELLENŐRZÉS <<<
        if not is_safe_extension(munkalap_file.filename):
            raise HTTPException(status_code=400, detail="Nem engedélyezett fájlformátum!")
        mappa = f"uploads/{working_company_id}/{gep.id}/munkalapok"
        os.makedirs(mappa, exist_ok=True)
        safe_filename = sanitize_filename(munkalap_file.filename)

        if kep_e(munkalap_file.filename):
            kep_bytes = tomorit_kepet(await munkalap_file.read())
            if kep_bytes is None:
                raise HTTPException(status_code=400, detail="A feltöltött fájl nem érvényes kép!")
            safe_filename = safe_filename.rsplit(".", 1)[0] + ".jpg"
            file_loc = f"{mappa}/{date.today().strftime('%Y%m%d')}_{safe_filename}"
            with open(file_loc, "wb+") as f:
                f.write(kep_bytes)
        else:
            fejresz = munkalap_file.file.read(8)
            munkalap_file.file.seek(0)
            if not tartalom_illeszkedik_e_kiterjesztesre(munkalap_file.filename, fejresz):
                raise HTTPException(status_code=400, detail="A feltöltött fájl tartalma nem egyezik a kiterjesztésével!")
            file_loc = f"{mappa}/{date.today().strftime('%Y%m%d')}_{safe_filename}"
            with open(file_loc, "wb+") as f:
                shutil.copyfileobj(munkalap_file.file, f)

        munkalap_path = "/" + file_loc

    # Ticket lezárása
    ticket.statusz = "Lezárva"
    # A hiba megoldódott: ha később újra előfordul, az ismét "új hiba" legyen, és azonnal menjen
    # levél (az ismétlődő riasztások 7 napos szűrése a lezárással nullázódik - l. email_sor.py).
    email_sor.riasztas_allapot_torlese(db, gep.id)
    ticket.lezaras_datum = datetime.now(timezone.utc)
    ticket.lezaro_user = current_user.username
    ticket.javitas_indoklas = javitas_indoklas
    ticket.munkalap_path = munkalap_path

    # A munkalap a gép hivatalos Csatolmányai közé is bekerül
    if munkalap_path:
        munkalap_fajl = models.File(
            machine_id=gep.id,
            file_path=munkalap_path,
            file_type="Javítási munkalap"
        )
        db.add(munkalap_fajl)

    # Gép feloldása és visszarakása "Aktív" státuszba
    # J-14 (v75): (1) csak akkor, ha nincs más nyitott LETILTÁS-jegy a gépen; (2) csak a "Kivonva (javításra vár)" státuszból
    # lép Aktívba - ha a gép közben végleges státuszt kapott (selejtezve, eladva, átszállítva...), a jelző törlődik, de a
    # státusz érintetlen marad (korábban a feloldás minden státuszt felülírt: selejtezett gép "feltámadhatott").
    if gep.letiltva_napi_hiba_miatt:
        van_mas_nyitott_letiltas = db.query(models.MaintenanceTicket).filter(
            models.MaintenanceTicket.machine_id == gep.id,
            models.MaintenanceTicket.id != ticket.id,
            models.MaintenanceTicket.statusz != "Lezárva",
            models.MaintenanceTicket.sulyossag == "LETILTAS",
        ).count() > 0
        if not van_mas_nyitott_letiltas:
            gep.letiltva_napi_hiba_miatt = False
            if gep.statusz == "Kivonva (javításra vár)":
                gep.statusz = "Aktív"
                gep.statusz_oka = f"Karbantartás elvégezve, gép feloldva."

    # Naplózás
    log = models.AuditLog(
        machine_id=gep.id,
        user_id=current_user.id,
        field_name="KARBANTARTÁS / FELOLDÁS",
        old_value=f"Hibajegy: {ticket.sulyossag}",
        new_value=f"Megoldva. Indoklás: {javitas_indoklas}"
    )
    db.add(log)
    db.commit()

    return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)