import json
from datetime import datetime, time

from fastapi import APIRouter, Request, Depends, Form, status
from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
from sqlalchemy.orm import Session

import email_feliratkozas as ef
import models
import szabadsag_utils
from database import get_db
from security import (
    get_current_user, get_working_company_id, get_allowed_companies_list, is_company_active,
    sugo_engedelyezve, is_rendszeradminisztrator, require_modul
)
from msz_logic import get_uzemora_beallitasok, get_vizsgalati_datum_kotelezo_mod
from licenc_utils import felhasznalo_letszam
from naplo_utils import naploz, be_ki
from templates_env import templates

router = APIRouter()

# J-26 (v76): a tisztán EMELŐGÉP-specifikus beállítás-író route-ok (gép-konfig, rendelet-szigorítás, üzemóra-eltérés, vizsgálati dátum,
# vizsgálat e-mail, napi ellenőrzés kapcsoló / kérdések / sablonok, jegyzőkönyv-sablonok, dashboard-kapcsolók) az EMELOGEP modulhoz
# kötöttek - a saját cég ÉS a kiválasztott munkakörnyezet cégének is elő kell fizetnie rá (security.require_modul, J-15). A /beallitasok
# közös oldal, a telephely- / szótár- / e-mail riport route-ok és az /ertesitesek SZÁNDÉKOSAN nyitottak maradnak: az összes modul
# (EBK, VIVÜ, Tűzvédelem) Admin-jai itt kezelik a felhasználóikat és az értesítéseiket.
EMELOGEP_MODUL_KAPU = [Depends(require_modul("EMELOGEP"))]


# J-20 (v77): MINDEN beállítás-író route naplózza a változást (AuditLog, mező: "Beállítás - <tárgy>"), a módosítással EGY tranzakcióban
# (a `naploz` nem commitol). A Beállítások "Jogosultsági napló" füle (company_id = munkakörnyezet) és a Rendszernapló ("Cég / rendszer"
# kategória, a "Beállítás" előtag) is ezeket mutatja. A változatlan újra-mentés (azonos régi / új érték) nem hoz létre sort.
def _dict_ertek(db: Session, company_id: int, kategoria: str):
    """Egy Dictionary-alapú beállítás jelenlegi értéke (None = nincs sor) - a naplózáshoz a MÓDOSÍTÁS ELŐTT kell lekérni."""
    sor = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == company_id, models.Dictionary.kategoria == kategoria
    ).first()
    return sor.ertek if sor else None


def _kapcsolo_szoveg(ertek) -> str:
    """A True/False Dictionary-kapcsoló érthető szövege a naplóhoz (nincs sor = az alapértelmezés még él)."""
    if ertek is None:
        return "(alapértelmezett)"
    return be_ki(ertek == "True")


def _sablon_nev(ertek) -> str:
    """A JSON-ban tárolt sablon neve (hibás JSON esetén '?') - a törlés naplójához."""
    try:
        return str((json.loads(ertek) or {}).get("nev") or "?")
    except (json.JSONDecodeError, TypeError, AttributeError):
        return "?"


def _konfig_szoveg(k) -> str:
    return (f"kötelező: {k.kotelezo_mezok or '-'}; rejtett: {k.rejtett_mezok or '-'}; egyedi: "
            f"{k.egyedi_1_nev or '-'}/{k.egyedi_2_nev or '-'}/{k.egyedi_3_nev or '-'}; "
            f"MSZ 16226: {'igen' if k.msz16226_szukseges else 'nem'}; kezelői munkahely: {'igen' if k.kezeloi_munkahely_szukseges else 'nem'}")


# A Beállítások "E-mail riportok" és "Jelszó-házirend" fülének egyszeri visszajelzései (a `uzenet` / `hiba` lekérdezési paraméter ELŐRE ISMERT kódja; szabad szöveg nem
# jelenik meg, így nem lehet az URL-lel szöveget beszúrni). A sikeres mentés után a POST végpontok ide irányítanak vissza (docs/BEALLITASOK_FULEK.md).
FLASH_OK = {
    "ertesitesek_mentve": "Az értesítési beállításaid mentve.",
    "szabadsag_be": "A szabadságod bekapcsolva: a következő időszakban nem küldünk neked e-mailt (a fiókodat védő biztonsági értesítők kivételével). A visszatéréskor egy összegző levelet kapsz.",
    "szabadsag_datum": "A visszatérés napja módosítva.",
    "szabadsag_nincs_valtozas": "Nem változott semmi.",
    "jelszo_hazirend_mentve": "A jelszó-házirend mentve.",
}
FLASH_HIBA = {
    "szabadsag_datum_formatum": "Érvénytelen dátum.",
    "szabadsag_datum_multban": "A visszatérés napja a jövőben legyen (legkorábban holnap).",
    "szabadsag_datum_tavoli": f"A visszatérés napja legfeljebb {szabadsag_utils.MAX_NAP} nappal lehet a jövőben.",
    "mentes_sikertelen": "A mentés nem sikerült, próbáld újra.",
}


