nodeMap/components/area/hooks/useAreaMarkersLayer.js

import { getDebugLog } from "@/utils/configUtils.js";
// /hooks/layers/useAreaMarkersLayer.js
import { useEffect, useState, useRef } from "react";
import L from "leaflet";
import "leaflet/dist/leaflet.css";
import { useDispatch } from "react-redux";
import { updateAreaThunk } from "@/redux/thunks/database/area/updateAreaThunk";

const customIcon = new L.Icon({
  iconUrl: "/img/bereich.png",
  iconSize: [25, 41],
  iconAnchor: [12, 41],
  popupAnchor: [1, -34],
  shadowUrl: "/img/marker-shadow.png",
  shadowSize: [41, 41],
});

const useAreaMarkersLayer = (map, oms, apiUrl, onUpdateSuccess) => {
  const dispatch = useDispatch();
  const [areaMarkers, setAreaMarkers] = useState([]);
  const prevVisibility = useRef(null);

  const updateMarkersVisibility = () => {
    if (!map || areaMarkers.length === 0) return;

    // Kartenspezifischer localStorage-Key verwenden
    const mapId = localStorage.getItem("currentMapId");
    const userId = localStorage.getItem("currentUserId");
    const mapStorageKey =
      mapId && userId ? `mapLayersVisibility_m${mapId}_u${userId}` : "mapLayersVisibility";

    const mapLayersVisibility = JSON.parse(localStorage.getItem(mapStorageKey)) || {};
    const areAllLayersInvisible = Object.values(mapLayersVisibility).every(v => !v);

    if (areAllLayersInvisible === prevVisibility.current) return;
    prevVisibility.current = areAllLayersInvisible;

    areaMarkers.forEach(marker => {
      if (areAllLayersInvisible) {
        marker.addTo(map);
        if (oms) oms.addMarker(marker);
      } else {
        map.removeLayer(marker);
      }
    });
  };

  useEffect(() => {
    updateMarkersVisibility();

    const handleStorageChange = event => {
      // Überwache sowohl den alten als auch kartenspezifische Keys
      if (event.key === "mapLayersVisibility" || event.key?.startsWith("mapLayersVisibility_")) {
        updateMarkersVisibility();
      }
    };

    window.addEventListener("storage", handleStorageChange);
    const intervalId = setInterval(updateMarkersVisibility, 5000);

    return () => {
      window.removeEventListener("storage", handleStorageChange);
      clearInterval(intervalId);
    };
  }, [map, areaMarkers, oms]);

  useEffect(() => {
    const fetchArea = async () => {
      try {
        const response = await fetch(apiUrl);
        if (!response.ok) throw new Error(`API-Fehler: ${response.status} ${response.statusText}`);

        const data = await response.json();

        const editMode = localStorage.getItem("editMode") === "true";
        const markers = data.map(item => {
          const marker = L.marker([item.x, item.y], {
            icon: customIcon,
            draggable: editMode,
            customType: "areaMarker",
          });

          marker.bindTooltip(
            `<strong>Bereich:</strong> ${item.location_name} <br />
             <strong>Standort:</strong> ${item.area_name}`,
            {
              permanent: false,
              direction: "top",
              offset: [0, -20],
            }
          );

          if (editMode) {
            marker.on("dragend", async e => {
              const { lat, lng } = e.target.getLatLng();
              try {
                await dispatch(
                  updateAreaThunk({
                    idLocation: item.idLocation,
                    idMap: item.idMaps,
                    newCoords: { x: lat, y: lng },
                  })
                ).unwrap();
                if (getDebugLog()) {
                  console.log("✔️ Koordinaten erfolgreich aktualisiert:", { lat, lng });
                }
                onUpdateSuccess?.(); // optionaler Callback
              } catch (error) {
                console.error("❌ Fehler beim Aktualisieren der Koordinaten:", error);
              }
            });
          }

          return marker;
        });

        setAreaMarkers(markers);
      } catch (error) {
        console.error("Fehler beim Laden der Bereiche:", error.message);
        setAreaMarkers([]);
      }
    };

    fetchArea();
  }, [apiUrl, dispatch]);

  useEffect(() => {
    if (map) {
      areaMarkers.forEach(marker => marker.addTo(map));
    }

    return () => {
      if (map) {
        areaMarkers.forEach(marker => map.removeLayer(marker));
      }
    };
  }, [map, areaMarkers]);

  return areaMarkers;
};

export default useAreaMarkersLayer;