import base64
import io
import json
import os
from datetime import date, datetime

from fastapi import APIRouter, Request, Depends, Form, HTTPException, status
from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse, StreamingResponse, FileResponse
from sqlalchemy import or_, func
from sqlalchemy.orm import Session, joinedload

import models
import aktivalas_utils
from database import get_db
from security import (
    get_current_user, get_working_company_id, is_company_active,
    irasi_tiltas_oka, IRASI_TILTAS_UZENETEK,
    require_modul, get_allowed_companies_list, safe_json_for_script,
    is_safe_extension, sanitize_filename, get_password_hash, van_e_tobb_modulja,
    sugo_engedelyezve, is_company_allowed, jelszo_eleg_eros_e,
)
from image_utils import tomorit_kepet
from hibakodok import hiba_uzenet
from ebk_pdf_utils import EbkNapiOsszefoglaloPDF, EbkEllenorzesPDF, SULYOSSAG_CIMKE
from templates_env import templates

router = APIRouter(dependencies=[Depends(require_modul("EBK"))])

SULYOSSAGOK = ["ENYHE", "KOZEPES", "SULYOS"]
ELLENORZES_STATUSZOK = ("RENDBEN", "SZABALYTALANSAG", "NEM_RELEVANS")


def _egesz_vagy_hiba(ertek):
    """int(ertek), ha egész szám (vagy számjegyes szöveg); különben ValueError. A bool nem számít egésznek."""
    if isinstance(ertek, bool):
        raise ValueError()
    if isinstance(ertek, int):
        return ertek
    if isinstance(ertek, str) and ertek.strip().isdigit():
        return int(ertek.strip())
    raise ValueError()


def ellenorzes_hivatkozasok_ellenorzese(db, projekt, working_company_id, terulet_id, epulet_id, szint_id, osszes_szint, tetel_eredmenyek):
    """J-13 (v70): az EBK ellenőrzés-mentés (a JSON-ból és az űrlapról érkező) hivatkozott azonosítóinak ellenőrzése MENTÉS ELŐTT.
    Eddig sem a fejléc épülete/szintje, sem a sorok tétele / alvállalkozója / tevékenysége / szintje nem volt a céghez (projekthez)
    kötve - idegen cég adatának neve megjelent az ellenőrzés részleteiben és a PDF-ben; a statusz fehérlista nélkül mentődött.
    Hibánál a visszatérési érték a 400-as válasz üzenete (és semmi sem mentődik), különben None. A sorok azonosítóit egész számra
    normalizálja (a tetel_eredmenyek elemeit helyben módosítja)."""
    if not isinstance(tetel_eredmenyek, list) or not all(isinstance(s, dict) for s in tetel_eredmenyek):
        return "Hibás tétel-adat formátum!"
    try:
        epulet = _egesz_vagy_hiba(epulet_id) if str(epulet_id or "").strip() else None
        fejlec_szint = _egesz_vagy_hiba(szint_id) if (str(szint_id or "").strip() and not osszes_szint) else None
    except ValueError:
        return "Érvénytelen épület/szint azonosító!"
    if epulet is not None:
        van = db.query(models.EbkEpulet.id).filter(models.EbkEpulet.id == epulet, models.EbkEpulet.terulet_id == terulet_id).first()
        if not van:
            return "A kiválasztott épület nem tartozik a megadott területhez!"
    if fejlec_szint is not None:
        van = epulet is not None and db.query(models.EbkSzint.id).filter(
            models.EbkSzint.id == fejlec_szint, models.EbkSzint.epulet_id == epulet).first()
        if not van:
            return "A kiválasztott szint nem tartozik a megadott épülethez!"

    projekt_tetel_idk = {r[0] for r in db.query(models.EbkProjektTetel.tetel_id).filter(models.EbkProjektTetel.projekt_id == projekt.id).all()}
    alvallalkozo_idk = {r[0] for r in db.query(models.EbkAlvallalkozo.id).filter(models.EbkAlvallalkozo.company_id == working_company_id).all()}
    tevekenyseg_idk = {r[0] for r in db.query(models.EbkTevekenyseg.id).filter(models.EbkTevekenyseg.company_id == working_company_id).all()}
    epulet_szint_idk = {r[0] for r in db.query(models.EbkSzint.id).filter(models.EbkSzint.epulet_id == epulet).all()} if epulet is not None else set()

    for sor in tetel_eredmenyek:
        if sor.get("statusz") not in ELLENORZES_STATUSZOK:
            return "Érvénytelen tétel-státusz!"
        try:
            sor["tetel_id"] = _egesz_vagy_hiba(sor.get("tetel_id"))
        except ValueError:
            return "Érvénytelen tétel-azonosító!"
        if sor["tetel_id"] not in projekt_tetel_idk:
            return "A tételek között van olyan, ami nem ehhez a projekthez tartozik!"
        if sor["statusz"] != "SZABALYTALANSAG":
            continue
        for mezo, ervenyes, uzenet in (
            ("alvallalkozo_id", alvallalkozo_idk, "Az alvállalkozó nem ehhez a céghez tartozik!"),
            ("tevekenyseg_id", tevekenyseg_idk, "A tevékenység nem ehhez a céghez tartozik!"),
            ("szint_id", epulet_szint_idk, "A szabálytalanság szintje nem tartozik a megadott épülethez!"),
        ):
            if mezo == "szint_id" and not osszes_szint:
                continue                          # nem "összes szint" bejárásnál a sor szintjét a kód nem menti
            if not sor.get(mezo):
                sor[mezo] = None
                continue
            try:
                sor[mezo] = _egesz_vagy_hiba(sor[mezo])
            except ValueError:
                return "Érvénytelen azonosító a tételsorban!"
            if sor[mezo] not in ervenyes:
                return uzenet
    return None


ADMIN_SZEREPKOROK = ["Admin"]


def _lehet_adminisztralni(current_user, working_company_id, db) -> bool:
    """Teljes beállítási jog: katalógusok, projekt létrehozása/szerkesztése, hozzárendelések -
    kizárólag Admin, sem az EBK koordinátor, sem a Megtekintő nem fér hozzá."""
    if current_user.role not in ADMIN_SZEREPKOROK:
        return False
    if not is_company_active(working_company_id, db):
        return False
    if current_user.csak_olvasas:
        return False
    return True


def _lehet_ellenorizni(current_user, working_company_id, db, projekt) -> bool:
    """Helyszíni ellenőrzés rögzítésének joga: Admin bármely projekten,
    EBK szerepkörű koordinátor kizárólag a hozzá rendelt projekte(ke)n."""
    if not is_company_active(working_company_id, db):
        return False
    if current_user.csak_olvasas:
        return False
    if current_user.role in ADMIN_SZEREPKOROK:
        return True
    if current_user.role == "EBK":
        return projekt in current_user.ebk_koordinalt_projektek
    return False


def _projekt_lathato_e(current_user, projekt) -> bool:
    """Megtekintő/EBK csak a hozzájuk rendelt projekte(ke)t láthatja; Admin mindent."""
    if current_user.role in ADMIN_SZEREPKOROK:
        return True
    if current_user.role == "Megtekintő":
        return projekt in current_user.ebk_projektek
    if current_user.role == "EBK":
        return projekt in current_user.ebk_koordinalt_projektek
    return False


def _ceg_kontextus(request, current_user, db):
    """Munkakörnyezet-context egységesen: a working_company_id, a modul szerint szűrt
    (EBK-előfizetéssel rendelkező) választható cégek listája, és - ha a jelenlegi
    working_company_id NEM szerepel ebben a szűrt listában, pl. mert egy korábbi
    cégváltás óta beragadt egy olyan cégre, aminek nincs EBK-előfizetése - a ténylegesen
    aktív cég neve. Enélkül a cégválasztó legördülő egyetlen opciós esetben (jellemzően
    csak egyetlen cégnek van EBK-ja) csendben, félrevezetően mindig azt az egy céget
    mutatja kiválasztva, függetlenül attól, hogy a valós munkakörnyezet egészen más cég -
    ez okozott korábban egy nehezen felderíthető "eltűnt adat" jelenséget."""
    working_company_id = get_working_company_id(current_user, request)
    cegek = get_allowed_companies_list(current_user, db, "EBK")
    aktualis_ceg_nev_ha_eltero = None
    if working_company_id not in {c.id for c in cegek}:
        aktualis = db.query(models.Company).filter(models.Company.id == working_company_id).first()
        aktualis_ceg_nev_ha_eltero = aktualis.nev if aktualis else f"#{working_company_id}"
    sugo_e = sugo_engedelyezve(working_company_id, db)
    return working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e


def _parse_date(ertek: str):
    if not ertek:
        return None
    try:
        return datetime.strptime(ertek, "%Y-%m-%d").date()
    except ValueError:
        return None