@router.get("/beallitasok", response_class=HTMLResponse)
def beallitasok_oldal(
    request: Request,
    naplo_tol: str = "",
    naplo_ig: str = "",
    uzenet: str = "",
    hiba: str = "",
    n: int = 0,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return RedirectResponse(url="/lista")
    return beallitasok_valasz(request, db, current_user, naplo_tol=naplo_tol, naplo_ig=naplo_ig, uzenet=uzenet, hiba=hiba, n=n)


def beallitasok_valasz(request: Request, db: Session, current_user: models.User, naplo_tol: str = "", naplo_ig: str = "",
                       uzenet: str = "", hiba: str = "", n: int = 0, jh_kontextus: dict = None, status_code: int = 200):
    """A Beállítások oldal. `uzenet` / `hiba`: a FLASH_OK / FLASH_HIBA előre ismert kódja (egyszeri visszajelzés az e-mail fülön); `n`: a darabszám a szabadság végi
    üzenethez / a házirend által érintett felhasználók száma. `jh_kontextus`: a jelszó-házirend űrlap állapota, ha a routers/jelszo_hazirend.py hibával / előnézettel
    (nem mentett értékekkel) rajzoltatja újra az oldalt; egyébként a tárolt házirend."""
    working_company_id = get_working_company_id(current_user, request)

    ceges_felhasznalok = db.query(models.User).filter(
        models.User.company_id == working_company_id,
        models.User.role.in_(["Felhasználó", "Emelőgép ügyintéző"])
    ).all()

    telephelyek = db.query(models.Site).filter(
        models.Site.company_id == working_company_id
    ).all()

    gyartok = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "Gyarto"
    ).all()

    tipusok = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "Tipus"
    ).all()

    gepek = db.query(models.Machine).filter(
        models.Machine.company_id == working_company_id,
        models.Machine.statusz == "Aktív"
    ).all()

    configs = db.query(models.MachineTypeConfig).filter(
        models.MachineTypeConfig.company_id == working_company_id
    ).all()

    szigor_ki = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "RendeletSzigoritasKikapcsolva"
    ).first()

    cegek = get_allowed_companies_list(current_user, db, "EMELOGEP")

    napi_kerdesek = db.query(models.DailyCheckQuestion).filter(
        models.DailyCheckQuestion.company_id == working_company_id
    ).all()

    napi_aktiv_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "NapiEllenorzesAktiv"
    ).first()

    # >>> ÚJ LEKÉRDEZÉS E-MAIL GYAKORISÁG<<<
    riport_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "EmailRiportGyakorisag"
    ).first()
    riport_gyakorisag = riport_obj.ertek if riport_obj else "Kikapcsolva"

    uzemora_eltertes_mod, uzemora_atlag_napok = get_uzemora_beallitasok(working_company_id, db)

    vizsgalati_datum_kotelezo_mod = get_vizsgalati_datum_kotelezo_mod(working_company_id, db)

    # >>> ÚJ: vizsgálat/dokumentum sikertelen minősítése esetén küldött e-mail be/kikapcsolása <<<
    vizsgalat_email_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "VizsgalatSikertelenEmailErtesites"
    ).first()
    vizsgalat_email_ertesites = (vizsgalat_email_obj.ertek == "True") if vizsgalat_email_obj else True

    # --- Ellenőrzőlista sablonok kezelése (létrehozás/törlés) - kizárólag a valódi
    # rendszeradmin joga (nem a cég saját Admin-ja) ---
    # Ugyanaz a "ha a cégnél nincs saját, az 1-es (alap) cég sablonjait mutatjuk" tartalék-logika,
    # mint a vizsgálati űrlapon (routers/inspections.py) és a napi sablonoknál lejjebb - enélkül a
    # cég itt üresnek látná a listát, miközben a vizsgálati űrlapon mégis megjelennek a sablonok.
    is_rendszeradmin = is_rendszeradminisztrator(current_user)
    jegyzokonyv_sablonok = []
    if is_rendszeradmin:
        sablon_sorok = db.query(models.Dictionary).filter(
            models.Dictionary.company_id == working_company_id,
            models.Dictionary.kategoria == "JegyzokonyvSablon"
        ).all()
        if not sablon_sorok:
            sablon_sorok = db.query(models.Dictionary).filter(
                models.Dictionary.company_id == 1,
                models.Dictionary.kategoria == "JegyzokonyvSablon"
            ).all()
        for s in sablon_sorok:
            try:
                adat = json.loads(s.ertek)
                jegyzokonyv_sablonok.append({
                    "id": s.id,
                    "nev": adat.get("nev", "Névtelen sablon"),
                    "kerdes_szam": len(adat.get("kerdesek", []))
                })
            except (json.JSONDecodeError, TypeError):
                continue

    # --- ÚJ: Napi ellenőrzés sablonok (géptípusonkénti kérdéscsomagok tömeges alkalmazásához) ---
    # Ugyanaz a "ha a cégnél nincs saját, az 1-es (alap) cég sablonjait mutatjuk" tartalék-logika,
    # mint a vizsgálati sablonoknál (routers/inspections.py) - a napi sablon is egy megosztott,
    # bármely cég által "Alkalmazás"-sal átvehető alap-készlet, nem cégenként egyedi tartalom.
    napi_sablonok = []
    if is_rendszeradmin:
        napi_sablon_sorok = db.query(models.Dictionary).filter(
            models.Dictionary.company_id == working_company_id,
            models.Dictionary.kategoria == "NapiEllenorzesSablon"
        ).all()
        if not napi_sablon_sorok:
            napi_sablon_sorok = db.query(models.Dictionary).filter(
                models.Dictionary.company_id == 1,
                models.Dictionary.kategoria == "NapiEllenorzesSablon"
            ).all()
        for s in napi_sablon_sorok:
            try:
                adat = json.loads(s.ertek)
                napi_sablonok.append({
                    "id": s.id,
                    "nev": adat.get("nev", "Névtelen sablon"),
                    "kerdes_szam": len(adat.get("kerdesek", []))
                })
            except (json.JSONDecodeError, TypeError):
                continue

    # A napló hosszú távon (évek alatt) egyre nagyobbra nő, ezért dátum szerint szűrhető -
    # a .limit(200) biztonsági korlát így is megmarad, de a szűréssel a régebbi bejegyzések is elérhetők.
    jogosultsagi_naplo = []
    if current_user.role in ["Admin"]:
        naplo_query = db.query(models.AuditLog).filter(
            models.AuditLog.company_id == working_company_id
        )
        if naplo_tol:
            try:
                naplo_tol_datum = datetime.strptime(naplo_tol, "%Y-%m-%d").date()
                naplo_query = naplo_query.filter(models.AuditLog.timestamp >= datetime.combine(naplo_tol_datum, time.min))
            except ValueError:
                pass
        if naplo_ig:
            try:
                naplo_ig_datum = datetime.strptime(naplo_ig, "%Y-%m-%d").date()
                naplo_query = naplo_query.filter(models.AuditLog.timestamp <= datetime.combine(naplo_ig_datum, time.max))
            except ValueError:
                pass
        jogosultsagi_naplo = naplo_query.order_by(models.AuditLog.timestamp.desc()).limit(200).all()

    # --- ÚJ: Dashboard widgetek beállításai ---
    naptar_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "DashboardNaptarAktiv"
    ).first()
    dashboard_naptar_aktiv = (naptar_obj.ertek == "True") if naptar_obj else True

    diagramok_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "DashboardDiagramokAktiv"
    ).first()
    dashboard_diagramok_aktiv = (diagramok_obj.ertek == "True") if diagramok_obj else True

    diagram_tipusok_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "DashboardDiagramTipusok"
    ).first()
    if diagram_tipusok_obj:
        dashboard_valasztott_diagramok = [t.strip() for t in diagram_tipusok_obj.ertek.split(",") if t.strip()]
    else:
        dashboard_valasztott_diagramok = ["statusz", "gyarto", "geptipus", "kor"]

    ceg = db.query(models.Company).filter(models.Company.id == working_company_id).first()
    licenc_letszamok = {
        "dolgozo": (felhasznalo_letszam(working_company_id, "Felhasználó", db), ceg.licenc_max_dolgozo if ceg else None),
        "ugyintezo": (felhasznalo_letszam(working_company_id, "Emelőgép ügyintéző", db), ceg.licenc_max_ugyintezo if ceg else None),
    }

    # --- v41: "E-mail riportok" fül: az ADOTT (bejelentkezett) felhasználó saját levelezési beállításai (Értesítéseim + Szabadságon vagyok) ---
    allapotok = ef.felhasznaloi_allapot(db, current_user)
    flash_ok = FLASH_OK.get(uzenet) if uzenet != "jelszo_hazirend_mentve" else None      # a házirend mentését a Jelszó-házirend fül saját sávja jelzi
    if uzenet == "szabadsag_ki":
        flash_ok = ("A szabadságod véget ért, jó munkát! " + (f"A szabadságod alatt kimaradt {n} levélről összegző levelet küldtünk (hamarosan megérkezik)."
                                                           if n else "A szabadságod alatt nem maradt ki levél."))
    # --- v41: "Jelszó-házirend" fül: a cég házirendje (ugyanaz az űrlap, mint a /jelszo-hazirend oldalon) ---
    if jh_kontextus is None:
        from routers import jelszo_hazirend as jelszo_router     # késői import: a jelszo_hazirend router a settings-et is használja (körkörös import ellen)
        jh_kontextus = jelszo_router.kontextus(request, db, current_user, mentve=1 if uzenet == "jelszo_hazirend_mentve" else None,
                                               n=n if (uzenet == "jelszo_hazirend_mentve" and n) else None, vissza_beallitasok=True)

    return templates.TemplateResponse(
        request=request,
        name="beallitasok.html",
        status_code=status_code,
        context={
            "user": current_user,
            "allapotok": allapotok,
            "van_lathato": any(a["lathato"] for a in allapotok),
            "szabadsag": szabadsag_utils.allapot(db, current_user),
            "flash_ok": flash_ok,
            "flash_hiba": FLASH_HIBA.get(hiba),
            "jh": jh_kontextus,
            "vissza_beallitasok": True,
            "admin_e": current_user.role == "Admin",
            "ceges_felhasznalok": ceges_felhasznalok,
            "licenc_letszamok": licenc_letszamok,
            "telephelyek": telephelyek,
            "gyartok": gyartok,
            "tipusok": tipusok,
            "gepek": gepek,
            "configs": configs,
            "szigor_ki": szigor_ki,
            "working_company_id": working_company_id,
            "cegek": cegek,
            "napi_kerdesek": napi_kerdesek,
            "napi_ellenorzes_aktiv": bool(napi_aktiv_obj),
            "riport_gyakorisag": riport_gyakorisag,
            "uzemora_eltertes_mod": uzemora_eltertes_mod,
            "uzemora_atlag_napok": uzemora_atlag_napok,
            "vizsgalat_email_ertesites": vizsgalat_email_ertesites,
            "vizsgalati_datum_kotelezo_mod": vizsgalati_datum_kotelezo_mod,
            "jogosultsagi_naplo": jogosultsagi_naplo,
            "naplo_tol": naplo_tol,
            "naplo_ig": naplo_ig,
            "dashboard_naptar_aktiv": dashboard_naptar_aktiv,
            "dashboard_diagramok_aktiv": dashboard_diagramok_aktiv,
            "dashboard_valasztott_diagramok": dashboard_valasztott_diagramok,
            "jegyzokonyv_sablonok": jegyzokonyv_sablonok,
            "napi_sablonok": napi_sablonok,
            "is_rendszeradmin": is_rendszeradmin,
            "sugo_e": sugo_engedelyezve(working_company_id, db),
            # ÚJ (2026-10-11-i user-jelzés): a mentő route-ok eddig is helyesen tiltották az
            # írást inaktív cégnél (redirect ?inaktiv_ceg=1-gyel, l. lent minden POST/DELETE),
            # DE az oldal maga semmilyen előzetes jelzést nem adott erről - a mezők elsőre
            # teljesen szerkeszthetőnek TŰNTEK, és csak egy sikertelen mentési kísérlet UTÁN
            # derült ki, hogy nem sikerült semmit elmenteni. A sablon ezt a kapcsolót
            # felhasználva most egy figyelmeztető sávval és egy <fieldset disabled>-del eleve
            # "szerkesztésre nem elérhetőnek" mutatja az egész oldalt, ha a cég inaktív.
            "ceg_aktiv": is_company_active(working_company_id, db),
        }
    )


