import re
from datetime import date, datetime, timedelta, timezone

from fastapi import BackgroundTasks
from sqlalchemy.orm import Session

import models
from database import SessionLocal
from email_utils import send_alert_email_task
from berles_utils import ertesitesi_emailek_berlet_miatt
import email_feliratkozas
from msz_constants import (
    MSZ_MATRIX, MSZ_9750_CSOPORT_MATRIX, add_months, compute_vizsgalati_esedekesseg,
    get_vizsgalati_datum_kotelezo_mod,
)

# A vizsgálat/dokumentum-minősítés két "sikertelen" értéke - ugyanazok a szövegek, amiket a
# vizsgalat.html checklist-jegyzőkönyve (vegso_ertekeles) és a dokumentum-feltöltési minősítés-
# kérdés is használ, hogy egy közös logika kezelhesse mindkét forrást.
VIZSGALATI_MINOSITES_KIVONO_ERTEKEK = {"Korlátozással alkalmas", "Nem alkalmas / Nem felelt meg"}
GEP_STATUSZ_VIZSGAN_NEM_MEGFELELT = "Kivonva (vizsgán nem megfelelés miatt)"


def _ertesitendo_cimek(gep, db: Session, kategoria: str = "sikertelen_vizsgalat") -> list:
    """A gép tulajdonos cégének címzettjei a megadott levélkategóriára (C szelet: a céges szabály és a
    felhasználói feliratkozás szerint - l. email_feliratkozas.py), + a bérlő cég "berlet" kategóriát kapó
    felhasználói, ha a gép ki van helyezve. Az aktiválásra váró és az inaktív felhasználók kimaradnak."""
    cimek = email_feliratkozas.cimzettek(db, gep.company_id, kategoria)
    return list(dict.fromkeys(cimek + ertesitesi_emailek_berlet_miatt(gep, db)))


def _email_engedelyezve_e(gep, db: Session) -> bool:
    beallitas = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == gep.company_id,
        models.Dictionary.kategoria == "VizsgalatSikertelenEmailErtesites"
    ).first()
    return beallitas.ertek == "True" if beallitas else True