def _teruletek_a_ceghez(working_company_id: int, db: Session) -> list:
    return db.query(models.EbkTerulet).filter(
        models.EbkTerulet.company_id == working_company_id, models.EbkTerulet.aktiv == True
    ).all()


def _celellenorzes_opciok(projekt_tetelek) -> list:
    """A célellenőrzés legördülő opciólistája a projekt aktív ellenőrzési tételeinek meglévő
    kategorizálásából - a tétel szövege jellemzően "Kategória – részletek (jogszabály)" alakú,
    ezért a kötőjel előtti rész adja a témát. Nem külön karbantartandó, kézzel felvitt lista."""
    kategoriak = []
    for pt in projekt_tetelek:
        if not pt.aktiv:
            continue
        szoveg = pt.tetel.szoveg or ""
        kategoria = szoveg.split(" – ", 1)[0].strip()
        if kategoria and kategoria not in kategoriak:
            kategoriak.append(kategoria)
    return sorted(kategoriak)


def _epuletek_json_projekthez(projekt, db: Session) -> str:
    """A projekthez rendelt területek épület+szint fáját szolgáltatja JSON-ban a
    helyszín-választó kaszkádolt legördülőkhöz (terulet -> épület -> szint)."""
    terulet_idk = [t.id for t in projekt.teruletek]
    if not terulet_idk:
        return safe_json_for_script([])

    epuletek = db.query(models.EbkEpulet).filter(
        models.EbkEpulet.terulet_id.in_(terulet_idk), models.EbkEpulet.aktiv == True
    ).all()
    szintek = db.query(models.EbkSzint).filter(
        models.EbkSzint.epulet_id.in_([e.id for e in epuletek]), models.EbkSzint.aktiv == True
    ).all() if epuletek else []

    szintek_epulet_szerint = {}
    for sz in szintek:
        szintek_epulet_szerint.setdefault(sz.epulet_id, []).append({"id": sz.id, "nev": sz.nev})

    return safe_json_for_script([
        {"id": e.id, "terulet_id": e.terulet_id, "nev": e.nev, "szintek": szintek_epulet_szerint.get(e.id, [])}
        for e in epuletek
    ])


def _mentse_base64_kepet(data_uri: str, mappa: str, fajlnev: str) -> str | None:
    """Egy 'data:image/png;base64,...' alakú stringet fájlba ment - az aláírás-canvas
    kimenetének mentéséhez."""
    if not data_uri or "," not in data_uri:
        return None
    try:
        fejlec, adat = data_uri.split(",", 1)
        kep_bytes = base64.b64decode(adat)
    except Exception:
        return None

    os.makedirs(mappa, exist_ok=True)
    file_loc = f"{mappa}/{fajlnev}"
    with open(file_loc, "wb") as f:
        f.write(kep_bytes)
    return "/" + file_loc


# --- DASHBOARD (kezdőlap) ---

def _lathato_projektek(current_user, working_company_id, db) -> list:
    """A jelenlegi felhasználó számára látható projektek listája - ugyanaz a szerepkör
    szerinti szűrés, mint a projektlistán (Megtekintő/EBK csak a sajátjait, Admin
    a cég összes projektjét látja).
    J-10 (v73): MINDEN MÁS szerepkör (Felhasználó, ügyintéző, szakértő, vizsgáló...) üres listát kap - ugyanaz a szabály,
    mint a részletoldalaknál (_projekt_lathato_e): számukra nincs hozzárendelhető projekt, ezért a statisztikájuk sem
    mutathat semmit. Korábban ők a munkakörnyezet összes projektjét és ellenőrzési statisztikáját látták."""
    if current_user.role == "Megtekintő":
        return list(current_user.ebk_projektek)
    if current_user.role == "EBK":
        return list(current_user.ebk_koordinalt_projektek)
    if current_user.role in ADMIN_SZEREPKOROK:
        return db.query(models.EbkProjekt).filter(models.EbkProjekt.company_id == working_company_id).all()
    return []


@router.get("/ebk/dashboard", response_class=HTMLResponse)
def ebk_dashboard(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """A modul kezdőlapja - ez az egyetlen EBK-oldal, amin a modulváltó ikon megjelenik,
    innen navigál tovább a felhasználó a projektlistára/beállításokra."""
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    projektek = _lathato_projektek(current_user, working_company_id, db)
    projekt_idk = [p.id for p in projektek]

    ellenorzesek = db.query(models.EbkEllenorzes).filter(
        models.EbkEllenorzes.projekt_id.in_(projekt_idk)
    ).all() if projekt_idk else []
    ellenorzes_idk = [e.id for e in ellenorzesek]

    mai_nap = date.today()
    ellenorzesek_e_honap = sum(1 for e in ellenorzesek if e.datum and e.datum.year == mai_nap.year and e.datum.month == mai_nap.month)

    szabalytalansagok = db.query(models.EbkEllenorzesTetel).options(joinedload(models.EbkEllenorzesTetel.tetel)).filter(
        models.EbkEllenorzesTetel.ellenorzes_id.in_(ellenorzes_idk),
        models.EbkEllenorzesTetel.statusz == "SZABALYTALANSAG",
    ).all() if ellenorzes_idk else []

    sulyossag_szamlalo = {"ENYHE": 0, "KOZEPES": 0, "SULYOS": 0}
    for sz in szabalytalansagok:
        if sz.sulyossag in sulyossag_szamlalo:
            sulyossag_szamlalo[sz.sulyossag] += 1

    jelleg_szamlalo = {}
    for sz in szabalytalansagok:
        szoveg = sz.tetel.szoveg if sz.tetel else "Ismeretlen tétel"
        jelleg_szamlalo[szoveg] = jelleg_szamlalo.get(szoveg, 0) + 1
    leggyakoribb_jellegek = sorted(jelleg_szamlalo.items(), key=lambda x: x[1], reverse=True)[:5]

    ellenorzes_map = {e.id: e for e in ellenorzesek}
    legutobbi_ellenorzesek = sorted(ellenorzesek, key=lambda e: e.letrehozva, reverse=True)[:10]

    aktiv_projektek_szama = sum(1 for p in projektek if p.vege is None)

    return templates.TemplateResponse(
        request=request,
        name="ebk_dashboard.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "aktiv_projektek_szama": aktiv_projektek_szama,
            "osszes_projekt_szama": len(projektek),
            "ellenorzesek_szama": len(ellenorzesek),
            "ellenorzesek_e_honap": ellenorzesek_e_honap,
            "szabalytalansagok_szama": len(szabalytalansagok),
            "sulyossag_szamlalo": sulyossag_szamlalo,
            "leggyakoribb_jellegek": leggyakoribb_jellegek,
            "legutobbi_ellenorzesek": legutobbi_ellenorzesek,
            "tobb_modul_van": van_e_tobb_modulja(current_user, db),
        }
    )


