Dwinzo_dev/app/src/components/ui/componets/RealTimeVisulization.tsx

import React, { useEffect, useState, useRef } from "react";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
import Panel from "./Panel";
import AddButtons from "./AddButtons";
import { useSelectedZoneStore } from "../../../store/useZoneStore";
import DisplayZone from "./DisplayZone";
import Scene from "../../../modules/scene/scene";
import useModuleStore from "../../../store/useModuleStore";

import DroppedObjects from "./DroppedFloatingWidgets";
import { useDroppedObjectsStore } from "../../../store/useDroppedObjectsStore";
import { useZones } from "../../../store/store";


type Side = "top" | "bottom" | "left" | "right";

type FormattedZoneData = Record<
  string,
  {
    activeSides: Side[];
    panelOrder: Side[];
    lockedPanels: Side[];
    zoneId: string;
    zoneViewPortTarget: number[];
    zoneViewPortPosition: number[]
    widgets: Widget[];
  }
>;
type Widget = {
  id: string;
  type: string;
  title: string;
  panel: Side;
  data: any;
};

const RealTimeVisulization: React.FC = () => {
  const [hiddenPanels, setHiddenPanels] = React.useState<Side[]>([]);
  const containerRef = useRef<HTMLDivElement>(null);
  const { isPlaying } = usePlayButtonStore();
  const { activeModule } = useModuleStore();
  const [droppedObjects, setDroppedObjects] = useState<any[]>([]);
  const [zonesData, setZonesData] = useState<FormattedZoneData>({});
  const { selectedZone, setSelectedZone } = useSelectedZoneStore();
  const { zones } = useZones()

  useEffect(() => {
    const data = Array.isArray(zones) ? zones : [];

    const formattedData = data.reduce<FormattedZoneData>((acc, zone) => {
      acc[zone.zoneName] = {
        activeSides: [],
        panelOrder: [],
        lockedPanels: [],
        zoneId: zone.zoneId,
        zoneViewPortTarget: zone.viewPortCenter,
        zoneViewPortPosition: zone.viewPortposition,
        widgets: [],
      };
      return acc;
    }, {});

    setZonesData(formattedData);
  }, [zones]);

  useEffect(() => {
    setZonesData((prev) => {
      if (!selectedZone) return prev;
      return {
        ...prev,
        [selectedZone.zoneName]: {
          ...prev[selectedZone.zoneName], // Keep existing properties
          activeSides: selectedZone.activeSides || [],
          panelOrder: selectedZone.panelOrder || [],
          lockedPanels: selectedZone.lockedPanels || [],
          zoneId: selectedZone.zoneId || "",
          zoneViewPortTarget: selectedZone.zoneViewPortTarget || [],
          zoneViewPortPosition: selectedZone.zoneViewPortPosition || [],
          widgets: selectedZone.widgets || [],
        },
      };
    });
  }, [selectedZone]);

  const handleDrop = (event: React.DragEvent<HTMLDivElement>) => {
    event.preventDefault();
    const data = event.dataTransfer.getData("text/plain");
    if (!data || !selectedZone.zoneName) return;
  
    const droppedData = JSON.parse(data);
    const canvasElement = document.getElementById("real-time-vis-canvas");
    if (!canvasElement) return;
  
    const canvasRect = canvasElement.getBoundingClientRect();
    const relativeX = event.clientX - canvasRect.left;
    const relativeY = event.clientY - canvasRect.top;
  
    const newObject = {
      ...droppedData,
      position: [relativeY, relativeX], // Y first because of top/left style
    };
  
    console.log("newObject: ", newObject);
  
    // Only set zone if it’s not already in the store (prevents overwriting objects)
    const existingZone = useDroppedObjectsStore.getState().zones[selectedZone.zoneName];
    if (!existingZone) {
      useDroppedObjectsStore.getState().setZone(selectedZone.zoneName, selectedZone.zoneId);
    }
  
    // Add the dropped object to the zone
    useDroppedObjectsStore.getState().addObject(selectedZone.zoneName, newObject);
  };
  

  return (
    <div
      ref={containerRef}
      id="real-time-vis-canvas"
      className={`realTime-viz canvas ${isPlaying ? "playingFlase" : ""}`}
      style={{
        height: isPlaying || activeModule !== "visualization" ? "100vh" : "",
        width: isPlaying || activeModule !== "visualization" ? "100vw" : "",
        left: isPlaying || activeModule !== "visualization" ? "0%" : "",
      }}
    >
      <div
        className="scene-container"
        style={{
          height: "100%",
          width: "100%",
          borderRadius:
            isPlaying || activeModule !== "visualization" ? "" : "6px",
        }}
        onDrop={(event) => handleDrop(event)}
        onDragOver={(event) => event.preventDefault()}
      >

        <Scene />
      </div>
      <DroppedObjects />
      {activeModule === "visualization" && (
        <>
          <DisplayZone
            zonesData={zonesData}
            selectedZone={selectedZone}
            setSelectedZone={setSelectedZone}
          />

          {!isPlaying && selectedZone?.zoneName !== "" && (
            <AddButtons
              hiddenPanels={hiddenPanels}
              setHiddenPanels={setHiddenPanels}
              selectedZone={selectedZone}
              setSelectedZone={setSelectedZone}
            />
          )}

          <Panel
            selectedZone={selectedZone}
            setSelectedZone={setSelectedZone}
            hiddenPanels={hiddenPanels}
            setZonesData={setZonesData}
          />
        </>
      )}
    </div>
  );
};

export default RealTimeVisulization;