def kezeli_sikertelen_vizsgalati_minositest(gep, minosites: str, forras_leiras: str, current_user, db: Session,
                                             background_tasks: BackgroundTasks = None, hatarido_obj: date = None) -> bool:
    """Ha egy vizsgálat (checklist-jegyzőkönyv) vagy egy feltöltött vizsgálati dokumentum
    "Korlátozással alkalmas" vagy "Nem alkalmas" minősítést kapott, hibajegyet (dashboard
    "hibalap") nyit rá, és - a cég beállításától függően - e-mailben is értesíti a feliratkozott
    felhasználókat (a bérlő cég EÜI-jét is, ha a gép ki van helyezve). Visszaadja, hogy történt-e
    bármilyen beavatkozás - ha a minősítés "Alkalmas / Megfelelt" volt, nem csinál semmit.

    A két minősítés eltérően viselkedik (2026-09-30-i user-kérés nyomán szétválasztva):
    - "Nem alkalmas / Nem felelt meg": a gép AZONNAL "Kivonva (vizsgán nem megfelelés miatt)"
      státuszba kerül - ez a régi, változatlan viselkedés.
    - "Korlátozással alkalmas": a gép a `hatarido_obj`-ig HASZNÁLHATÓ marad (nem vonjuk ki), csak
      egy "FIGYELMEZTETES" súlyosságú, határidős hibajegy nyílik rá. Ha a határidőig valaki
      lezárja a hibajegyet (javítás megtörtént, l. routers/mobile_qr.py ticket_feloldas), a gép
      Aktív marad. Ha nem, a naponta lefutó `korlatozott_gepek_hataridejenek_ellenorzese()` a
      határidő elteltével automatikusan kivonja."""
    if minosites not in VIZSGALATI_MINOSITES_KIVONO_ERTEKEK:
        return False

    nem_alkalmas = "Nem alkalmas" in minosites

    if nem_alkalmas:
        regi_statusz = gep.statusz
        gep.statusz = GEP_STATUSZ_VIZSGAN_NEM_MEGFELELT
        gep.statusz_oka = f"{forras_leiras} - minősítés: {minosites}"

        db.add(models.AuditLog(
            machine_id=gep.id,
            user_id=current_user.id if current_user else None,
            field_name="Státusz (automatikus)",
            old_value=regi_statusz,
            new_value=f"{GEP_STATUSZ_VIZSGAN_NEM_MEGFELELT} - {forras_leiras}: {minosites}"
        ))

        hiba_leiras = f"{forras_leiras} miatt a gép automatikusan kivonásra került. Minősítés: {minosites}."
        sulyossag = "LETILTAS"
        ticket_hatarido = None
        kritikus_email = True
    else:
        if hatarido_obj is None:
            hatarido_obj = date.today() + timedelta(days=30)

        db.add(models.AuditLog(
            machine_id=gep.id,
            user_id=current_user.id if current_user else None,
            field_name="Korlátozással alkalmas (határidős)",
            old_value=gep.statusz,
            new_value=(
                f"A gép {hatarido_obj.strftime('%Y-%m-%d')}-ig használható marad, utána javítás "
                f"hiányában automatikusan kivonásra kerül - {forras_leiras}: {minosites}"
            )
        ))

        hiba_leiras = (
            f"{forras_leiras} miatt a gép \"Korlátozással alkalmas\" minősítést kapott. A gép "
            f"{hatarido_obj.strftime('%Y-%m-%d')}-ig HASZNÁLHATÓ, de eddig a hibát el kell hárítani - "
            f"ha addig nem történik javítás rögzítése, a gép automatikusan kivonásra kerül."
        )
        sulyossag = "FIGYELMEZTETES"
        ticket_hatarido = hatarido_obj
        kritikus_email = False

    db.add(models.MaintenanceTicket(
        machine_id=gep.id,
        bejelento_nev=current_user.username if current_user else "Rendszer",
        hiba_leirasa=hiba_leiras,
        sulyossag=sulyossag,
        statusz="Nyitott",
        hatarido=ticket_hatarido,
    ))

    if _email_engedelyezve_e(gep, db) and background_tasks is not None:
        cimek = _ertesitendo_cimek(gep, db)
        if cimek:
            gep_ad = {
                "nev": gep.megnevezes or "Ismeretlen gép",
                "gyari_szam": gep.gyari_szam or "-",
                "tipus": gep.tipus or "-",
                "gep_id": gep.id,
                "company_id": gep.company_id
            }
            background_tasks.add_task(
                send_alert_email_task, cimek, gep_ad, hiba_leiras, kritikus_email,
                current_user.username if current_user else "Rendszer"
            )

    return True


def korlatozott_gepek_hataridejenek_ellenorzese():
    """Naponta lefutó ütemezett feladat (l. main.py scheduler): minden még "Nyitott",
    "FIGYELMEZTETES" súlyosságú, határidős hibajegyet megnéz - ha a határidő letelt és a gép
    időközben nem lett kézzel kivonva/javítva, automatikusan "Kivonva" státuszba kerül."""
    db = SessionLocal()
    try:
        ma = date.today()
        lejart_jegyek = db.query(models.MaintenanceTicket).filter(
            models.MaintenanceTicket.statusz == "Nyitott",
            models.MaintenanceTicket.sulyossag == "FIGYELMEZTETES",
            models.MaintenanceTicket.hatarido.isnot(None),
            models.MaintenanceTicket.hatarido < ma,
        ).all()

        for jegy in lejart_jegyek:
            gep = jegy.machine
            if not gep or gep.statusz != "Aktív":
                continue

            regi_statusz = gep.statusz
            gep.statusz = GEP_STATUSZ_VIZSGAN_NEM_MEGFELELT
            gep.statusz_oka = f"Korlátozással alkalmas minősítés határideje ({jegy.hatarido}) letelt javítás nélkül."

            db.add(models.AuditLog(
                machine_id=gep.id,
                user_id=None,
                field_name="Státusz (automatikus - határidő letelt)",
                old_value=regi_statusz,
                new_value=gep.statusz_oka,
            ))

            jegy.sulyossag = "LETILTAS"
            jegy.hiba_leirasa = f"{jegy.hiba_leirasa} [Automatikusan kivonva: a javítási határidő ({jegy.hatarido}) letelt.]"

            if _email_engedelyezve_e(gep, db):
                cimek = _ertesitendo_cimek(gep, db)
                if cimek:
                    gep_ad = {
                        "nev": gep.megnevezes or "Ismeretlen gép",
                        "gyari_szam": gep.gyari_szam or "-",
                        "tipus": gep.tipus or "-",
                        "gep_id": gep.id,
                        "company_id": gep.company_id
                    }
                    send_alert_email_task(cimek, gep_ad, gep.statusz_oka, True, "Rendszer")

        db.commit()
    except Exception as e:
        db.rollback()
        print(f"❌ Hiba a korlátozott gépek határidő-ellenőrzésekor: {type(e).__name__}: {e}")
    finally:
        db.close()