@router.get("/ebk/hasznalati-utmutato", response_class=HTMLResponse)
def ebk_hasznalati_utmutato(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """Az EBK modul írott használati útmutatója - cégenként, a rendszeradmin által
    ki/bekapcsolható (lásd security.sugo_engedelyezve), ha a cég nem kéri, az oldal
    egyáltalán nem érhető el."""
    working_company_id = get_working_company_id(current_user, request)
    if not sugo_engedelyezve(working_company_id, db):
        return RedirectResponse(url="/ebk", status_code=303)

    return templates.TemplateResponse(
        request=request,
        name="ebk_hasznalati_utmutato.html",
        context={
            "user": current_user,
            "working_company_id": working_company_id,
            "tobb_modul_van": van_e_tobb_modulja(current_user, db),
        }
    )


@router.get("/uploads/{company_id}/ebk/{ellenorzes_id}/{filename}")
def ebk_fajl_kiszolgalas(
    company_id: int,
    ellenorzes_id: int,
    filename: str,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """Az EBK szabálytalansági fényképek és aláírások hitelesített kiszolgálása - ugyanazt a
    mintát követi, mint a machines.py/tuzvedelem.py már meglévő "secure_file_server"-jei.
    Enélkül a fájlok URL-je (ha a webszerver közvetlenül, statikusan szolgálná ki az uploads/
    mappát) bejelentkezés nélkül, bárki számára elérhető lenne, aki kitalálja/megszerzi az
    elérési utat - ez más cégek szabálytalanság-fotóinak/aláírásainak kiszivárgását jelentené."""
    ellenorzes = db.query(models.EbkEllenorzes).join(models.EbkProjekt).filter(
        models.EbkEllenorzes.id == ellenorzes_id,
        models.EbkProjekt.company_id == company_id,
    ).first()

    if not ellenorzes or not is_company_allowed(current_user, company_id) or not _projekt_lathato_e(current_user, ellenorzes.projekt):
        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Nincs jogosultságod a kért dokumentum eléréséhez!")

    safe_filename = sanitize_filename(filename)
    file_path = f"uploads/{company_id}/ebk/{ellenorzes_id}/{safe_filename}"

    if not os.path.exists(file_path):
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="A keresett fájl nem található a szerveren.")

    return FileResponse(file_path)


# --- PROJEKT LISTA ---

@router.get("/ebk", response_class=HTMLResponse)
def ebk_projekt_lista(
    request: Request,
    kereses: str = "",
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)

    if current_user.role == "Megtekintő":
        # A Megtekintő csak a hozzá rendelt projekt(ek)et látja - se más projektet,
        # se a céges katalógusokat (terulet/alvallalkozo/tetel), semmilyen szerkesztést.
        projektek = sorted(current_user.ebk_projektek, key=lambda p: p.letrehozva, reverse=True)
        if kereses:
            term = kereses.lower()
            projektek = [
                p for p in projektek
                if term in (p.megrendelo_nev or "").lower() or term in (p.kivitelezes_helyszine or "").lower()
            ]
    elif current_user.role == "EBK":
        # Az EBK koordinátor csak a hozzá rendelt projekte(ke)t látja - itt tud helyszíni
        # ellenőrzést indítani, de semmilyen beállítást nem érhet el.
        projektek = sorted(current_user.ebk_koordinalt_projektek, key=lambda p: p.letrehozva, reverse=True)
        if kereses:
            term = kereses.lower()
            projektek = [
                p for p in projektek
                if term in (p.megrendelo_nev or "").lower() or term in (p.kivitelezes_helyszine or "").lower()
            ]
    elif current_user.role not in ADMIN_SZEREPKOROK:
        # J-10 (v73): a többi szerepkörnek (Felhasználó, ügyintéző, szakértő, vizsgáló) nincs hozzárendelt projektje
        # (a részletoldalak is tiltottak számukra), ezért a lista üres - korábban a cég összes projektjét látták.
        projektek = []
    else:
        query = db.query(models.EbkProjekt).filter(models.EbkProjekt.company_id == working_company_id)
        if kereses:
            term = f"%{kereses}%"
            query = query.filter(or_(
                models.EbkProjekt.megrendelo_nev.ilike(term),
                models.EbkProjekt.kivitelezes_helyszine.ilike(term),
            ))
        projektek = query.order_by(models.EbkProjekt.letrehozva.desc()).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_projektek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "projektek": projektek,
            "kereses": kereses,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


# --- CÉGES BEÁLLÍTÁSOK (áttekintő oldal: ügyfelek, projektek, koordinátorok, megtekintők) ---

@router.get("/ebk/beallitasok", response_class=HTMLResponse)
def ebk_ceges_beallitasok(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk", status_code=303)

    projektek = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.company_id == working_company_id
    ).order_by(models.EbkProjekt.letrehozva.desc()).all()

    koordinatorok = db.query(models.User).filter(
        models.User.company_id == working_company_id, models.User.role == "EBK"
    ).order_by(models.User.username).all()
    megtekintok = db.query(models.User).filter(
        models.User.company_id == working_company_id, models.User.role == "Megtekintő"
    ).order_by(models.User.username).all()

    # Minden koordinátor/megtekintő mellé a saját (ehhez a céghez tartozó) projektjei -
    # így a rosztereken egyben látszik, ki melyik projekten dolgozik, cross-project.
    koordinatorok_projektjei = {
        u.id: [p for p in u.ebk_koordinalt_projektek if p.company_id == working_company_id]
        for u in koordinatorok
    }
    megtekintok_projektjei = {
        u.id: [p for p in u.ebk_projektek if p.company_id == working_company_id]
        for u in megtekintok
    }

    return templates.TemplateResponse(
        request=request,
        name="ebk_ceges_beallitasok.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "projektek": projektek,
            "koordinatorok": koordinatorok,
            "megtekintok": megtekintok,
            "koordinatorok_projektjei": koordinatorok_projektjei,
            "megtekintok_projektjei": megtekintok_projektjei,
        }
    )


@router.get("/ebk/uj-projekt", response_class=HTMLResponse)
def uj_projekt_oldal(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    ugyfelek = db.query(models.EbkUgyfel).filter(
        models.EbkUgyfel.company_id == working_company_id, models.EbkUgyfel.aktiv == True
    ).order_by(models.EbkUgyfel.nev).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_uj_projekt.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "ugyfelek": ugyfelek,
            "mai_nap": date.today().isoformat(),
        }
    )


@router.post("/ebk/uj-projekt")
def uj_projekt_mentese(
    request: Request,
    ugyfel_id: int = Form(...),
    kivitelezes_helyszine: str = Form(""),
    kezdete: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk", status_code=303)

    ugyfel = db.query(models.EbkUgyfel).filter(
        models.EbkUgyfel.id == ugyfel_id, models.EbkUgyfel.company_id == working_company_id
    ).first()
    if not ugyfel:
        return RedirectResponse(url="/ebk/uj-projekt", status_code=303)

    # A kiválasztott ügyfél adatait pillanatkép (snapshot) formájában másoljuk a projektbe,
    # hogy az ügyfél későbbi módosítása ne írja át visszamenőleg a már létrehozott projektet.
    projekt = models.EbkProjekt(
        company_id=working_company_id,
        ugyfel_id=ugyfel.id,
        megrendelo_nev=ugyfel.nev,
        megrendelo_cim=ugyfel.cim,
        megrendelo_kapcsolattarto_nev=ugyfel.kapcsolattarto_nev,
        megrendelo_kapcsolattarto_elerhetoseg=ugyfel.kapcsolattarto_elerhetoseg,
        kivitelezes_helyszine=kivitelezes_helyszine or None,
        kezdete=_parse_date(kezdete) or date.today(),
        letrehozo_user_id=current_user.id,
    )
    db.add(projekt)
    db.commit()
    db.refresh(projekt)

    # A projekt indulásakor minden aktív céges ellenőrzési tétel bekerül ide bekapcsolt
    # állapotban - az admin ezt utólag, a projekt adatlapján tételenként kikapcsolhatja.
    aktiv_tetelek = db.query(models.EbkEllenorzesiTetel).filter(
        or_(models.EbkEllenorzesiTetel.company_id == None, models.EbkEllenorzesiTetel.company_id == working_company_id),
        models.EbkEllenorzesiTetel.aktiv == True,
    ).all()
    for tetel in aktiv_tetelek:
        db.add(models.EbkProjektTetel(projekt_id=projekt.id, tetel_id=tetel.id, aktiv=True))
    db.commit()

    return RedirectResponse(url=f"/ebk/projekt/{projekt.id}", status_code=303)


@router.get("/ebk/projekt/{projekt_id}", response_class=HTMLResponse)
def projekt_adatlap(
    projekt_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)
    if not _projekt_lathato_e(current_user, projekt):
        return RedirectResponse(url="/ebk", status_code=303)

    teruletek = _teruletek_a_ceghez(working_company_id, db)
    kivalasztott_terulet_idk = {t.id for t in projekt.teruletek}

    alvallalkozok = db.query(models.EbkAlvallalkozo).filter(
        models.EbkAlvallalkozo.company_id == working_company_id, models.EbkAlvallalkozo.aktiv == True
    ).all()
    tevekenysegek = db.query(models.EbkTevekenyseg).filter(
        models.EbkTevekenyseg.company_id == working_company_id, models.EbkTevekenyseg.aktiv == True
    ).all()

    ellenorzesek = sorted(projekt.ellenorzesek, key=lambda e: e.letrehozva, reverse=True)
    van_e_ellenorizheto_tetel = any(pt.aktiv for pt in projekt.projekt_tetelek)

    lehet_adminisztralni = _lehet_adminisztralni(current_user, working_company_id, db)

    hozzarendelheto_megtekintok = []
    hozzarendelheto_koordinatorok = []
    if lehet_adminisztralni:
        mar_hozzarendelt_megtekinto_idk = {u.id for u in projekt.megrendelo_felhasznalok}
        hozzarendelheto_megtekintok = [
            u for u in db.query(models.User).filter(
                models.User.company_id == working_company_id, models.User.role == "Megtekintő"
            ).all() if u.id not in mar_hozzarendelt_megtekinto_idk
        ]
        mar_hozzarendelt_koordinator_idk = {u.id for u in projekt.koordinator_felhasznalok}
        hozzarendelheto_koordinatorok = [
            u for u in db.query(models.User).filter(
                models.User.company_id == working_company_id, models.User.role == "EBK"
            ).all() if u.id not in mar_hozzarendelt_koordinator_idk
        ]

    return templates.TemplateResponse(
        request=request,
        name="ebk_projekt_adatlap.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "projekt": projekt,
            "hozzarendelheto_megtekintok": hozzarendelheto_megtekintok,
            "hozzarendelheto_koordinatorok": hozzarendelheto_koordinatorok,
            "teruletek": teruletek,
            "kivalasztott_terulet_idk": kivalasztott_terulet_idk,
            "alvallalkozok": alvallalkozok,
            "tevekenysegek": tevekenysegek,
            "ellenorzesek": ellenorzesek,
            "indithato_ellenorzes": bool(projekt.teruletek) and van_e_ellenorizheto_tetel,
            "lehet_adminisztralni": lehet_adminisztralni,
            "lehet_ellenorizni": _lehet_ellenorizni(current_user, working_company_id, db, projekt),
            "szerkesztheto": lehet_adminisztralni,
        }
    )