@router.post("/uj-telephely")
def uj_telephely(
    request: Request,
    nev: str = Form(...),
    cim: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    uj_th = models.Site(
        company_id=working_company_id,
        nev=nev,
        cim=cim
    )
    db.add(uj_th)
    naploz(db, current_user, working_company_id, "Beállítás - Telephely", None, f"Új: {nev} ({cim or '-'})")
    db.commit()

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


@router.post("/szerkeszt-telephely")
def szerkeszt_telephely(
    request: Request,
    telephely_id: int = Form(...),
    nev: str = Form(...),
    cim: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    th = db.query(models.Site).filter(
        models.Site.id == telephely_id,
        models.Site.company_id == working_company_id
    ).first()

    if th:
        regi = f"{th.nev} ({th.cim or '-'})"
        th.nev = nev
        th.cim = cim
        naploz(db, current_user, working_company_id, "Beállítás - Telephely", regi, f"{nev} ({cim or '-'})", csak_ha_valtozott=True)
        db.commit()

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


@router.delete("/torol-telephely/{id}")
def torol_telephely(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú, telephely nem törölhető!"})

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

    th = db.query(models.Site).filter(
        models.Site.id == id,
        models.Site.company_id == working_company_id
    ).first()

    if th:
        naploz(db, current_user, working_company_id, "Beállítás - Telephely", f"{th.nev} ({th.cim or '-'})", "Törölve")
        db.delete(th)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Törölve"})


# A Beállítások "Szótárak" fülén a céges Admin KIZÁRÓLAG ezeket a szótár-kategóriákat kezelheti (Gyártó és Típus legördülő-listák).
# A `Dictionary` tábla ugyanakkor ENGEDÉLYEZÉSI KAPCSOLÓKAT és beállításokat is tárol (pl. AiSzkennelesEngedelyezve, SugoEngedelyezve,
# AzonositasMod, OEAlapteruletSzamitas, JegyzokonyvLogoUtvonal / FejlecSzoveg / LablecMarka, JegyzokonyvSablon ...), amelyeket a rendszeradmin
# vagy a saját, dedikált route-jaik kezelnek. Ha a három általános szótár-route bármilyen kategóriát elfogadna, a céges Admin egy kézzel
# összeállított kéréssel (a felület csak Gyarto/Tipus értéket küld, de ez csupán kliens-oldali korlát) megkerülné ezeket a kapcsolókat
# (pl. bekapcsolhatná a fizetős AI-szkennelést) - lásd docs/JOGOSULTSAGOK.md, J-01.
SZOTAR_KEZELHETO_KATEGORIAK = ("Gyarto", "Tipus")


@router.post("/uj-szotar")
def uj_szotar(
    request: Request,
    kategoria: str = Form(...),
    ertek: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return RedirectResponse(url="/beallitasok", status_code=status.HTTP_303_SEE_OTHER)

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    # J-01: csak a Gyártó / Típus szótár vehető fel ezen az útvonalon (kézzel küldött, más kategória: 400, semmi sem íródik).
    if kategoria not in SZOTAR_KEZELHETO_KATEGORIAK:
        return JSONResponse(status_code=400, content={"message": "Ismeretlen szótár-kategória!"})

    uj_szot = models.Dictionary(
        company_id=working_company_id,
        kategoria=kategoria,
        ertek=ertek
    )
    db.add(uj_szot)
    naploz(db, current_user, working_company_id, f"Beállítás - Szótár ({kategoria})", None, f"Új: {ertek}")
    db.commit()

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


@router.post("/szerkeszt-szotar")
def szerkeszt_szotar(
    request: Request,
    szotar_id: int = Form(...),
    ertek: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return RedirectResponse(url="/beallitasok", status_code=status.HTTP_303_SEE_OTHER)

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    # J-01: a sor kategóriáját is ellenőrizzük - egy kapcsoló / beállítás sor (nem Gyártó/Típus) azonosítója sem szerkeszthető itt.
    sz = db.query(models.Dictionary).filter(
        models.Dictionary.id == szotar_id,
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria.in_(SZOTAR_KEZELHETO_KATEGORIAK)
    ).first()

    if sz:
        regi = sz.ertek
        sz.ertek = ertek
        naploz(db, current_user, working_company_id, f"Beállítás - Szótár ({sz.kategoria})", regi, ertek, csak_ha_valtozott=True)
        db.commit()

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


@router.delete("/torol-szotar/{id}")
def torol_szotar(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú, szótárelem nem törölhető!"})

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

    # J-01: a törlésnél is csak Gyártó / Típus sor (egy kapcsoló / beállítás sor azonosítója esetén nem törlődik semmi).
    sz = db.query(models.Dictionary).filter(
        models.Dictionary.id == id,
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria.in_(SZOTAR_KEZELHETO_KATEGORIAK)
    ).first()

    if sz:
        naploz(db, current_user, working_company_id, f"Beállítás - Szótár ({sz.kategoria})", sz.ertek, "Törölve")
        db.delete(sz)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Törölve"})


@router.post("/uj-gep-konfig", dependencies=EMELOGEP_MODUL_KAPU)
async def uj_gep_konfig(
    request: Request,
    geptipus: str = Form(...),
    kotelezo_mezok: list[str] = Form(default=[]),
    rejtett_mezok: list[str] = Form(default=[]),
    # --- ÚJ JOKER MEZŐ NEVEK ---
    egyedi_1_nev: str = Form(default=""),
    egyedi_2_nev: str = Form(default=""),
    egyedi_3_nev: str = Form(default=""),
    # ---------------------------
    msz16226_szukseges: str = Form(default=""),
    kezeloi_munkahely_szukseges: str = Form(default=""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return RedirectResponse(url="/beallitasok", status_code=303)

    form_data = await request.form()
    geptipus = form_data.get("geptipus")
    kotelezo_mezok_list = form_data.getlist("kotelezo_mezok")
    rejtett_mezok_list = form_data.getlist("rejtett_mezok")  # <--- ÚJ: Kiolvassuk a rejtetteket is

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=303)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=303)

    # Ellenőrizzük, van-e már konfig ehhez a típushoz a cégnél
    letezo = db.query(models.MachineTypeConfig).filter(
        models.MachineTypeConfig.company_id == working_company_id,
        models.MachineTypeConfig.geptipus == geptipus
    ).first()

    regi_konfig = _konfig_szoveg(letezo) if letezo else None
    if letezo:
        letezo.kotelezo_mezok = ",".join(kotelezo_mezok)
        letezo.rejtett_mezok = ",".join(rejtett_mezok)
        # --- ÚJ MEZŐK FELÜLÍRÁSA ---
        letezo.egyedi_1_nev = egyedi_1_nev
        letezo.egyedi_2_nev = egyedi_2_nev
        letezo.egyedi_3_nev = egyedi_3_nev
        letezo.msz16226_szukseges = bool(msz16226_szukseges)
        letezo.kezeloi_munkahely_szukseges = bool(kezeloi_munkahely_szukseges)
    else:
        uj_konfig = models.MachineTypeConfig(
            company_id=working_company_id,
            geptipus=geptipus,
            kotelezo_mezok=",".join(kotelezo_mezok),
            rejtett_mezok=",".join(rejtett_mezok),
            # --- ÚJ MEZŐK MENTÉSE ---
            egyedi_1_nev=egyedi_1_nev,
            egyedi_2_nev=egyedi_2_nev,
            egyedi_3_nev=egyedi_3_nev,
            msz16226_szukseges=bool(msz16226_szukseges),
            kezeloi_munkahely_szukseges=bool(kezeloi_munkahely_szukseges)
        )
        db.add(uj_konfig)

    uj_szoveg = _konfig_szoveg(letezo if letezo else uj_konfig)
    naploz(db, current_user, working_company_id, f"Beállítás - Géptípus-konfiguráció ({geptipus})", regi_konfig, uj_szoveg, csak_ha_valtozott=True)
    db.commit()
    return RedirectResponse(url="/beallitasok", status_code=303)


@router.delete("/torol-gep-konfig/{id}", dependencies=EMELOGEP_MODUL_KAPU)
def torol_gep_konfig(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú, konfiguráció nem törölhető!"})

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

    konfig = db.query(models.MachineTypeConfig).filter(
        models.MachineTypeConfig.id == id,
        models.MachineTypeConfig.company_id == working_company_id
    ).first()

    if konfig:
        naploz(db, current_user, working_company_id, f"Beállítás - Géptípus-konfiguráció ({konfig.geptipus})", _konfig_szoveg(konfig), "Törölve")
        db.delete(konfig)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Törölve"})


@router.post("/kapcsol-rendelet-szigoritas", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_rendelet_szigoritas(
    request: Request,
    kikapcsolva: str = Form(None),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    szigor = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "RendeletSzigoritasKikapcsolva"
    ).first()

    naploz(db, current_user, working_company_id, "Beállítás - Rendelet-szigorítás (automatikus besorolás)",
           be_ki(szigor is None), be_ki(kikapcsolva != "on"), csak_ha_valtozott=True)
    if kikapcsolva == "on":
        if not szigor:
            uj_szabaly = models.Dictionary(
                company_id=working_company_id,
                kategoria="RendeletSzigoritasKikapcsolva",
                ertek="True"
            )
            db.add(uj_szabaly)
    else:
        if szigor:
            db.delete(szigor)

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


# >>> E-MAIL FÜGGVÉNY <<<
@router.post("/kapcsol-email-riport")
def kapcsol_email_riport(
    request: Request,
    gyakorisag: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "EmailRiportGyakorisag"
    ).first()

    naploz(db, current_user, working_company_id, "Beállítás - E-mail riport gyakoriság",
           beallitas.ertek if beallitas else None, gyakorisag, csak_ha_valtozott=True)
    if not beallitas:
        uj_beallitas = models.Dictionary(
            company_id=working_company_id,
            kategoria="EmailRiportGyakorisag",
            ertek=gyakorisag
        )
        db.add(uj_beallitas)
    else:
        beallitas.ertek = gyakorisag

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


@router.post("/kapcsol-uzemora-eltertes", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_uzemora_eltertes(
    request: Request,
    mod: str = Form(...),
    atlag_napok: int = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    if mod not in ("Figyelmeztetes", "AutomatikusModositas"):
        mod = "Figyelmeztetes"
    if atlag_napok < 1:
        atlag_napok = 30

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    def ment_beallitas(kategoria, ertek):
        beallitas = db.query(models.Dictionary).filter(
            models.Dictionary.company_id == working_company_id,
            models.Dictionary.kategoria == kategoria
        ).first()
        if not beallitas:
            db.add(models.Dictionary(company_id=working_company_id, kategoria=kategoria, ertek=str(ertek)))
        else:
            beallitas.ertek = str(ertek)

    regi_uzemora = f"{_dict_ertek(db, working_company_id, 'UzemoraEltertesMod') or '-'}, {_dict_ertek(db, working_company_id, 'UzemoraAtlagNapok') or '-'} nap"
    ment_beallitas("UzemoraEltertesMod", mod)
    ment_beallitas("UzemoraAtlagNapok", atlag_napok)
    naploz(db, current_user, working_company_id, "Beállítás - Üzemóra-eltérés", regi_uzemora, f"{mod}, {atlag_napok} nap", csak_ha_valtozott=True)

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


@router.post("/kapcsol-vizsgalati-datum-kotelezo-mod", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_vizsgalati_datum_kotelezo_mod(
    request: Request,
    mod: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """Szabályozza, hogy a vizsgálati dátumok (Szerkezeti/Fő/Biztonsági) hiánya/lejárata mikor
    jelezzen (naptár-ikon, dashboard, "Lejárt vizsgálat" automatikus státusz): "AlapbolKotelezo"
    - minden géptípusnál kötelező, csak a kifejezetten "rejtett"-té tett dátumok nem számítanak;
    "CsakBepipalt" - csak azok a dátumok jeleznek, amiket a géptípusnál kifejezetten kötelezőnek
    jelöltek a Beállítások / Géptípusok fülön."""
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    if mod not in ("AlapbolKotelezo", "CsakBepipalt"):
        mod = "AlapbolKotelezo"

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "VizsgalatiDatumKotelezoMod"
    ).first()
    naploz(db, current_user, working_company_id, "Beállítás - Vizsgálati dátum kötelező mód",
           beallitas.ertek if beallitas else None, mod, csak_ha_valtozott=True)
    if not beallitas:
        db.add(models.Dictionary(company_id=working_company_id, kategoria="VizsgalatiDatumKotelezoMod", ertek=mod))
    else:
        beallitas.ertek = mod

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


@router.post("/kapcsol-vizsgalat-email-ertesites", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_vizsgalat_email_ertesites(
    request: Request,
    bekapcsolva: str = Form(default="false"),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """Ha egy vizsgálat vagy feltöltött vizsgálati dokumentum "Korlátozással alkalmas" / "Nem
    alkalmas" minősítést kap, a gép automatikus kivonása és a dashboard hibajegy mindig
    megtörténik - ez a beállítás csak azt szabályozza, hogy erről e-mail is menjen-e az EÜI-nek."""
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    ertek = "True" if bekapcsolva == "on" else "False"

    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "VizsgalatSikertelenEmailErtesites"
    ).first()
    naploz(db, current_user, working_company_id, "Beállítás - Vizsgálat e-mail értesítés",
           _kapcsolo_szoveg(beallitas.ertek if beallitas else None), _kapcsolo_szoveg(ertek), csak_ha_valtozott=True)
    if not beallitas:
        db.add(models.Dictionary(company_id=working_company_id, kategoria="VizsgalatSikertelenEmailErtesites", ertek=ertek))
    else:
        beallitas.ertek = ertek

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


@router.post("/kapcsol-napi-ellenorzes", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_napi_ellenorzes(
    request: Request,
    aktiv: str = Form(None),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    # Ellenőrizzük, van-e már ilyen beállítás a céghez
    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "NapiEllenorzesAktiv"
    ).first()

    naploz(db, current_user, working_company_id, "Beállítás - Napi ellenőrzés (műszakkezdő ellenőrzőlisták)",
           be_ki(beallitas is not None), be_ki(aktiv == "on"), csak_ha_valtozott=True)
    if aktiv == "on":
        if not beallitas:
            uj_beallitas = models.Dictionary(
                company_id=working_company_id,
                kategoria="NapiEllenorzesAktiv",
                ertek="True"
            )
            db.add(uj_beallitas)
    else:
        if beallitas:
            db.delete(beallitas)

    db.commit()
    # Frissítjük a beállítások oldalt, hogy a gomb beálljon a helyes állapotba
    return RedirectResponse(url="/beallitasok", status_code=status.HTTP_303_SEE_OTHER)


@router.post("/uj-napi-kerdes", dependencies=EMELOGEP_MODUL_KAPU)
async def uj_napi_kerdes(
    request: Request,
    szoveg: str = Form(...),
    kovetkezmeny: str = Form(...),
    geptipus_lista: list[str] = Form(default=[]),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    # Ez a helyes kód az ÚJ kérdés rögzítésére
    uj_kerdes = models.DailyCheckQuestion(
        company_id=working_company_id,
        szoveg=szoveg.strip(),
        kovetkezmeny=kovetkezmeny,
        geptipus_lista=",".join(geptipus_lista) if geptipus_lista else None
    )
    db.add(uj_kerdes)
    naploz(db, current_user, working_company_id, "Beállítás - Napi kérdés", None,
           f"Új: {szoveg.strip()} [{kovetkezmeny}; géptípus: {uj_kerdes.geptipus_lista or 'mind'}]")
    db.commit()
    return RedirectResponse(url="/beallitasok", status_code=status.HTTP_303_SEE_OTHER)


@router.post("/szerkeszt-napi-kerdes", dependencies=EMELOGEP_MODUL_KAPU)
async def szerkeszt_napi_kerdes(
    request: Request,
    kerdes_id: int = Form(...),
    szoveg: str = Form(...),
    kovetkezmeny: str = Form(...),
    geptipus_lista: list[str] = Form(default=[]),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)

    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    # Ez a helyes kód a MEGLÉVŐ kérdés módosítására
    kerdes = db.query(models.DailyCheckQuestion).filter(
        models.DailyCheckQuestion.id == kerdes_id,
        models.DailyCheckQuestion.company_id == working_company_id
    ).first()

    if kerdes:
        regi = f"{kerdes.szoveg} [{kerdes.kovetkezmeny}; géptípus: {kerdes.geptipus_lista or 'mind'}]"
        kerdes.szoveg = szoveg.strip()
        kerdes.kovetkezmeny = kovetkezmeny
        kerdes.geptipus_lista = ",".join(geptipus_lista) if geptipus_lista else None
        naploz(db, current_user, working_company_id, "Beállítás - Napi kérdés", regi,
               f"{kerdes.szoveg} [{kerdes.kovetkezmeny}; géptípus: {kerdes.geptipus_lista or 'mind'}]", csak_ha_valtozott=True)
        db.commit()

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


@router.delete("/torol-napi-kerdes/{id}", dependencies=EMELOGEP_MODUL_KAPU)
def torol_napi_kerdes(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú, kérdés nem törölhető!"})

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

    kerdes = db.query(models.DailyCheckQuestion).filter(
        models.DailyCheckQuestion.id == id,
        models.DailyCheckQuestion.company_id == working_company_id
    ).first()

    if kerdes:
        naploz(db, current_user, working_company_id, "Beállítás - Napi kérdés",
               f"{kerdes.szoveg} [{kerdes.kovetkezmeny}; géptípus: {kerdes.geptipus_lista or 'mind'}]", "Törölve")
        db.delete(kerdes)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Törölve"})


def _kapcsol_dictionary_flag(db: Session, company_id: int, kategoria: str, alapertelmezett_true: bool,
                             actor=None, naplo_mezo: str = "Beállítás - Dashboard kapcsoló") -> bool:
    """Megfordítja egy True/False Dictionary-alapú kapcsoló állapotát. Ha még nincs rögzítve sor,
    az alapértelmezett (jelenlegi, be nem állított) állapot ellentétjét menti el elsőként."""
    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == company_id,
        models.Dictionary.kategoria == kategoria
    ).first()

    if beallitas:
        uj_ertek = not (beallitas.ertek == "True")
        beallitas.ertek = "True" if uj_ertek else "False"
    else:
        uj_ertek = not alapertelmezett_true
        db.add(models.Dictionary(company_id=company_id, kategoria=kategoria, ertek=("True" if uj_ertek else "False")))
    naploz(db, actor, company_id, naplo_mezo, be_ki(not uj_ertek), be_ki(uj_ertek))      # J-20: a kapcsolás mindig állapotot vált
    db.commit()
    return uj_ertek


@router.post("/kapcsol-dashboard-naptar", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_dashboard_naptar(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú!"})
    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})

    uj_allapot = _kapcsol_dictionary_flag(db, working_company_id, "DashboardNaptarAktiv", alapertelmezett_true=True,
                                          actor=current_user, naplo_mezo="Beállítás - Dashboard eseménynaptár")
    allapot_szoveg = "bekapcsolva" if uj_allapot else "kikapcsolva"
    return JSONResponse(status_code=200, content={"message": f"Eseménynaptár sikeresen {allapot_szoveg}!", "aktiv": uj_allapot})


@router.post("/kapcsol-dashboard-diagramok", dependencies=EMELOGEP_MODUL_KAPU)
def kapcsol_dashboard_diagramok(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    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ú!"})
    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})

    uj_allapot = _kapcsol_dictionary_flag(db, working_company_id, "DashboardDiagramokAktiv", alapertelmezett_true=True,
                                          actor=current_user, naplo_mezo="Beállítás - Dashboard diagramok")
    allapot_szoveg = "bekapcsolva" if uj_allapot else "kikapcsolva"
    return JSONResponse(status_code=200, content={"message": f"Diagramok sikeresen {allapot_szoveg}!", "aktiv": uj_allapot})


@router.post("/ment-dashboard-diagram-tipusok", dependencies=EMELOGEP_MODUL_KAPU)
async def ment_dashboard_diagram_tipusok(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    working_company_id = get_working_company_id(current_user, request)

    if not is_company_active(working_company_id, db):
        return RedirectResponse(url="/beallitasok?inaktiv_ceg=1", status_code=status.HTTP_303_SEE_OTHER)
    if current_user.csak_olvasas:
        return RedirectResponse(url="/beallitasok?csak_olvasas=1", status_code=status.HTTP_303_SEE_OTHER)

    form_data = await request.form()
    valasztott = form_data.getlist("diagram_tipus")
    ervenyes_tipusok = {"statusz", "gyarto", "geptipus", "kor"}
    szurt = [t for t in valasztott if t in ervenyes_tipusok]
    ertek = ",".join(szurt)

    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "DashboardDiagramTipusok"
    ).first()
    naploz(db, current_user, working_company_id, "Beállítás - Dashboard diagram-típusok",
           beallitas.ertek if beallitas else None, ertek, csak_ha_valtozott=True)
    if beallitas:
        beallitas.ertek = ertek
    else:
        db.add(models.Dictionary(company_id=working_company_id, kategoria="DashboardDiagramTipusok", ertek=ertek))

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


# --- ELLENŐRZŐLISTA SABLONOK (kizárólag Admin hozhat létre / törölhet - az Emelőgép szakértő/vizsgáló/EÜI
# a vizsgálat rögzítésekor csak a meglévő sablonokat töltheti be, sort ad hozzá/vesz el). ---

@router.post("/uj-jegyzokonyv-sablon", dependencies=EMELOGEP_MODUL_KAPU)
async def uj_jegyzokonyv_sablon(
    request: Request,
    nev: str = Form(...),
    kerdesek_json: str = Form(...),
    vizsgalat_tipus: str = Form(default=""),
    geptipus_lista: list[str] = Form(default=[]),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if not is_rendszeradminisztrator(current_user):
        return JSONResponse(status_code=403, content={"message": "Csak a rendszeradminisztrátor hozhat létre ellenőrzőlista sablont!"})

    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ú, sablon nem hozható létre!"})

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

    if not nev.strip():
        return JSONResponse(status_code=400, content={"message": "A sablon nevének megadása kötelező!"})

    try:
        kerdesek = json.loads(kerdesek_json)
        if not isinstance(kerdesek, list):
            raise ValueError("A kérdéslistának tömbnek kell lennie.")
    except (json.JSONDecodeError, ValueError):
        return JSONResponse(status_code=400, content={"message": "Érvénytelen kérdéslista-formátum!"})

    if len(kerdesek) == 0:
        return JSONResponse(status_code=400, content={"message": "Legalább egy kérdés szükséges a sablonhoz!"})

    sablon_ertek = {"nev": nev.strip(), "kerdesek": kerdesek}
    if vizsgalat_tipus.strip():
        sablon_ertek["vizsgalat_tipus"] = vizsgalat_tipus.strip()
    if geptipus_lista:
        sablon_ertek["geptipus_lista"] = ",".join(geptipus_lista)

    uj_sablon = models.Dictionary(
        company_id=working_company_id,
        kategoria="JegyzokonyvSablon",
        ertek=json.dumps(sablon_ertek, ensure_ascii=False)
    )
    db.add(uj_sablon)
    naploz(db, current_user, working_company_id, "Beállítás - Jegyzőkönyv-sablon", None, f"Új: {nev.strip()} ({len(kerdesek)} kérdés)")
    db.commit()

    return JSONResponse(status_code=200, content={"message": f"'{nev.strip()}' sablon sikeresen létrehozva!"})


@router.delete("/torol-jegyzokonyv-sablon/{id}", dependencies=EMELOGEP_MODUL_KAPU)
def torol_jegyzokonyv_sablon(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if not is_rendszeradminisztrator(current_user):
        return JSONResponse(status_code=403, content={"message": "Csak a rendszeradminisztrátor törölhet ellenőrzőlista sablont!"})

    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ú, sablon nem törölhető!"})

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

    sablon = db.query(models.Dictionary).filter(
        models.Dictionary.id == id,
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "JegyzokonyvSablon"
    ).first()

    if sablon:
        naploz(db, current_user, working_company_id, "Beállítás - Jegyzőkönyv-sablon", _sablon_nev(sablon.ertek), "Törölve")
        db.delete(sablon)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Sablon törölve!"})


# --- NAPI ELLENŐRZÉS SABLONOK (géptípusonkénti kérdéscsomagok - "Alkalmazás"-kor tömegesen új
# DailyCheckQuestion sorokat hoznak létre, nem egy kliens-oldali táblázatot töltenek be). ---

@router.post("/uj-napi-sablon", dependencies=EMELOGEP_MODUL_KAPU)
async def uj_napi_sablon(
    request: Request,
    nev: str = Form(...),
    geptipus_lista: list[str] = Form(default=[]),
    kerdesek_json: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if not is_rendszeradminisztrator(current_user):
        return JSONResponse(status_code=403, content={"message": "Csak a rendszeradminisztrátor hozhat létre napi ellenőrzés sablont!"})

    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ú, sablon nem hozható létre!"})

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

    if not nev.strip():
        return JSONResponse(status_code=400, content={"message": "A sablon nevének megadása kötelező!"})

    try:
        kerdesek = json.loads(kerdesek_json)
        if not isinstance(kerdesek, list):
            raise ValueError("A kérdéslistának tömbnek kell lennie.")
    except (json.JSONDecodeError, ValueError):
        return JSONResponse(status_code=400, content={"message": "Érvénytelen kérdéslista-formátum!"})

    if len(kerdesek) == 0:
        return JSONResponse(status_code=400, content={"message": "Legalább egy kérdés szükséges a sablonhoz!"})

    uj_sablon = models.Dictionary(
        company_id=working_company_id,
        kategoria="NapiEllenorzesSablon",
        ertek=json.dumps({
            "nev": nev.strip(),
            "geptipus_lista": ",".join(geptipus_lista) if geptipus_lista else "",
            "kerdesek": kerdesek
        }, ensure_ascii=False)
    )
    db.add(uj_sablon)
    naploz(db, current_user, working_company_id, "Beállítás - Napi ellenőrzés sablon", None, f"Új: {nev.strip()} ({len(kerdesek)} kérdés)")
    db.commit()

    return JSONResponse(status_code=200, content={"message": f"'{nev.strip()}' napi sablon sikeresen létrehozva!"})


@router.delete("/torol-napi-sablon/{id}", dependencies=EMELOGEP_MODUL_KAPU)
def torol_napi_sablon(
    request: Request,
    id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if not is_rendszeradminisztrator(current_user):
        return JSONResponse(status_code=403, content={"message": "Csak a rendszeradminisztrátor törölhet napi ellenőrzés sablont!"})

    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ú, sablon nem törölhető!"})

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

    sablon = db.query(models.Dictionary).filter(
        models.Dictionary.id == id,
        models.Dictionary.company_id == working_company_id,
        models.Dictionary.kategoria == "NapiEllenorzesSablon"
    ).first()

    if sablon:
        naploz(db, current_user, working_company_id, "Beállítás - Napi ellenőrzés sablon", _sablon_nev(sablon.ertek), "Törölve")
        db.delete(sablon)
        db.commit()

    return JSONResponse(status_code=200, content={"message": "Napi sablon törölve!"})


@router.post("/alkalmaz-napi-sablon/{sablon_id}", dependencies=EMELOGEP_MODUL_KAPU)
def alkalmaz_napi_sablon(
    request: Request,
    sablon_id: int,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """A napi ellenőrzés sablon összes kérdéséhez létrehoz egy-egy ÚJ DailyCheckQuestion sort a
    cégnél, a sablon geptipus_lista-jával megjelölve. Duplikátum-védelem: kihagyja azokat a
    kérdéseket, amiknek a szövege szó szerint már létezik a cégnél."""
    if not is_rendszeradminisztrator(current_user):
        return JSONResponse(status_code=403, content={"message": "Csak a rendszeradminisztrátor alkalmazhat napi ellenőrzés sablont!"})

    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ú, sablon nem alkalmazható!"})

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

    # A sablon lehet a saját cégé, VAGY az 1-es (alap) cég megosztott sablonja (lásd a fenti,
    # `napi_sablonok` listát építő tartalék-logikát) - ide bármelyik CSAK OLVASÁSRA kerül, az
    # újonnan létrehozott DailyCheckQuestion sorok mindig a working_company_id-hez kerülnek.
    sablon = db.query(models.Dictionary).filter(
        models.Dictionary.id == sablon_id,
        models.Dictionary.company_id.in_([working_company_id, 1]),
        models.Dictionary.kategoria == "NapiEllenorzesSablon"
    ).first()

    if not sablon:
        return JSONResponse(status_code=404, content={"message": "A sablon nem található!"})

    try:
        adat = json.loads(sablon.ertek)
    except (json.JSONDecodeError, TypeError):
        return JSONResponse(status_code=400, content={"message": "Érvénytelen sablon-formátum!"})

    geptipus_lista = adat.get("geptipus_lista") or None
    meglevo_szovegek = {
        (k.szoveg or "").strip().lower() for k in db.query(models.DailyCheckQuestion).filter(
            models.DailyCheckQuestion.company_id == working_company_id
        ).all()
    }

    letrehozott = 0
    kihagyott = 0
    for kerdes in adat.get("kerdesek", []):
        szoveg = (kerdes.get("szoveg") or "").strip()
        if not szoveg or szoveg.lower() in meglevo_szovegek:
            kihagyott += 1
            continue
        db.add(models.DailyCheckQuestion(
            company_id=working_company_id,
            szoveg=szoveg,
            kovetkezmeny=kerdes.get("kovetkezmeny", "FIGYELMEZTETES"),
            geptipus_lista=geptipus_lista
        ))
        meglevo_szovegek.add(szoveg.lower())
        letrehozott += 1

    if letrehozott:
        naploz(db, current_user, working_company_id, "Beállítás - Napi ellenőrzés sablon alkalmazva", _sablon_nev(sablon.ertek),
               f"{letrehozott} új napi kérdés létrehozva, {kihagyott} kihagyva (már létezett)")
    db.commit()
    uzenet = f"{letrehozott} új napi kérdés létrehozva."
    if kihagyott:
        uzenet += f" {kihagyott} kérdés kihagyva (már létezett)."
    return JSONResponse(status_code=200, content={"message": uzenet})