def eui_fovizsgalatra_jogosult_e(gep) -> bool:
    """EBSZ 7.2.10 - egy Emelőgép ügyintéző csak akkor jogosult Fővizsgálatra VAGY Időszakos
    biztonsági felülvizsgálatra (utóbbi tartalmazza az előbbit), ha a gép megengedett
    teherbírása legfeljebb 1000 kg, ÉS a gépnek nincs olyan kezelői munkahelye, ami az
    emelőkocsin van és 1,5 méternél magasabbra emelhető."""
    try:
        teher_str = str(gep.teherbiras).replace(',', '.')
        tisztitott_szam = re.sub(r'[^\d.]', '', teher_str)
        teher_num = float(tisztitott_szam) if tisztitott_szam else 0
    except Exception:
        teher_num = 0

    if teher_num > 1000:
        return False

    if gep.kezelo_egyutt_emelkedik and (gep.kezeloi_munkahely_magassaga or 0) > 1500:
        return False

    return True


def msz_m_fokozat(h: float) -> str:
    """A napi átlagos üzemidőből (óra) számolt M-fokozat - tükrözi az index.html JS calculateKtValue()-ját."""
    if h <= 2:
        return "M1"
    elif h <= 6:
        return "M2"
    elif h <= 9:
        return "M3"
    elif h <= 12:
        return "M4"
    return "M5"


def msz_t_fokozat(gep) -> str:
    if gep.veszelyes_kornyezet:
        return "T3"
    if gep.teher_class in ("T1", "T2", "T3"):
        return gep.teher_class
    return "T1"


def recompute_msz_classification(gep, form_data):
    """
    Biztonsági validáció (IDOR/adatintegritás): az M-fokozatot és a csoportszámot
    a szerver számolja újra a mentett adatokból, nem a kliens JS-ből kapott értéket
    fogadja el vakon - kivéve az explicit, kockázatértékelésen alapuló egyedi felülbírálást.
    Tükrözi az index.html-ben lévő calculateKtValue() JS logikáját.
    """
    if gep.is_teherfelvevo:
        return

    m_fokozat = msz_m_fokozat(gep.napi_atlag_uzemido or 0.0)
    t_fokozat = msz_t_fokozat(gep)

    gep.calculated_m_fokozat = m_fokozat
    szamolt_csoportszam = MSZ_9750_CSOPORT_MATRIX[m_fokozat][t_fokozat]

    if gep.egyedi_csoportszam_kockazat_alapjan:
        # Kockázatértékelés alapján a felhasználó módosíthatja a csoportszámot,
        # de csak érvényes (1-5) tartományon belül - egyébként az MSZ alapérték marad.
        try:
            beirt_csoportszam = int(form_data.get("calculated_csoportszam"))
        except (TypeError, ValueError):
            beirt_csoportszam = szamolt_csoportszam
        if beirt_csoportszam < 1 or beirt_csoportszam > 5:
            beirt_csoportszam = szamolt_csoportszam
        gep.calculated_csoportszam = str(beirt_csoportszam)
    elif gep.vizsgaloi_csoportszam_felulbiralas:
        # A vizsgáló a vizsgálati lapon már felülbírálta a csoportszámot - egy ezzel
        # össze nem függő gép-szerkesztési mentés (pl. egy másik mező módosítása) ezt
        # ne írja felül csendben az MSZ-mátrix alapján frissen számolt értékkel.
        pass
    else:
        gep.calculated_csoportszam = str(szamolt_csoportszam)


def get_uzemora_beallitasok(company_id: int, db: Session):
    """Visszaadja a cég üzemóra-eltérés kezelési beállításait: (mód, átlagolási napok száma)."""
    mod_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == company_id,
        models.Dictionary.kategoria == "UzemoraEltertesMod"
    ).first()
    mod = mod_obj.ertek if mod_obj else "Figyelmeztetes"

    napok_obj = db.query(models.Dictionary).filter(
        models.Dictionary.company_id == company_id,
        models.Dictionary.kategoria == "UzemoraAtlagNapok"
    ).first()
    try:
        napok = int(napok_obj.ertek) if napok_obj else 30
    except (TypeError, ValueError):
        napok = 30
    if napok < 1:
        napok = 30

    return mod, napok


