import io

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

import models
from database import get_db
from security import get_current_user, get_working_company_id, get_allowed_companies_list, is_company_active, is_company_accessible, require_modul
from hibakodok import hiba_uzenet
from excel_import_utils import import_datum_parszolas, import_szam_parszolas
from tuzvedelem_import_utils import (
    TUZVEDELEM_IMPORT_MEZOK, letrehoz_uj_keszuleket_importbol, frissit_meglevo_keszuleket_importbol
)
from templates_env import templates

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

_JOGOSULT_SZEREPKOROK = ["Admin"]


@router.get("/tuzvedelem/import", response_class=HTMLResponse)
def keszulek_import_oldal(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in _JOGOSULT_SZEREPKOROK:
        return RedirectResponse(url="/tuzvedelem")

    working_company_id = get_working_company_id(current_user, request)
    cegek = get_allowed_companies_list(current_user, db, "TUZVEDELEM")

    return templates.TemplateResponse(
        request=request,
        name="tuzvedelem_import.html",
        context={
            "user": current_user,
            "cegek": cegek,
            "working_company_id": working_company_id,
            "import_mezok": [{"kulcs": k, "cimke": c} for k, c in TUZVEDELEM_IMPORT_MEZOK]
        }
    )


@router.post("/tuzvedelem/import/elemzes")
async def keszulek_import_elemzes(
    file: UploadFile = File(...),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in _JOGOSULT_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    try:
        tartalom = await file.read()
        wb = openpyxl.load_workbook(io.BytesIO(tartalom), read_only=True, data_only=True)
        sheet = wb.active
        elso_sor = next(sheet.iter_rows(min_row=1, max_row=1, values_only=True))
        oszlopok = [str(c).strip() for c in elso_sor if c is not None and str(c).strip() != ""]
    except Exception as e:
        return JSONResponse(status_code=400, content={"message": hiba_uzenet("Nem sikerült beolvasni a fájlt - ellenőrizd, hogy érvényes Excel (.xlsx) fájlt választottál!", "E-TUZIMP-01")})

    return {"oszlopok": oszlopok}


@router.post("/tuzvedelem/import/futtatas")
async def keszulek_import_futtatas(
    request: Request,
    file: UploadFile = File(...),
    target_company_id: int = Form(...),
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in _JOGOSULT_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    if not is_company_accessible(current_user, target_company_id):
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod ehhez a céghez!"})

    if not is_company_active(target_company_id, db):
        return JSONResponse(status_code=403, content={"message": "A célcég inaktív státuszú, import nem futtatható!"})

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

    form_data = await request.form()

    oszlop_hozzarendeles = {}
    for kulcs, _ in TUZVEDELEM_IMPORT_MEZOK:
        ertek = form_data.get(f"map_{kulcs}")
        if ertek:
            oszlop_hozzarendeles[kulcs] = ertek

    try:
        tartalom = await file.read()
        wb = openpyxl.load_workbook(io.BytesIO(tartalom), read_only=True, data_only=True)
        sheet = wb.active
        sorok = list(sheet.iter_rows(values_only=True))
    except Exception as e:
        return JSONResponse(status_code=400, content={"message": hiba_uzenet("Nem sikerült beolvasni a fájlt - ellenőrizd, hogy érvényes Excel (.xlsx) fájlt választottál!", "E-TUZIMP-01")})

    if not sorok:
        return JSONResponse(status_code=400, content={"message": "A fájl üres!"})

    fejlec = [str(c).strip() if c is not None else "" for c in sorok[0]]
    oszlop_index = {}
    for kulcs, excel_oszlop_nev in oszlop_hozzarendeles.items():
        if excel_oszlop_nev in fejlec:
            oszlop_index[kulcs] = fejlec.index(excel_oszlop_nev)

    def cellaertek(sor, kulcs):
        idx = oszlop_index.get(kulcs)
        if idx is None or idx >= len(sor):
            return None
        return sor[idx]

    letrehozva = 0
    konfliktusok = []

    try:
        for sor_szam, sor in enumerate(sorok[1:], start=2):
            if sor is None or all(c is None for c in sor):
                continue

            gyari_szam_nyers = cellaertek(sor, "gyari_szam")
            gyari_szam = str(gyari_szam_nyers).strip() if gyari_szam_nyers is not None else ""

            gyarto_nyers = cellaertek(sor, "gyarto")
            tipus_nyers = cellaertek(sor, "tipus_nev")

            if not gyari_szam and not gyarto_nyers and not tipus_nyers:
                continue  # teljesen üres sor

            gyartas_datum = import_datum_parszolas(cellaertek(sor, "gyartas_datum"))

            adat = {
                "telephely": cellaertek(sor, "telephely"),
                "epulet": cellaertek(sor, "epulet"),
                "szint": cellaertek(sor, "szint"),
                "hely_leiras": cellaertek(sor, "hely_leiras"),
                "gyarto": gyarto_nyers,
                "tipus_nev": tipus_nyers,
                "gyari_szam": gyari_szam,
                "gyartasi_szabvany": cellaertek(sor, "gyartasi_szabvany"),
                "oltoanyag_tipus": cellaertek(sor, "oltoanyag_tipus"),
                "oe_ertek": cellaertek(sor, "oe_ertek"),
                "toltettomeg_kg": import_szam_parszolas(cellaertek(sor, "toltettomeg_kg")),
                "gyartas_datum": gyartas_datum.isoformat() if gyartas_datum else None,
                "statusz": cellaertek(sor, "statusz"),
            }

            meglevo = None
            if gyari_szam:
                meglevo = db.query(models.TuzoltoKeszulek).filter(
                    models.TuzoltoKeszulek.company_id == target_company_id,
                    models.TuzoltoKeszulek.gyari_szam == gyari_szam
                ).first()

            if meglevo:
                konfliktusok.append({
                    "adat": adat,
                    "meglevo_keszulek_id": meglevo.id,
                    "meglevo_adat": {
                        "telephely": meglevo.jelenlegi_hely.telephely.nev if meglevo.jelenlegi_hely and meglevo.jelenlegi_hely.telephely else "-",
                        "hely_leiras": meglevo.jelenlegi_hely.hely_leiras if meglevo.jelenlegi_hely else "-",
                        "gyarto": meglevo.gyarto,
                        "tipus_nev": meglevo.tipus_nev,
                        "gyartasi_szabvany": meglevo.gyartasi_szabvany,
                        "oltoanyag_tipus": meglevo.oltoanyag_tipus,
                        "oe_ertek": meglevo.oe_ertek,
                        "toltettomeg_kg": meglevo.toltettomeg_kg,
                        "statusz": meglevo.statusz,
                    }
                })
                continue

            letrehoz_uj_keszuleket_importbol(adat, target_company_id, db, current_user)
            letrehozva += 1

        db.commit()
    except Exception as e:
        db.rollback()
        print(f"❌ Hiba a tűzvédelmi Excel import feldolgozása közben (sor {sor_szam}): {type(e).__name__}: {e}")
        return JSONResponse(
            status_code=400,
            content={"message": hiba_uzenet(f"Hiba történt a(z) {sor_szam}. sor feldolgozása közben!", "E-TUZIMP-02")}
        )

    return {"letrehozva": letrehozva, "konfliktusok": konfliktusok}


@router.post("/tuzvedelem/import/konfliktus-feloldas")
async def keszulek_import_konfliktus_feloldas(
    request: Request,
    db: Session = Depends(get_db),
    current_user: models.User = Depends(get_current_user)
):
    if current_user.role not in _JOGOSULT_SZEREPKOROK:
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod!"})

    body = await request.json()
    target_company_id = body.get("target_company_id")
    dontesek = body.get("dontesek", [])

    if not is_company_accessible(current_user, target_company_id):
        return JSONResponse(status_code=403, content={"message": "Nincs jogosultságod ehhez a céghez!"})

    if not is_company_active(target_company_id, db):
        return JSONResponse(status_code=403, content={"message": "A célcég inaktív státuszú, import nem futtatható!"})

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

    letrehozva = 0
    frissitve = 0
    kihagyva = 0

    try:
        for i, d in enumerate(dontesek):
            action = d.get("action")
            adat = d.get("adat", {})

            if action == "overwrite":
                meglevo_keszulek_id = d.get("meglevo_keszulek_id")
                keszulek = db.query(models.TuzoltoKeszulek).filter(
                    models.TuzoltoKeszulek.id == meglevo_keszulek_id,
                    models.TuzoltoKeszulek.company_id == target_company_id
                ).first()
                if keszulek:
                    frissit_meglevo_keszuleket_importbol(keszulek, adat, target_company_id, db, current_user)
                    frissitve += 1
            elif action == "new":
                letrehoz_uj_keszuleket_importbol(adat, target_company_id, db, current_user)
                letrehozva += 1
            else:
                kihagyva += 1

        db.commit()
    except Exception as e:
        db.rollback()
        print(f"❌ Hiba a tűzvédelmi konfliktus-feloldás közben ({i}. döntés): {type(e).__name__}: {e}")
        return JSONResponse(
            status_code=400,
            content={"message": hiba_uzenet(f"Hiba történt a(z) {i + 1}. döntés feldolgozása közben!", "E-TUZIMP-03")}
        )

    return {"letrehozva": letrehozva, "frissitve": frissitve, "kihagyva": kihagyva}