@router.post("/ebk/projekt/{projekt_id}/szerkesztes")
def projekt_szerkesztese(
    projekt_id: int,
    request: Request,
    megrendelo_nev: str = Form(...),
    megrendelo_cim: str = Form(""),
    megrendelo_kapcsolattarto_nev: str = Form(""),
    megrendelo_kapcsolattarto_elerhetoseg: str = Form(""),
    kivitelezes_helyszine: str = Form(""),
    kezdete: str = Form(""),
    vege: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if projekt:
        projekt.megrendelo_nev = megrendelo_nev
        projekt.megrendelo_cim = megrendelo_cim or None
        projekt.megrendelo_kapcsolattarto_nev = megrendelo_kapcsolattarto_nev or None
        projekt.megrendelo_kapcsolattarto_elerhetoseg = megrendelo_kapcsolattarto_elerhetoseg or None
        projekt.kivitelezes_helyszine = kivitelezes_helyszine or None
        projekt.kezdete = _parse_date(kezdete) or projekt.kezdete
        projekt.vege = _parse_date(vege)
        db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.post("/ebk/projekt/{projekt_id}/teruletek")
async def projekt_teruletek_mentese(
    projekt_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)

    form_data = await request.form()
    try:
        kivalasztott_idk = [int(v) for v in form_data.getlist("terulet_id")]
    except (TypeError, ValueError):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    teruletek = db.query(models.EbkTerulet).filter(
        models.EbkTerulet.id.in_(kivalasztott_idk), models.EbkTerulet.company_id == working_company_id
    ).all() if kivalasztott_idk else []
    projekt.teruletek = teruletek
    db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.post("/ebk/projekt/{projekt_id}/alvallalkozo-hozzaadasa")
async def projekt_alvallalkozo_hozzaadasa(
    projekt_id: int,
    request: Request,
    alvallalkozo_id: int = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    alvallalkozo = db.query(models.EbkAlvallalkozo).filter(
        models.EbkAlvallalkozo.id == alvallalkozo_id, models.EbkAlvallalkozo.company_id == working_company_id,
    ).first()
    if not projekt or not alvallalkozo:
        return RedirectResponse(url="/ebk", status_code=303)

    mar_hozzarendelve = db.query(models.EbkProjektAlvallalkozo).filter(
        models.EbkProjektAlvallalkozo.projekt_id == projekt_id,
        models.EbkProjektAlvallalkozo.alvallalkozo_id == alvallalkozo_id,
    ).first()
    if mar_hozzarendelve:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    form_data = await request.form()
    try:
        tevekenyseg_idk = [int(v) for v in form_data.getlist("tevekenyseg_id")]
    except (TypeError, ValueError):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    projekt_alvallalkozo = models.EbkProjektAlvallalkozo(projekt_id=projekt_id, alvallalkozo_id=alvallalkozo_id)
    if tevekenyseg_idk:
        projekt_alvallalkozo.tevekenysegek = db.query(models.EbkTevekenyseg).filter(
            models.EbkTevekenyseg.id.in_(tevekenyseg_idk), models.EbkTevekenyseg.company_id == working_company_id
        ).all()
    db.add(projekt_alvallalkozo)
    db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.delete("/ebk/projekt/{projekt_id}/alvallalkozo/{projekt_alvallalkozo_id}")
def projekt_alvallalkozo_torlese(
    projekt_id: int,
    projekt_alvallalkozo_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    pa = db.query(models.EbkProjektAlvallalkozo).join(models.EbkProjekt).filter(
        models.EbkProjektAlvallalkozo.id == projekt_alvallalkozo_id,
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id,
    ).first()
    if pa:
        db.delete(pa)
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


@router.post("/ebk/projekt/{projekt_id}/tetel/{projekt_tetel_id}/valtas")
def projekt_tetel_valtasa(
    projekt_id: int,
    projekt_tetel_id: int,
    request: Request,
    aktiv: 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": "Csak Admin!"})

    working_company_id = get_working_company_id(current_user, request)
    # J-09 (v65): a csak_olvasas fiók sem kapcsolhatja a projekt tételeit
    tiltas = irasi_tiltas_oka(current_user, working_company_id, db)
    if tiltas:
        return JSONResponse(status_code=403, content={"message": IRASI_TILTAS_UZENETEK[tiltas]})
    pt = db.query(models.EbkProjektTetel).join(models.EbkProjekt).filter(
        models.EbkProjektTetel.id == projekt_tetel_id,
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id,
    ).first()
    if not pt:
        return JSONResponse(status_code=404, content={"message": "Tétel nem található!"})
    pt.aktiv = (aktiv == "true")
    db.commit()
    return JSONResponse(status_code=200, content={"message": "Mentve."})


# --- MEGRENDELŐI HOZZÁFÉRÉS (korlátozott, csak-olvasás fiók egy adott projekthez) ---

@router.post("/ebk/projekt/{projekt_id}/megrendelo-uj-felhasznalo")
def megrendelo_uj_felhasznalo(
    projekt_id: int,
    request: Request,
    username: str = Form(...),
    email: 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=f"/ebk/projekt/{projekt_id}", status_code=303)

    working_company_id = get_working_company_id(current_user, request)
    if not is_company_active(working_company_id, db):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=inaktiv_ceg", status_code=303)

    if current_user.csak_olvasas:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=csak_olvasas", status_code=303)

    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)

    if db.query(models.User).filter(models.User.email == email).first():
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=email_foglalt", status_code=303)

    if not aktivalas_utils.email_ervenyes_e(email):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=email_ervenytelen", status_code=303)

    megrendelo_user = models.User(
        username=username, email=email, hashed_password=aktivalas_utils.jelszo_nelkuli_hash(),
        role="Megtekintő", company_id=working_company_id, hozzaferes_szint="CEG", csak_olvasas=True,
    )
    # A Megtekintő (a megbízó/megrendelő képviselője) kizárólag az EBK modult használja -
    # automatikusan megkapja, hogy ne akadjon el a modulválasztó oldalon (a modul-
    # hozzárendelést egyébként a rendszeradmin kezeli, de ez a szerepkör csak ehhez az
    # egy modulhoz köthető értelmesen).
    ebk_modul = db.query(models.Modul).filter(models.Modul.kod == "EBK").first()
    if ebk_modul:
        megrendelo_user.sajat_modulok.append(ebk_modul)

    db.add(megrendelo_user)
    aktivalas_utils.meghivas(db, megrendelo_user, current_user)   # aktiváló levél (E szelet)
    db.commit()
    db.refresh(megrendelo_user)

    projekt.megrendelo_felhasznalok.append(megrendelo_user)
    db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.post("/ebk/projekt/{projekt_id}/megrendelo-hozzarendeles")
def megrendelo_hozzarendeles(
    projekt_id: int,
    request: Request,
    user_id: int = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ["Admin"]:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    working_company_id = get_working_company_id(current_user, request)
    # J-09 (v65): inaktív cégben / csak_olvasas fiókkal nincs hozzárendelés (a hiba paramétert az ebk_projekt oldal már kezeli)
    tiltas = irasi_tiltas_oka(current_user, working_company_id, db)
    if tiltas:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba={tiltas}", status_code=303)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    megrendelo_user = db.query(models.User).filter(
        models.User.id == user_id, models.User.company_id == working_company_id, models.User.role == "Megtekintő"
    ).first()
    if not projekt or not megrendelo_user:
        return RedirectResponse(url="/ebk", status_code=303)

    if megrendelo_user not in projekt.megrendelo_felhasznalok:
        projekt.megrendelo_felhasznalok.append(megrendelo_user)
        db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.delete("/ebk/projekt/{projekt_id}/megrendelo/{user_id}")
def megrendelo_eltavolitasa(
    projekt_id: int,
    user_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    megrendelo_user = db.query(models.User).filter(models.User.id == user_id).first()
    if projekt and megrendelo_user and megrendelo_user in projekt.megrendelo_felhasznalok:
        projekt.megrendelo_felhasznalok.remove(megrendelo_user)
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Hozzáférés eltávolítva."})


# --- EBK KOORDINÁTOR HOZZÁRENDELÉS (helyszíni ellenőrzésre jogosult, projekthez kötött fiók) ---

@router.post("/ebk/projekt/{projekt_id}/koordinator-uj-felhasznalo")
def koordinator_uj_felhasznalo(
    projekt_id: int,
    request: Request,
    username: str = Form(...),
    email: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    working_company_id = get_working_company_id(current_user, request)
    if not is_company_active(working_company_id, db):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=inaktiv_ceg", status_code=303)

    if current_user.csak_olvasas:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=csak_olvasas", status_code=303)

    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)

    if db.query(models.User).filter(models.User.email == email).first():
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=email_foglalt", status_code=303)

    if not aktivalas_utils.email_ervenyes_e(email):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba=email_ervenytelen", status_code=303)

    koordinator_user = models.User(
        username=username, email=email, hashed_password=aktivalas_utils.jelszo_nelkuli_hash(),
        role="EBK", company_id=working_company_id, hozzaferes_szint="CEG",
    )
    ebk_modul = db.query(models.Modul).filter(models.Modul.kod == "EBK").first()
    if ebk_modul:
        koordinator_user.sajat_modulok.append(ebk_modul)

    db.add(koordinator_user)
    aktivalas_utils.meghivas(db, koordinator_user, current_user)   # aktiváló levél (E szelet)
    db.commit()
    db.refresh(koordinator_user)

    projekt.koordinator_felhasznalok.append(koordinator_user)
    db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.post("/ebk/projekt/{projekt_id}/koordinator-hozzarendeles")
def koordinator_hozzarendeles(
    projekt_id: int,
    request: Request,
    user_id: int = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    working_company_id = get_working_company_id(current_user, request)
    # J-09 (v65): inaktív cégben / csak_olvasas fiókkal nincs hozzárendelés (a hiba paramétert az ebk_projekt oldal már kezeli)
    tiltas = irasi_tiltas_oka(current_user, working_company_id, db)
    if tiltas:
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}?hiba={tiltas}", status_code=303)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    koordinator_user = db.query(models.User).filter(
        models.User.id == user_id, models.User.company_id == working_company_id, models.User.role == "EBK"
    ).first()
    if not projekt or not koordinator_user:
        return RedirectResponse(url="/ebk", status_code=303)

    if koordinator_user not in projekt.koordinator_felhasznalok:
        projekt.koordinator_felhasznalok.append(koordinator_user)
        db.commit()
    return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)


@router.delete("/ebk/projekt/{projekt_id}/koordinator/{user_id}")
def koordinator_eltavolitasa(
    projekt_id: int,
    user_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    koordinator_user = db.query(models.User).filter(models.User.id == user_id).first()
    if projekt and koordinator_user and koordinator_user in projekt.koordinator_felhasznalok:
        projekt.koordinator_felhasznalok.remove(koordinator_user)
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Hozzáférés eltávolítva."})


# --- TERÜLETEK / ÉPÜLETEK / SZINTEK (céges katalógus) ---

@router.get("/ebk/teruletek", response_class=HTMLResponse)
def ebk_teruletek_lista(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    teruletek = _teruletek_a_ceghez(working_company_id, db)

    epuletek_terulet_szerint = {}
    szintek_epulet_szerint = {}
    if teruletek:
        epuletek = db.query(models.EbkEpulet).filter(
            models.EbkEpulet.terulet_id.in_([t.id for t in teruletek]), models.EbkEpulet.aktiv == True
        ).all()
        for e in epuletek:
            epuletek_terulet_szerint.setdefault(e.terulet_id, []).append(e)

        if epuletek:
            szintek = db.query(models.EbkSzint).filter(
                models.EbkSzint.epulet_id.in_([e.id for e in epuletek]), models.EbkSzint.aktiv == True
            ).all()
            for sz in szintek:
                szintek_epulet_szerint.setdefault(sz.epulet_id, []).append(sz)

    return templates.TemplateResponse(
        request=request,
        name="ebk_teruletek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "teruletek": teruletek,
            "epuletek_terulet_szerint": epuletek_terulet_szerint,
            "szintek_epulet_szerint": szintek_epulet_szerint,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


@router.post("/ebk/uj-terulet")
def uj_terulet_mentese(
    request: Request,
    nev: str = Form(...),
    cim: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    db.add(models.EbkTerulet(company_id=working_company_id, nev=nev, cim=cim or None))
    db.commit()
    return RedirectResponse(url="/ebk/teruletek", status_code=303)


@router.post("/ebk/terulet/{terulet_id}/szerkesztes")
def terulet_szerkesztese(
    terulet_id: int,
    request: Request,
    nev: str = Form(...),
    cim: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    terulet = db.query(models.EbkTerulet).filter(
        models.EbkTerulet.id == terulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if terulet:
        terulet.nev = nev
        terulet.cim = cim or None
        db.commit()
    return RedirectResponse(url="/ebk/teruletek", status_code=303)


@router.delete("/ebk/terulet/{terulet_id}")
def terulet_torlese(
    terulet_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    terulet = db.query(models.EbkTerulet).filter(
        models.EbkTerulet.id == terulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if terulet:
        terulet.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


@router.post("/ebk/uj-epulet")
def uj_epulet_mentese(
    request: Request,
    terulet_id: int = Form(...),
    nev: str = Form(...),
    leiras: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    terulet = db.query(models.EbkTerulet).filter(
        models.EbkTerulet.id == terulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if not terulet:
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    db.add(models.EbkEpulet(terulet_id=terulet_id, nev=nev, leiras=leiras or None))
    db.commit()
    return RedirectResponse(url="/ebk/teruletek", status_code=303)


@router.post("/ebk/epulet/{epulet_id}/szerkesztes")
def epulet_szerkesztese(
    epulet_id: int,
    request: Request,
    nev: str = Form(...),
    leiras: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    epulet = db.query(models.EbkEpulet).join(models.EbkTerulet).filter(
        models.EbkEpulet.id == epulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if epulet:
        epulet.nev = nev
        epulet.leiras = leiras or None
        db.commit()
    return RedirectResponse(url="/ebk/teruletek", status_code=303)


@router.delete("/ebk/epulet/{epulet_id}")
def epulet_torlese(
    epulet_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    epulet = db.query(models.EbkEpulet).join(models.EbkTerulet).filter(
        models.EbkEpulet.id == epulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if epulet:
        epulet.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


@router.post("/ebk/uj-szint")
def uj_szint_mentese(
    request: Request,
    epulet_id: int = Form(...),
    nev: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    epulet = db.query(models.EbkEpulet).join(models.EbkTerulet).filter(
        models.EbkEpulet.id == epulet_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if not epulet:
        return RedirectResponse(url="/ebk/teruletek", status_code=303)

    db.add(models.EbkSzint(epulet_id=epulet_id, nev=nev))
    db.commit()
    return RedirectResponse(url="/ebk/teruletek", status_code=303)


@router.delete("/ebk/szint/{szint_id}")
def szint_torlese(
    szint_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    szint = db.query(models.EbkSzint).join(models.EbkEpulet).join(models.EbkTerulet).filter(
        models.EbkSzint.id == szint_id, models.EbkTerulet.company_id == working_company_id
    ).first()
    if szint:
        szint.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


# --- ALVÁLLALKOZÓK (a bejelentkezett felhasználó saját, privát partnerlistája) ---

@router.get("/ebk/alvallalkozok", response_class=HTMLResponse)
def ebk_alvallalkozok_lista(
    request: Request,
    kereses: str = "",
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    query = db.query(models.EbkAlvallalkozo).filter(
        models.EbkAlvallalkozo.company_id == working_company_id, models.EbkAlvallalkozo.aktiv == True,
    )
    if kereses:
        term = f"%{kereses}%"
        query = query.filter(or_(
            models.EbkAlvallalkozo.nev.ilike(term),
            models.EbkAlvallalkozo.felelos_vezeto.ilike(term),
        ))
    alvallalkozok = query.order_by(models.EbkAlvallalkozo.nev).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_alvallalkozok.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "alvallalkozok": alvallalkozok,
            "kereses": kereses,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


@router.post("/ebk/uj-alvallalkozo")
def uj_alvallalkozo_mentese(
    request: Request,
    nev: str = Form(...),
    felelos_vezeto: str = Form(""),
    kapcsolattarto_nev: str = Form(""),
    kapcsolattarto_elerhetoseg: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/alvallalkozok", status_code=303)

    db.add(models.EbkAlvallalkozo(
        company_id=working_company_id, nev=nev, felelos_vezeto=felelos_vezeto or None,
        kapcsolattarto_nev=kapcsolattarto_nev or None, kapcsolattarto_elerhetoseg=kapcsolattarto_elerhetoseg or None,
    ))
    db.commit()
    return RedirectResponse(url="/ebk/alvallalkozok", status_code=303)


@router.post("/ebk/alvallalkozo/{alvallalkozo_id}/szerkesztes")
def alvallalkozo_szerkesztese(
    alvallalkozo_id: int,
    request: Request,
    nev: str = Form(...),
    felelos_vezeto: str = Form(""),
    kapcsolattarto_nev: str = Form(""),
    kapcsolattarto_elerhetoseg: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/alvallalkozok", status_code=303)

    alvallalkozo = db.query(models.EbkAlvallalkozo).filter(
        models.EbkAlvallalkozo.id == alvallalkozo_id, models.EbkAlvallalkozo.company_id == working_company_id,
    ).first()
    if alvallalkozo:
        alvallalkozo.nev = nev
        alvallalkozo.felelos_vezeto = felelos_vezeto or None
        alvallalkozo.kapcsolattarto_nev = kapcsolattarto_nev or None
        alvallalkozo.kapcsolattarto_elerhetoseg = kapcsolattarto_elerhetoseg or None
        db.commit()
    return RedirectResponse(url="/ebk/alvallalkozok", status_code=303)


@router.delete("/ebk/alvallalkozo/{alvallalkozo_id}")
def alvallalkozo_torlese(
    alvallalkozo_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    alvallalkozo = db.query(models.EbkAlvallalkozo).filter(
        models.EbkAlvallalkozo.id == alvallalkozo_id, models.EbkAlvallalkozo.company_id == working_company_id,
    ).first()
    if alvallalkozo:
        alvallalkozo.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


# --- ÜGYFELEK (céges katalógus - a projekt létrehozásakor ebből választható a megbízó) ---

@router.get("/ebk/ugyfelek", response_class=HTMLResponse)
def ebk_ugyfelek_lista(
    request: Request,
    kereses: str = "",
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    query = db.query(models.EbkUgyfel).filter(
        models.EbkUgyfel.company_id == working_company_id, models.EbkUgyfel.aktiv == True,
    )
    if kereses:
        term = f"%{kereses}%"
        query = query.filter(models.EbkUgyfel.nev.ilike(term))
    ugyfelek = query.order_by(models.EbkUgyfel.nev).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_ugyfelek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "ugyfelek": ugyfelek,
            "kereses": kereses,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


@router.post("/ebk/uj-ugyfel")
def uj_ugyfel_mentese(
    request: Request,
    nev: str = Form(...),
    cim: str = Form(""),
    kapcsolattarto_nev: str = Form(""),
    kapcsolattarto_elerhetoseg: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/ugyfelek", status_code=303)

    db.add(models.EbkUgyfel(
        company_id=working_company_id, nev=nev, cim=cim or None,
        kapcsolattarto_nev=kapcsolattarto_nev or None, kapcsolattarto_elerhetoseg=kapcsolattarto_elerhetoseg or None,
    ))
    db.commit()
    return RedirectResponse(url="/ebk/ugyfelek", status_code=303)


@router.post("/ebk/ugyfel/{ugyfel_id}/szerkesztes")
def ugyfel_szerkesztese(
    ugyfel_id: int,
    request: Request,
    nev: str = Form(...),
    cim: str = Form(""),
    kapcsolattarto_nev: str = Form(""),
    kapcsolattarto_elerhetoseg: str = Form(""),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/ugyfelek", status_code=303)

    ugyfel = db.query(models.EbkUgyfel).filter(
        models.EbkUgyfel.id == ugyfel_id, models.EbkUgyfel.company_id == working_company_id,
    ).first()
    if ugyfel:
        ugyfel.nev = nev
        ugyfel.cim = cim or None
        ugyfel.kapcsolattarto_nev = kapcsolattarto_nev or None
        ugyfel.kapcsolattarto_elerhetoseg = kapcsolattarto_elerhetoseg or None
        db.commit()
    return RedirectResponse(url="/ebk/ugyfelek", status_code=303)


@router.delete("/ebk/ugyfel/{ugyfel_id}")
def ugyfel_torlese(
    ugyfel_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    ugyfel = db.query(models.EbkUgyfel).filter(
        models.EbkUgyfel.id == ugyfel_id, models.EbkUgyfel.company_id == working_company_id,
    ).first()
    if ugyfel:
        ugyfel.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


# --- TEVÉKENYSÉGEK (céges katalógus) ---

@router.get("/ebk/tevekenysegek", response_class=HTMLResponse)
def ebk_tevekenysegek_lista(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    tevekenysegek = db.query(models.EbkTevekenyseg).filter(
        models.EbkTevekenyseg.company_id == working_company_id, models.EbkTevekenyseg.aktiv == True
    ).order_by(models.EbkTevekenyseg.nev).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_tevekenysegek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "tevekenysegek": tevekenysegek,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


@router.post("/ebk/uj-tevekenyseg")
def uj_tevekenyseg_mentese(
    request: Request,
    nev: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/tevekenysegek", status_code=303)

    db.add(models.EbkTevekenyseg(company_id=working_company_id, nev=nev))
    db.commit()
    return RedirectResponse(url="/ebk/tevekenysegek", status_code=303)


@router.delete("/ebk/tevekenyseg/{tevekenyseg_id}")
def tevekenyseg_torlese(
    tevekenyseg_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    tevekenyseg = db.query(models.EbkTevekenyseg).filter(
        models.EbkTevekenyseg.id == tevekenyseg_id, models.EbkTevekenyseg.company_id == working_company_id
    ).first()
    if tevekenyseg:
        tevekenyseg.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


# --- ELLENŐRZÉSI TÉTELEK (céges sablon-katalógus) ---

@router.get("/ebk/ellenorzesi-tetelek", response_class=HTMLResponse)
def ebk_tetelek_lista(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in ADMIN_SZEREPKOROK:
        return RedirectResponse(url="/ebk", status_code=303)

    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    tetelek = db.query(models.EbkEllenorzesiTetel).filter(
        or_(models.EbkEllenorzesiTetel.company_id == None, models.EbkEllenorzesiTetel.company_id == working_company_id),
        models.EbkEllenorzesiTetel.aktiv == True,
    ).order_by(models.EbkEllenorzesiTetel.tipus, models.EbkEllenorzesiTetel.szoveg).all()

    return templates.TemplateResponse(
        request=request,
        name="ebk_tetelek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "tetelek": tetelek,
            "szerkesztheto": _lehet_adminisztralni(current_user, working_company_id, db),
        }
    )


@router.post("/ebk/uj-tetel")
def uj_tetel_mentese(
    request: Request,
    szoveg: str = Form(...),
    kotelezo: str = Form(""),
    tipus: str = Form("NAPI"),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/ellenorzesi-tetelek", status_code=303)

    db.add(models.EbkEllenorzesiTetel(
        company_id=working_company_id, szoveg=szoveg,
        kotelezo=(kotelezo == "on"), tipus=tipus if tipus in ("ATFOGO", "NAPI") else "NAPI",
    ))
    db.commit()
    return RedirectResponse(url="/ebk/ellenorzesi-tetelek", status_code=303)


@router.post("/ebk/tetel/{tetel_id}/szerkesztes")
def tetel_szerkesztese(
    tetel_id: int,
    request: Request,
    szoveg: str = Form(...),
    kotelezo: str = Form(""),
    tipus: str = Form("NAPI"),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    if not _lehet_adminisztralni(current_user, working_company_id, db):
        return RedirectResponse(url="/ebk/ellenorzesi-tetelek", status_code=303)

    tetel = db.query(models.EbkEllenorzesiTetel).filter(
        models.EbkEllenorzesiTetel.id == tetel_id, models.EbkEllenorzesiTetel.company_id == working_company_id
    ).first()
    if tetel:
        tetel.szoveg = szoveg
        tetel.kotelezo = (kotelezo == "on")
        tetel.tipus = tipus if tipus in ("ATFOGO", "NAPI") else "NAPI"
        db.commit()
    return RedirectResponse(url="/ebk/ellenorzesi-tetelek", status_code=303)


@router.delete("/ebk/tetel/{tetel_id}")
def tetel_torlese(
    tetel_id: int,
    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": "Csak Admin!"})

    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ú, törlés nem lehetséges!"})

    if current_user.csak_olvasas:
        return JSONResponse(status_code=403, content={"message": "Csak megtekintési jogosultsággal rendelkezel, szerkesztés nem lehetséges!"})
    tetel = db.query(models.EbkEllenorzesiTetel).filter(
        models.EbkEllenorzesiTetel.id == tetel_id, models.EbkEllenorzesiTetel.company_id == working_company_id
    ).first()
    if tetel:
        tetel.aktiv = False
        db.commit()
    return JSONResponse(status_code=200, content={"message": "Törölve."})


# --- TEREPI ELLENŐRZÉS (helyszíni bejárás) ---

@router.get("/ebk/projekt/{projekt_id}/uj-ellenorzes", response_class=HTMLResponse)
def uj_ellenorzes_oldal(
    projekt_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)
    if not _lehet_ellenorizni(current_user, working_company_id, db, projekt):
        return RedirectResponse(url=f"/ebk/projekt/{projekt_id}", status_code=303)

    napi_tetelek = [
        pt for pt in projekt.projekt_tetelek if pt.aktiv and pt.tetel.tipus == "NAPI"
    ]
    # Az automatikusan összesítő "engedély nélküli munkavégzés" tétel mindig a lista végén
    # jelenjen meg (stabil rendezés - a többi tétel egymáshoz képesti sorrendje nem változik).
    napi_tetelek.sort(key=lambda pt: bool(pt.tetel.auto_engedely_osszesito))
    atfogo_tetelek = [
        pt for pt in projekt.projekt_tetelek if pt.aktiv and pt.tetel.tipus == "ATFOGO"
    ]

    alvallalkozok_json = safe_json_for_script([
        {
            # Az EbkEllenorzesTetel.alvallalkozo_id a céges katalógusra (EbkAlvallalkozo.id)
            # mutat, ezért itt is azt kell küldeni - NEM a projekt-hozzárendelés (EbkProjektAlvallalkozo)
            # saját id-ját, ami egy másik, függetlenül növekvő sorozat, és idegenkulcs-hibát okozott.
            "id": pa.alvallalkozo_id, "nev": pa.alvallalkozo.nev,
            "tevekenysegek": [{"id": tev.id, "nev": tev.nev} for tev in pa.tevekenysegek],
        }
        for pa in projekt.projekt_alvallalkozok
    ])

    return templates.TemplateResponse(
        request=request,
        name="ebk_uj_ellenorzes.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "projekt": projekt,
            "teruletek": projekt.teruletek,
            "epuletek_json": _epuletek_json_projekthez(projekt, db),
            "alvallalkozok_json": alvallalkozok_json,
            "napi_tetelek": napi_tetelek,
            "atfogo_tetelek": atfogo_tetelek,
            "sulyossagok": SULYOSSAGOK,
            "mai_nap": date.today().isoformat(),
            "celellenorzes_opciok": _celellenorzes_opciok(projekt.projekt_tetelek),
        }
    )


@router.post("/ebk/projekt/{projekt_id}/ellenorzes")
async def ellenorzes_mentese(
    projekt_id: int,
    request: Request,
    terulet_id: int = Form(...),
    epulet_id: str = Form(""),
    szint_id: str = Form(""),
    osszes_szint: str = Form(""),
    celellenorzes: str = Form(""),
    datum: str = Form(""),
    mindenrendben: str = Form(""),
    tetel_eredmenyek_json: str = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt or terulet_id not in [t.id for t in projekt.teruletek]:
        return JSONResponse(status_code=404, content={"message": "Projekt vagy terület nem található!"})
    if not _lehet_ellenorizni(current_user, working_company_id, db, projekt):
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod ehhez a projekthez!"})

    try:
        tetel_eredmenyek = json.loads(tetel_eredmenyek_json)
    except Exception:
        return JSONResponse(status_code=400, content={"message": "Hibás tétel-adat formátum!"})

    # J-13 (v70): a hivatkozott azonosítók ellenőrzése MENTÉS ELŐTT (hibánál 400, semmi sem keletkezik)
    hivatkozas_hiba = ellenorzes_hivatkozasok_ellenorzese(
        db, projekt, working_company_id, terulet_id, epulet_id, szint_id, (osszes_szint == "true"), tetel_eredmenyek)
    if hivatkozas_hiba:
        return JSONResponse(status_code=400, content={"message": hivatkozas_hiba})

    form_data = await request.form()

    try:
        van_osszes_szint = (osszes_szint == "true")
        ellenorzes = models.EbkEllenorzes(
            projekt_id=projekt_id,
            terulet_id=terulet_id,
            epulet_id=int(epulet_id) if epulet_id else None,
            # Ha a bejárás az épület összes szintjére kiterjedt, itt nem rögzítünk egyetlen
            # szintet - a szint ilyenkor szabálytalanságonként külön van megadva.
            szint_id=int(szint_id) if (szint_id and not van_osszes_szint) else None,
            osszes_szint=van_osszes_szint,
            celellenorzes=celellenorzes or None,
            datum=_parse_date(datum) or date.today(),
            ellenorzo_user_id=current_user.id,
            mindenrendben=(mindenrendben == "true"),
        )
        db.add(ellenorzes)
        db.flush()

        mappa = f"uploads/{working_company_id}/ebk/{ellenorzes.id}"

        # A session autoflush=False (lásd database.py), így egy ugyanebben a mentésben korábban
        # hozzáadott EbkProjektAlvallalkozo még nem látszana a lenti "mar_hozzarendelve" lekérdezésnek -
        # emiatt ha ugyanaz az engedély nélkül dolgozó cég két külön szabálytalanságnál is szerepel
        # (pl. "+ Újabb szabálytalanság"-gal felvéve), duplán rendelődött volna a projekthez.
        ebben_a_mentesben_hozzarendelt_alvallalkozo_idk = set()

        for sor_idx, sor in enumerate(tetel_eredmenyek):
            tetel_id = sor.get("tetel_id")
            statusz = sor.get("statusz")

            eredmeny = models.EbkEllenorzesTetel(
                ellenorzes_id=ellenorzes.id, tetel_id=tetel_id, statusz=statusz,
            )

            if statusz == "SZABALYTALANSAG":
                eredmeny.alvallalkozo_id = sor.get("alvallalkozo_id") or None
                eredmeny.tevekenyseg_id = sor.get("tevekenyseg_id") or None
                if van_osszes_szint:
                    eredmeny.szint_id = sor.get("szint_id") or None
                eredmeny.munkavallalo_neve = sor.get("munkavallalo_neve") or None
                eredmeny.sulyossag = sor.get("sulyossag") if sor.get("sulyossag") in SULYOSSAGOK else None
                eredmeny.leiras = sor.get("leiras") or None
                eredmeny.elismerve = sor.get("elismerve")
                eredmeny.nem_elismeres_indoklas = sor.get("nem_elismeres_indoklas") or None
                eredmeny.munkavegzesi_engedely_szam = sor.get("munkavegzesi_engedely_szam") or None
                eredmeny.engedely_nelkul = bool(sor.get("engedely_nelkul"))
                eredmeny.engedely_ceg_nev = sor.get("engedely_ceg_nev") or None
                eredmeny.engedely_ceg_szekhely = sor.get("engedely_ceg_szekhely") or None
                eredmeny.engedely_felelos_vezeto = sor.get("engedely_felelos_vezeto") or None
                eredmeny.engedely_helyi_vezeto = sor.get("engedely_helyi_vezeto") or None
                eredmeny.engedely_megrendelo_neve = sor.get("engedely_megrendelo_neve") or None
                eredmeny.engedely_tevekenyseg = sor.get("engedely_tevekenyseg") or None

                # Egy tételnek több (a "+ Újabb szabálytalanság" felületi gombbal hozzáadott) esete
                # is lehet ugyanabban a mentésben - a fényképet ezért a soron belül egyedi
                # sorszám (nem a tetel_id) azonosítja, különben két azonos tételű eset fényképe
                # ütközne (form_data.get ugyanazt a kulcsot adná vissza mindkettőnek).
                fenykep = form_data.get(f"fenykep_{sor_idx}")
                if fenykep is not None and getattr(fenykep, "filename", "") != "":
                    if not is_safe_extension(fenykep.filename):
                        raise ValueError("Nem engedélyezett fájlformátum a fényképnél!")
                    safe_filename = sanitize_filename(fenykep.filename).rsplit(".", 1)[0] + ".jpg"
                    kep_bytes = tomorit_kepet(await fenykep.read())
                    if kep_bytes is None:
                        raise ValueError("A feltöltött fájl nem érvényes kép!")
                    os.makedirs(mappa, exist_ok=True)
                    file_loc = f"{mappa}/{datetime.now().strftime('%Y%m%d%H%M%S')}_{sor_idx}_{safe_filename}"
                    with open(file_loc, "wb") as f:
                        f.write(kep_bytes)
                    eredmeny.fenykep_path = "/" + file_loc

                alairas_datauri = sor.get("alairas_datauri")
                if alairas_datauri:
                    eredmeny.alairas_path = _mentse_base64_kepet(
                        alairas_datauri, mappa, f"alairas_{sor_idx}_{datetime.now().strftime('%Y%m%d%H%M%S')}.png"
                    )

                # Az engedély nélkül dolgozó céget automatikusan felvesszük (ha még nincs a
                # katalógusban) és hozzárendeljük a projekt alvállalkozói közé - így legközelebb
                # már a szokásos Alvállalkozó-választóból is kiválasztható, nem kell újra
                # begépelni a szabad szöveges mezőket.
                if eredmeny.engedely_nelkul and eredmeny.engedely_ceg_nev:
                    ceg_nev = eredmeny.engedely_ceg_nev.strip()
                    alvallalkozo = db.query(models.EbkAlvallalkozo).filter(
                        models.EbkAlvallalkozo.company_id == working_company_id,
                        func.lower(models.EbkAlvallalkozo.nev) == ceg_nev.lower(),
                    ).first()
                    if not alvallalkozo:
                        alvallalkozo = models.EbkAlvallalkozo(
                            company_id=working_company_id, nev=ceg_nev,
                            felelos_vezeto=eredmeny.engedely_felelos_vezeto,
                        )
                        db.add(alvallalkozo)
                        db.flush()
                    if alvallalkozo.id not in ebben_a_mentesben_hozzarendelt_alvallalkozo_idk:
                        mar_hozzarendelve = db.query(models.EbkProjektAlvallalkozo).filter(
                            models.EbkProjektAlvallalkozo.projekt_id == projekt_id,
                            models.EbkProjektAlvallalkozo.alvallalkozo_id == alvallalkozo.id,
                        ).first()
                        if not mar_hozzarendelve:
                            db.add(models.EbkProjektAlvallalkozo(projekt_id=projekt_id, alvallalkozo_id=alvallalkozo.id))
                        ebben_a_mentesben_hozzarendelt_alvallalkozo_idk.add(alvallalkozo.id)

            db.add(eredmeny)

        db.commit()
    except Exception as e:
        db.rollback()
        print(f"❌ Hiba az EBK ellenőrzés mentése közben: {type(e).__name__}: {e}")
        return JSONResponse(status_code=400, content={"message": hiba_uzenet("Hiba történt a mentés közben!", "E-EBK-01")})

    return JSONResponse(status_code=200, content={"message": "Ellenőrzés elmentve.", "ellenorzes_id": ellenorzes.id})


@router.get("/ebk/ellenorzes/{ellenorzes_id}", response_class=HTMLResponse)
def ellenorzes_reszletek(
    ellenorzes_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id, cegek, aktualis_ceg_nev_ha_eltero, sugo_e = _ceg_kontextus(request, current_user, db)
    ellenorzes = db.query(models.EbkEllenorzes).join(models.EbkProjekt).filter(
        models.EbkEllenorzes.id == ellenorzes_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not ellenorzes:
        return RedirectResponse(url="/ebk", status_code=303)
    if not _projekt_lathato_e(current_user, ellenorzes.projekt):
        return RedirectResponse(url="/ebk", status_code=303)

    szabalytalansagok = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "SZABALYTALANSAG"]
    rendben_tetelek = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "RENDBEN"]
    nem_relevans_tetelek = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "NEM_RELEVANS"]

    return templates.TemplateResponse(
        request=request,
        name="ebk_ellenorzes_reszletek.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "aktualis_ceg_nev_ha_eltero": aktualis_ceg_nev_ha_eltero,
            "sugo_e": sugo_e,
            "working_company_id": working_company_id,
            "ellenorzes": ellenorzes,
            "szabalytalansagok": szabalytalansagok,
            "rendben_tetelek": rendben_tetelek,
            "nem_relevans_tetelek": nem_relevans_tetelek,
        }
    )


@router.get("/ebk/ellenorzes/{ellenorzes_id}/pdf")
def ellenorzes_pdf(
    ellenorzes_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    """Egyetlen helyszíni ellenőrzés (bejárás) teljes, nyomtatható jegyzőkönyve - a napi
    összefoglalóval szemben ez a fényképeket és aláírásokat is tartalmazza."""
    working_company_id = get_working_company_id(current_user, request)
    ellenorzes = db.query(models.EbkEllenorzes).join(models.EbkProjekt).filter(
        models.EbkEllenorzes.id == ellenorzes_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not ellenorzes:
        return RedirectResponse(url="/ebk", status_code=303)
    if not _projekt_lathato_e(current_user, ellenorzes.projekt):
        return RedirectResponse(url="/ebk", status_code=303)

    szabalytalansagok = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "SZABALYTALANSAG"]
    rendben_tetelek = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "RENDBEN"]
    nem_relevans_tetelek = [t for t in ellenorzes.tetel_eredmenyek if t.statusz == "NEM_RELEVANS"]

    pdf = EbkEllenorzesPDF(ellenorzes)
    pdf.alias_nb_pages()
    pdf.add_page()
    pdf.alapadatok()

    if szabalytalansagok:
        pdf.set_font("DejaVu", "B", 12)
        pdf.cell(0, 8, f"Szabálytalanságok ({len(szabalytalansagok)})", ln=True)
        pdf.ln(1)
        for sz in szabalytalansagok:
            pdf.szabalytalansag_blokk(sz)
    else:
        pdf.set_font("DejaVu", "", 10)
        pdf.cell(0, 7, "Nem történt szabálytalanság ezen a bejáráson.", ln=True)

    pdf.egyszeru_lista(f"Rendben talált tételek ({len(rendben_tetelek)})", rendben_tetelek)
    pdf.egyszeru_lista(f"Nem releváns tételek ({len(nem_relevans_tetelek)})", nem_relevans_tetelek)

    pdf_bytes = bytes(pdf.output())
    return StreamingResponse(
        io.BytesIO(pdf_bytes), media_type="application/pdf",
        headers={"Content-Disposition": f"inline; filename=ebk_ellenorzes_{ellenorzes_id}.pdf"}
    )


@router.get("/ebk/projekt/{projekt_id}/napi-osszefoglalo/pdf")
def napi_osszefoglalo_pdf(
    projekt_id: int,
    request: Request,
    datum: str,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    working_company_id = get_working_company_id(current_user, request)
    projekt = db.query(models.EbkProjekt).filter(
        models.EbkProjekt.id == projekt_id, models.EbkProjekt.company_id == working_company_id
    ).first()
    if not projekt:
        return RedirectResponse(url="/ebk", status_code=303)
    if not _projekt_lathato_e(current_user, projekt):
        return RedirectResponse(url="/ebk", status_code=303)

    datum_obj = _parse_date(datum) or date.today()

    ellenorzesek = db.query(models.EbkEllenorzes).options(joinedload(models.EbkEllenorzes.terulet)).filter(
        models.EbkEllenorzes.projekt_id == projekt_id, models.EbkEllenorzes.datum == datum_obj
    ).all()

    terulet_szamlalo = {}
    for e in ellenorzesek:
        nev = e.terulet.nev if e.terulet else "-"
        terulet_szamlalo[nev] = terulet_szamlalo.get(nev, 0) + 1

    ellenorzes_idk = [e.id for e in ellenorzesek]
    szabalytalansagok = db.query(models.EbkEllenorzesTetel).options(
        joinedload(models.EbkEllenorzesTetel.alvallalkozo), joinedload(models.EbkEllenorzesTetel.tetel)
    ).filter(
        models.EbkEllenorzesTetel.ellenorzes_id.in_(ellenorzes_idk),
        models.EbkEllenorzesTetel.statusz == "SZABALYTALANSAG",
    ).all() if ellenorzes_idk else []

    alvallalkozo_szamlalo = {}
    tetel_szamlalo = {}
    sulyossag_szamlalo = {"ENYHE": 0, "KOZEPES": 0, "SULYOS": 0}
    for sz in szabalytalansagok:
        alv_nev = sz.alvallalkozo.nev if sz.alvallalkozo else "Ismeretlen"
        alvallalkozo_szamlalo[alv_nev] = alvallalkozo_szamlalo.get(alv_nev, 0) + 1
        tetel_szoveg = sz.tetel.szoveg if sz.tetel else "Ismeretlen"
        tetel_szamlalo[tetel_szoveg] = tetel_szamlalo.get(tetel_szoveg, 0) + 1
        if sz.sulyossag in sulyossag_szamlalo:
            sulyossag_szamlalo[sz.sulyossag] += 1

    pdf = EbkNapiOsszefoglaloPDF(projekt, datum_obj)
    pdf.alias_nb_pages()
    pdf.add_page()
    pdf.diagramok_hozzaadasa(
        terulet_adatok=sorted(terulet_szamlalo.items(), key=lambda x: -x[1]),
        alvallalkozo_adatok=sorted(alvallalkozo_szamlalo.items(), key=lambda x: -x[1]),
        tetel_adatok=sorted(tetel_szamlalo.items(), key=lambda x: -x[1])[:8],
        sulyossag_adatok=[(SULYOSSAG_CIMKE[k], v) for k, v in sulyossag_szamlalo.items()],
    )

    pdf.tablazat_fejlec(f"Elvégzett ellenőrzések ({len(ellenorzesek)})")
    pdf.ellenorzesek_tablazata(ellenorzesek)

    if szabalytalansagok:
        pdf.tablazat_fejlec(f"Szabálytalanságok részletei ({len(szabalytalansagok)})")
        pdf.szabalytalansagok_tablazata(szabalytalansagok)

    pdf_bytes = bytes(pdf.output())
    return StreamingResponse(
        io.BytesIO(pdf_bytes), media_type="application/pdf",
        headers={"Content-Disposition": f"inline; filename=ebk_napi_osszefoglalo_{projekt_id}_{datum_obj}.pdf"}
    )