from fastapi import APIRouter, Depends, HTTPException, status
from typing import List
from schemas.reslevis import (
    BuildingItem, PlanItem, ZoneItem, GatewayItem, TrackerItem,
    OperatorItem, SubjectItem, AlarmItem, TrackItem
)
from logica_reslevis.gateway import GatewayJsonRepository

# importa le dipendenze di sicurezza
from security import get_current_user, require_roles

gateway_repo = GatewayJsonRepository()
router = APIRouter()

# -----------------------
# Endpoints pubblici (se vuoi che restino pubblici, niente Depends)
# -----------------------
@router.get("/getBuildings", response_model=List[BuildingItem], tags=["Reslevis"])
def getBuildings():
    return []

@router.get("/getPlans", response_model=List[PlanItem], tags=["Reslevis"])
def getPlans():
    return []

@router.get("/getZones", response_model=List[ZoneItem], tags=["Reslevis"])
def getZones():
    return []

# -----------------------
# Endpoints protetti: richiedono almeno un Bearer token valido
# -----------------------
@router.get("/getGateways", response_model=List[GatewayItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getGateways():
    return gateway_repo.list()

@router.get("/getTrackers", response_model=List[TrackerItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getTrackers():
    return []

@router.get("/getOperators", response_model=List[OperatorItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getOperators():
    return []

@router.get("/getSubjects", response_model=List[SubjectItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getSubjects():
    return []

@router.get("/getAlarms", response_model=List[AlarmItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getAlarms():
    return []

@router.get("/getTracks", response_model=List[TrackItem], tags=["Reslevis"], dependencies=[Depends(get_current_user)])
def getTracks():
    return []

# -----------------------
# Operazioni di scrittura su Gateway:
# - Token valido
# - Ruolo richiesto (esempio: "reslevis:write")
#   Cambia il nome ruolo per allinearlo a come lo hai definito in Keycloak
# -----------------------
write_role = "reslevis:write"  # esempio; usa il tuo realm/client role

@router.post(
    "/postGateway",
    tags=["Reslevis"],
    dependencies=[Depends(require_roles(write_role))]
)
def postGateway(item: GatewayItem):
    try:
        gateway_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")

@router.put(
    "/updateGateway",
    tags=["Reslevis"],
    dependencies=[Depends(require_roles(write_role))]
)
def updateGateway(item: GatewayItem):
    try:
        gateway_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")

@router.delete(
    "/removeGateway/{gateway_id}",
    tags=["Reslevis"],
    dependencies=[Depends(require_roles(write_role))]
)
def removeGateway(gateway_id: str):
    try:
        gateway_repo.remove(gateway_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")

@router.post("/postBuilding", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postBuilding(item: BuildingItem):
    return {"message": "OK"}

@router.post("/postPlan", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postPlan(item: PlanItem):
    return {"message": "OK"}

@router.post("/postZone", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postZone(item: ZoneItem):
    return {"message": "OK"}

@router.post("/postTracker", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postTracker(item: TrackerItem):
    return {"message": "OK"}

@router.post("/postOperator", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postOperator(item: OperatorItem):
    return {"message": "OK"}

@router.post("/postSubject", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postSubject(item: SubjectItem):
    return {"message": "OK"}

@router.post("/postAlarm", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postAlarm(item: AlarmItem):
    return {"message": "OK"}

@router.post("/postTrack", tags=["Reslevis"], dependencies=[Depends(require_roles(write_role))])
def postTrack(item: TrackItem):
    return {"message": "OK"}