def check_uzemora_drift_and_escalate(gep, db: Session, background_tasks: BackgroundTasks = None):
    """
    Ha a ténylegesen rögzített üzemóra-fogyás (a Mátrix bázispont óta) jelentősen
    meghaladja a tervezett napi átlagot, a cég beállításától függően:
    - "Figyelmeztetes": csak naplóz és e-mailt küld, a besorolást nem módosítja,
    - "AutomatikusModositas": automatikusan szigorítja az M-fokozatot / csoportszámot is.
    Kockázatértékelés alapján egyedileg felülbírált gépeknél nem nyúlunk automatikusan
    a csoportszámhoz, és nem is figyelmeztetünk - ott a felülbírálás a mérvadó.
    """
    if gep.is_teherfelvevo or gep.egyedi_csoportszam_kockazat_alapjan:
        return

    if not gep.matrix_kezdo_datum or gep.matrix_kezdo_uzemora is None:
        return

    mod, atlag_napok = get_uzemora_beallitasok(gep.company_id, db)

    matrix_kezdo_datum = gep.matrix_kezdo_datum
    if matrix_kezdo_datum.tzinfo is None:
        matrix_kezdo_datum = matrix_kezdo_datum.replace(tzinfo=timezone.utc)

    elapsed_days = (datetime.now(timezone.utc) - matrix_kezdo_datum).total_seconds() / 86400.0
    # A beállított napszámnyi adat kell a megbízható átlagoláshoz, hogy egy egyszeri
    # óraállás-korrekció ne váltson ki téves, azonnali szigorítást/figyelmeztetést.
    if elapsed_days < atlag_napok:
        return

    tenyleges_ora = (gep.uzemora or 0.0) - gep.matrix_kezdo_uzemora
    if tenyleges_ora <= 0:
        return

    tenyleges_napi_atlag = tenyleges_ora / elapsed_days
    tervezett_napi_atlag = gep.napi_atlag_uzemido or 0.0

    # 20% tolerancia, hogy ne villogjon minden apró eltérésnél
    if tenyleges_napi_atlag <= tervezett_napi_atlag * 1.2:
        return

    regi_m_fokozat = gep.calculated_m_fokozat
    regi_csoportszam = gep.calculated_csoportszam

    uj_m_fokozat = msz_m_fokozat(tenyleges_napi_atlag)
    t_fokozat = msz_t_fokozat(gep)
    uj_csoportszam = str(MSZ_9750_CSOPORT_MATRIX[uj_m_fokozat][t_fokozat])

    if mod == "AutomatikusModositas":
        if uj_m_fokozat == regi_m_fokozat and uj_csoportszam == regi_csoportszam:
            return

        gep.calculated_m_fokozat = uj_m_fokozat
        gep.calculated_csoportszam = uj_csoportszam
        # Megjelöljük a dashboard riasztási sávnak is, hogy ez a gép nemrég szigorításon esett át
        gep.uzemora_riasztas_szint = uj_m_fokozat

        log = models.AuditLog(
            machine_id=gep.id,
            user_id=None,
            field_name="AUTOMATIKUS BESOROLÁS SZIGORÍTÁS",
            old_value=f"{regi_m_fokozat or '-'} / {regi_csoportszam or '-'}. csoport",
            new_value=(
                f"{uj_m_fokozat} / {uj_csoportszam}. csoport "
                f"(tényleges napi átlag: {tenyleges_napi_atlag:.1f} h, tervezett: {tervezett_napi_atlag:.1f} h)"
            )
        )
        db.add(log)
        uzenet = (
            f"A gép tényleges üzemóra-használata ({tenyleges_napi_atlag:.1f} h/nap) jelentősen meghaladja "
            f"a tervezett átlagot ({tervezett_napi_atlag:.1f} h/nap). A rendszer ezért automatikusan "
            f"szigorította a besorolást: {regi_m_fokozat or '-'} ({regi_csoportszam or '-'}. csoport) -> "
            f"{uj_m_fokozat} ({uj_csoportszam}. csoport). Kérjük, ellenőrizze a vizsgálati esedékességeket, "
            f"és szükség esetén frissítse a tervezett napi átlagot a gép adatlapján!"
        )
    else:
        # "Figyelmeztetes" mód: nem módosítjuk a besorolást, csak egyszer jelzünk soronként,
        # amíg a szint nem változik (elkerülve, hogy minden napi ellenőrzés újra e-mailt küldjön).
        if gep.uzemora_riasztas_szint == uj_m_fokozat:
            return

        gep.uzemora_riasztas_szint = uj_m_fokozat

        log = models.AuditLog(
            machine_id=gep.id,
            user_id=None,
            field_name="ÜZEMÓRA ELTÉRÉS FIGYELMEZTETÉS",
            old_value=f"Jelenlegi besorolás: {regi_m_fokozat or '-'} / {regi_csoportszam or '-'}. csoport",
            new_value=(
                f"A tényleges használat alapján indokolt lenne: {uj_m_fokozat} / {uj_csoportszam}. csoport "
                f"(tényleges napi átlag: {tenyleges_napi_atlag:.1f} h, tervezett: {tervezett_napi_atlag:.1f} h)"
            )
        )
        db.add(log)
        uzenet = (
            f"A gép tényleges üzemóra-használata ({tenyleges_napi_atlag:.1f} h/nap) jelentősen meghaladja "
            f"a tervezett átlagot ({tervezett_napi_atlag:.1f} h/nap). A jelenlegi besorolás ({regi_m_fokozat or '-'} / "
            f"{regi_csoportszam or '-'}. csoport) a tényleges használat alapján már nem elegendő, indokolt lenne: "
            f"{uj_m_fokozat} / {uj_csoportszam}. csoport. Kérjük, ellenőrizze és szükség esetén frissítse manuálisan "
            f"a besorolást és a tervezett napi átlagot a gép adatlapján! (A rendszer jelenleg csak figyelmeztet, "
            f"a besorolást nem módosítja automatikusan - ez a Beállítások / Szabályok fülön állítható át.)"
        )

    if background_tasks is not None:
        emailek = email_feliratkozas.cimzettek(db, gep.company_id, "gep_riasztas")
        if emailek:
            gep_ad = {
                "nev": gep.megnevezes or "Ismeretlen gép",
                "gyari_szam": gep.gyari_szam or "-",
                "tipus": gep.tipus or "-",
                "gep_id": gep.id,
                "company_id": gep.company_id
            }
            background_tasks.add_task(
                send_alert_email_task, emailek, gep_ad, uzenet, True, "Rendszer (Automatikus besorolás-ellenőrzés)"
            )


