import PolygonGenerator from "./polygonGenerator";
import { useThree } from "@react-three/fiber";
import { useEffect, useMemo, useRef, useState } from "react";
import * as THREE from "three";
import * as Types from "../../../types/world/worldTypes";
import PathNavigator from "./pathNavigator";
import NavMeshDetails from "./navMeshDetails";
import {
  useSelectedActionSphere,
  useSimulationPaths,
} from "../../../store/store";
import * as CONSTANTS from "../../../types/world/worldConstants";

const Agv = ({
  lines,
}: {
  lines: Types.RefLines;
}) => {
  const [pathPoints, setPathPoints] = useState<
    {
      modelUuid: string;
      modelSpeed: number;
      bufferTime: number;
      points: { x: number; y: number; z: number }[];
      hitCount: number;
    }[]
  >([]);
  const { simulationPaths } = useSimulationPaths();
  const { selectedActionSphere } = useSelectedActionSphere();
  useEffect(() => {
    if (!Array.isArray(simulationPaths)) {
    } else {
      let agvModels = simulationPaths.filter(
        (val: any) => val.modelName === "agv"
      );

      
      let findMesh = agvModels.filter(
        (val: any) =>
          val.modeluuid === selectedActionSphere?.path?.modeluuid &&
          val.type === "Vehicle"
      );

      const result =
        findMesh.length > 0 &&
          findMesh[0].type === "Vehicle" &&
          typeof findMesh[0].points?.actions.start === "object" &&
          typeof findMesh[0].points?.actions.end === "object" &&
          "x" in findMesh[0].points.actions.start &&
          "y" in findMesh[0].points.actions.start &&
          "x" in findMesh[0].points.actions.end &&
          "y" in findMesh[0].points.actions.end
          ? [
              {
                modelUuid: findMesh[0].modeluuid, // Ensure it's a number
                modelSpeed: findMesh[0].points.speed,
                bufferTime: findMesh[0].points.actions.buffer,
                hitCount: findMesh[0].points.actions.hitCount,
                points: [
                  {
                    x: findMesh[0].position[0],
                    y: findMesh[0].position[1],
                    z: findMesh[0].position[2],
                  },
                  {
                    x: findMesh[0].points.actions.start.x,
                    y: 0,
                    z: findMesh[0].points.actions.start.y,
                  },
                  {
                    x: findMesh[0].points.actions.end.x,
                    y: 0,
                    z: findMesh[0].points.actions.end.y,
                  },
                ],
              },
            ]
          : [];
      if (result.length > 0) {
        // setPathPoints((prev) => [...prev, ...result]);
        setPathPoints((prev) => {
          const existingIndex = prev.findIndex(
            (item) => item.modelUuid === result[0].modelUuid
          );

          if (existingIndex !== -1) {
            const updatedPathPoints = [...prev];
            updatedPathPoints[existingIndex] = result[0];
            return updatedPathPoints;
          } else {
            return [...prev, ...result];
          }
        });
      }
    }
    // setPathPoints((prev) => {
    //   const existingUUIDs = new Set(prev.map((item) => item.uuid));
    //   const newItems = result.filter(
    //     (item) => !existingUUIDs.has(item.uuid)
    //   );
    //   return [...prev, ...newItems];
    // });
  }, [simulationPaths, selectedActionSphere]);

  let groupRef = useRef() as Types.RefGroup;
  const [navMesh, setNavMesh] = useState();

  return (
    <>
      <PolygonGenerator groupRef={groupRef} lines={lines} />
      <NavMeshDetails
        lines={lines}
        setNavMesh={setNavMesh}
        groupRef={groupRef}
      />
      {pathPoints.map((pair, i) => (
        <>
          <PathNavigator
            navMesh={navMesh}
            selectedPoints={pair.points}
            id={pair.modelUuid}
            key={i}
            speed={pair.modelSpeed}
            bufferTime={pair.bufferTime}
            hitCount={pair.hitCount}
          />
          {/* {pair.points.length > 2 && (
            <>
              <mesh
                position={[
                  pair.points[1].x,
                  pair.points[1].y,
                  pair.points[1].z,
                ]}
              >
                <sphereGeometry args={[0.3, 15, 15]} />
                <meshStandardMaterial color="red" />
              </mesh>
              <mesh
                position={[
                  pair.points[2].x,
                  pair.points[2].y,
                  pair.points[2].z,
                ]}
              >
                <sphereGeometry args={[0.3, 15, 15]} />
                <meshStandardMaterial color="red" />
              </mesh>
            </>
          )} */}
        </>
      ))}
      <group ref={groupRef} visible={false} name="Meshes">
        <mesh rotation-x={CONSTANTS.planeConfig.rotation} position={CONSTANTS.planeConfig.position3D} name="Plane" receiveShadow>
          <planeGeometry args={[300, 300]} />
          <meshBasicMaterial color={CONSTANTS.planeConfig.color} />
        </mesh>
      </group>
    </>
  );
};

export default Agv;