FIELD_LABELS = {
    "megnevezes": "Megnevezés",
    "gyarto": "Gyártó",
    "tipus": "Típus",
    "gyari_szam": "Gyári szám",
    "leltari_szam": "Leltári szám",
    "teherbiras": "Teherbírás",
    "alapadat_megjegyzes": "Alapadat megjegyzés",
    "emelesi_magassag": "Emelési magasság",
    "fesztav_gemhossz": "Fesztáv / Gémhossz",
    "meghajtas": "Meghajtás",
    "teljesitmeny": "Teljesítmény",
    "gyartas_datum": "Gyártás dátuma",
    "uzembe_helyezes_datum": "Üzembe helyezés dátuma",
    "szerkezeti_vizsgalat_datum": "Utolsó Szerkezeti vizsgálat",
    "fovizsgalat_datum": "Utolsó Fővizsgálat",
    "biztonsagi_vizsgalat_datum": "Utolsó Bizt. felülvizsgálat",
}


def gep_hianyzo_kotelezo_mezok(gep, config):
    """
    Visszaadja az üresen álló kötelező mezők magyar címkéjét: elsőként a Telephelyet és a
    Géptípust (ezek a szerkesztő adatlapon fixen "required"-ek, minden géptípusnál, pl.
    Excel importtal felvitt gépeknél gyakran üresen maradnak), majd a géptípushoz
    (MachineTypeConfig) beállított egyedi kötelező mezőket - az index.html "Dinamikus
    kötelező mezők" JS logikáját (configMap/hiddenConfigMap) tükrözi vissza, lista-nézethez.
    """
    hianyzik = []

    if not gep.site_id:
        hianyzik.append("Telephely")
    if not gep.geptipus or not str(gep.geptipus).strip():
        hianyzik.append("Géptípus")

    if config and config.kotelezo_mezok:
        kotelezo_lista = [m.strip() for m in config.kotelezo_mezok.split(",") if m.strip()]
        rejtett_lista = set(m.strip() for m in (config.rejtett_mezok or "").split(",") if m.strip())

        egyedi_cimkek = {
            "egyedi_1": config.egyedi_1_nev,
            "egyedi_2": config.egyedi_2_nev,
            "egyedi_3": config.egyedi_3_nev,
        }

        for mezo in kotelezo_lista:
            if mezo in rejtett_lista:
                continue
            ertek = getattr(gep, mezo, None)
            if ertek is None or (isinstance(ertek, str) and not ertek.strip()):
                hianyzik.append(egyedi_cimkek.get(mezo) or FIELD_LABELS.get(mezo, mezo))

    return hianyzik


def build_naptar_esemenyek(gepek, mai_nap, configs_by_geptipus=None, datum_kotelezo_mod="AlapbolKotelezo"):
    """Az aktív gépek soron következő vizsgálati esedékességeit napokra csoportosítva adja vissza
    a dashboard eseménynaptárához. Kulcs: ÉÉÉÉ-HH-NN dátum-szöveg, érték: az adott napra eső események listája."""
    configs_by_geptipus = configs_by_geptipus or {}
    esemenyek = {}
    for gep in gepek:
        config = configs_by_geptipus.get(gep.geptipus)
        for e in compute_vizsgalati_esedekesseg(gep, mai_nap, config, datum_kotelezo_mod):
            if not e["esedekes"]:
                continue
            esemenyek.setdefault(e["esedekes"], []).append({
                "gep_nev": gep.megnevezes or "Ismeretlen gép",
                "tipus": e["tipus"],
                "allapot": e["allapot"]
            })
    return esemenyek


def build_diagram_adatok(gepek, valasztott_diagramok, mai_nap, lejart_db, hamarosan_db, rendben_db):
    """A dashboardon megjeleníthető diagramokhoz szükséges összesített adatokat állítja elő,
    kizárólag a cég Beállításokban kiválasztott diagramtípusokhoz."""
    adatok = {}

    if "statusz" in valasztott_diagramok:
        adatok["statusz"] = {
            "cimkek": ["Rendben", "Közelgő", "Lejárt"],
            "ertekek": [rendben_db, hamarosan_db, lejart_db],
            "szinek": ["#28a745", "#ffc107", "#dc3545"]
        }

    if "gyarto" in valasztott_diagramok:
        szamlalo = {}
        for gep in gepek:
            nev = (gep.gyarto or "Ismeretlen").strip() or "Ismeretlen"
            szamlalo[nev] = szamlalo.get(nev, 0) + 1
        rendezett = sorted(szamlalo.items(), key=lambda x: x[1], reverse=True)
        adatok["gyarto"] = {
            "cimkek": [nev for nev, _ in rendezett[:8]],
            "ertekek": [db_ertek for _, db_ertek in rendezett[:8]]
        }

    if "geptipus" in valasztott_diagramok:
        szamlalo = {}
        for gep in gepek:
            nev = (gep.geptipus or "Ismeretlen").strip() or "Ismeretlen"
            szamlalo[nev] = szamlalo.get(nev, 0) + 1
        rendezett = sorted(szamlalo.items(), key=lambda x: x[1], reverse=True)
        adatok["geptipus"] = {
            "cimkek": [nev for nev, _ in rendezett[:8]],
            "ertekek": [db_ertek for _, db_ertek in rendezett[:8]]
        }

    if "kor" in valasztott_diagramok:
        korcsoportok = {"0-2 év": 0, "2-5 év": 0, "5-10 év": 0, "10+ év": 0, "Ismeretlen": 0}
        koroszszeg = 0.0
        koros_db = 0
        for gep in gepek:
            if not gep.gyartas_datum:
                korcsoportok["Ismeretlen"] += 1
                continue
            kor_evek = (mai_nap - gep.gyartas_datum).days / 365.25
            koroszszeg += kor_evek
            koros_db += 1
            if kor_evek < 2:
                korcsoportok["0-2 év"] += 1
            elif kor_evek < 5:
                korcsoportok["2-5 év"] += 1
            elif kor_evek < 10:
                korcsoportok["5-10 év"] += 1
            else:
                korcsoportok["10+ év"] += 1
        atlag_kor = round(koroszszeg / koros_db, 1) if koros_db else None
        adatok["kor"] = {
            "cimkek": list(korcsoportok.keys()),
            "ertekek": list(korcsoportok.values()),
            "atlag": atlag_kor
        }

    return adatok