import * as THREE from "three";
import { useEffect, useMemo, useRef, useState } from "react";
import { useFrame, useThree } from "@react-three/fiber";
import {
    useFloorItems,
    useSelectedAssets,
    useSocketStore,
    useToggleView,
} from "../../../../store/builder/store";
// import { setFloorItemApi } from '../../../../services/factoryBuilder/assest/floorAsset/setFloorItemApi';
import * as Types from "../../../../types/world/worldTypes";
import { detectModifierKeys } from "../../../../utils/shortcutkeys/detectModifierKeys";
import { useEventsStore } from "../../../../store/simulation/useEventsStore";
import { useProductStore } from "../../../../store/simulation/useProductStore";
import { useSelectedProduct } from "../../../../store/simulation/useSimulationStore";
import { upsertProductOrEventApi } from "../../../../services/simulation/products/UpsertProductOrEventApi";
import { snapControls } from "../../../../utils/handleSnap";
import DistanceFindingControls from "./distanceFindingControls";
import { useParams } from "react-router-dom";

function MoveControls({
    movedObjects,
    setMovedObjects,
    itemsGroupRef,
    pastedObjects,
    setpastedObjects,
    duplicatedObjects,
    setDuplicatedObjects,
    selectionGroup,
    rotatedObjects,
    setRotatedObjects,
    boundingBoxRef,
}: any) {
    const { camera, controls, gl, scene, pointer, raycaster } = useThree();
    const plane = useMemo(() => new THREE.Plane(new THREE.Vector3(0, 1, 0), 0), []);

    const { toggleView } = useToggleView();
    const { selectedAssets, setSelectedAssets } = useSelectedAssets();
    const { selectedProduct } = useSelectedProduct();
    const { floorItems, setFloorItems } = useFloorItems();
    const { socket } = useSocketStore();
    const itemsData = useRef<Types.FloorItems>([]);
    const [keyEvent, setKeyEvent] = useState<"Ctrl" | "Shift" | "Ctrl+Shift" | "">("");
    const email = localStorage.getItem("email");
    const organization = email!.split("@")[1].split(".")[0];
    const userId = localStorage.getItem("userId");
    const { projectId } = useParams();

    const updateBackend = (
        productName: string,
        productId: string,
        organization: string,
        eventData: EventsSchema
    ) => {
        upsertProductOrEventApi({
            productName: productName,
            productId: productId,
            organization: organization,
            eventDatas: eventData,
        });
    };

    useEffect(() => {
        if (!camera || !scene || toggleView || !itemsGroupRef.current) return;

        const canvasElement = gl.domElement;
        canvasElement.tabIndex = 0;

        let isMoving = false;

        const onPointerDown = () => {
            isMoving = false;
        };

        const onPointerMove = () => {
            isMoving = true;
        };

        const onKeyUp = (event: KeyboardEvent) => {
            const isModifierKey = event.key === "Control" || event.key === "Shift";

            if (isModifierKey) {
                setKeyEvent("");
            }
        };

        const onPointerUp = (event: PointerEvent) => {
            if (!isMoving && movedObjects.length > 0 && event.button === 0) {
                event.preventDefault();
                placeMovedAssets();
            }
            if (!isMoving && movedObjects.length > 0 && event.button === 2) {
                event.preventDefault();

                clearSelection();
                movedObjects.forEach((asset: any) => {
                    if (itemsGroupRef.current) {
                        itemsGroupRef.current.attach(asset);
                    }
                });

                setFloorItems([...floorItems, ...itemsData.current]);

                setMovedObjects([]);
                itemsData.current = [];
            }
            setKeyEvent("");
        };

        const onKeyDown = (event: KeyboardEvent) => {
            const keyCombination = detectModifierKeys(event);

            if (pastedObjects.length > 0 || duplicatedObjects.length > 0 || rotatedObjects.length > 0)
                return;

            if (keyCombination === "Ctrl" || keyCombination === "Ctrl+Shift" || keyCombination === "Shift") {
                setKeyEvent(keyCombination);
            } else {
                setKeyEvent("");
            }

            if (keyCombination === "G") {
                if (selectedAssets.length > 0) {
                    moveAssets();
                    itemsData.current = floorItems.filter((item: { modelUuid: string }) =>
                        selectedAssets.some((asset: any) => asset.uuid === item.modelUuid)
                    );
                }
            }

            if (keyCombination === "ESCAPE") {
                event.preventDefault();

                clearSelection();
                movedObjects.forEach((asset: any) => {
                    if (itemsGroupRef.current) {
                        itemsGroupRef.current.attach(asset);
                    }
                });

                setFloorItems([...floorItems, ...itemsData.current]);

                setMovedObjects([]);
                itemsData.current = [];
            }
        };

        if (!toggleView) {
            canvasElement.addEventListener("pointerdown", onPointerDown);
            canvasElement.addEventListener("pointermove", onPointerMove);
            canvasElement.addEventListener("pointerup", onPointerUp);
            canvasElement.addEventListener("keydown", onKeyDown);
            canvasElement?.addEventListener("keyup", onKeyUp);
        }

        return () => {
            canvasElement.removeEventListener("pointerdown", onPointerDown);
            canvasElement.removeEventListener("pointermove", onPointerMove);
            canvasElement.removeEventListener("pointerup", onPointerUp);
            canvasElement.removeEventListener("keydown", onKeyDown);
            canvasElement?.removeEventListener("keyup", onKeyUp);
        };
    }, [camera, controls, scene, toggleView, selectedAssets, socket, floorItems, pastedObjects, duplicatedObjects, movedObjects, rotatedObjects, keyEvent,]);

    let moveSpeed = keyEvent === "Ctrl" || "Ctrl+Shift" ? 1 : 0.25;

    useFrame(() => {
        if (movedObjects.length > 0) {
            const intersectionPoint = new THREE.Vector3();
            raycaster.setFromCamera(pointer, camera);
            const point = raycaster.ray.intersectPlane(plane, intersectionPoint);

            if (point) {
                let targetX = point.x;
                let targetZ = point.z;

                if (keyEvent === "Ctrl") {
                    targetX = snapControls(targetX, "Ctrl");
                    targetZ = snapControls(targetZ, "Ctrl");
                }

                // else if (keyEvent === "Ctrl+Shift") {
                //     targetX = snapControls(targetX, "Ctrl+Shift");
                //     targetZ = snapControls(targetZ, "Ctrl+Shift");
                // } else if (keyEvent === "Shift") {
                //     targetX = snapControls(targetX, "Shift");
                //     targetZ = snapControls(targetZ, "Shift");
                // } else {
                // }

                const position = new THREE.Vector3();

                if (boundingBoxRef.current) {
                    boundingBoxRef.current.getWorldPosition(position);
                    selectionGroup.current.position.lerp(
                        new THREE.Vector3(
                            targetX - (position.x - selectionGroup.current.position.x),
                            selectionGroup.current.position.y,
                            targetZ - (position.z - selectionGroup.current.position.z)
                        ),
                        moveSpeed
                    );
                } else {
                    const box = new THREE.Box3();
                    movedObjects.forEach((obj: THREE.Object3D) =>
                        box.expandByObject(obj)
                    );
                    const center = new THREE.Vector3();
                    box.getCenter(center);

                    selectionGroup.current.position.lerp(
                        new THREE.Vector3(
                            targetX - (center.x - selectionGroup.current.position.x),
                            selectionGroup.current.position.y,
                            targetZ - (center.z - selectionGroup.current.position.z)
                        ),
                        moveSpeed
                    );
                }
            }
        }
    });

    const moveAssets = () => {
        const updatedItems = floorItems.filter(
            (item: { modelUuid: string }) =>
                !selectedAssets.some((asset: any) => asset.uuid === item.modelUuid)
        );
        setFloorItems(updatedItems);
        setMovedObjects(selectedAssets);
        selectedAssets.forEach((asset: any) => {
            selectionGroup.current.attach(asset);
        });
    };

    const placeMovedAssets = () => {
        if (movedObjects.length === 0) return;

        movedObjects.forEach(async (obj: THREE.Object3D) => {
            const worldPosition = new THREE.Vector3();
            obj.getWorldPosition(worldPosition);

            selectionGroup.current.remove(obj);
            obj.position.copy(worldPosition);

            if (itemsGroupRef.current) {
                const newFloorItem: Types.FloorItemType = {
                    modelUuid: obj.uuid,
                    modelName: obj.userData.name,
                    modelfileID: obj.userData.modelId,
                    position: [worldPosition.x, worldPosition.y, worldPosition.z],
                    rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z },
                    isLocked: false,
                    isVisible: true,
                };

                if (obj.userData.eventData) {
                    const eventData = useEventsStore.getState().getEventByModelUuid(obj.userData.modelUuid);
                    const productData = useProductStore.getState().getEventByModelUuid(selectedProduct.productId, obj.userData.modelUuid);

                    if (eventData) {
                        useEventsStore.getState().updateEvent(obj.userData.modelUuid, {
                            position: [worldPosition.x, worldPosition.y, worldPosition.z],
                            rotation: [obj.rotation.x, obj.rotation.y, obj.rotation.z],
                        });
                    }

                    if (productData) {
                        const event = useProductStore
                            .getState()
                            .updateEvent(
                                selectedProduct.productId,
                                obj.userData.modelUuid,
                                {
                                    position: [worldPosition.x, worldPosition.y, worldPosition.z],
                                    rotation: [obj.rotation.x, obj.rotation.y, obj.rotation.z],
                                }
                            );

                        if (event) {
                            updateBackend(
                                selectedProduct.productName,
                                selectedProduct.productId,
                                organization,
                                event
                            );
                        }

                        newFloorItem.eventData = eventData;
                    }
                }

                setFloorItems((prevItems: Types.FloorItems) => {
                    const updatedItems = [...(prevItems || []), newFloorItem];
                    localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
                    return updatedItems;
                });

                //REST

                // await setFloorItemApi(
                //     organization,
                //     obj.uuid,
                //     obj.userData.name,
                //     [worldPosition.x, worldPosition.y, worldPosition.z],
                //     { "x": obj.rotation.x, "y": obj.rotation.y, "z": obj.rotation.z },
                //     obj.userData.modelId,
                //     false,
                //     true,
                // );

                //SOCKET

                const data = {
                    organization,
                    modelUuid: newFloorItem.modelUuid,
                    modelName: newFloorItem.modelName,
                    modelfileID: newFloorItem.modelfileID,
                    position: newFloorItem.position,
                    rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z },
                    isLocked: false,
                    isVisible: true,
                    socketId: socket.id,
                    projectId,userId
                };

                socket.emit("v1:model-asset:add", data);

                itemsGroupRef.current.add(obj);
            }
        });
        echo.success("Object moved!");

        itemsData.current = [];
        clearSelection();
    };

    const clearSelection = () => {
        selectionGroup.current.children = [];
        selectionGroup.current.position.set(0, 0, 0);
        selectionGroup.current.rotation.set(0, 0, 0);
        setpastedObjects([]);
        setDuplicatedObjects([]);
        setMovedObjects([]);
        setRotatedObjects([]);
        setSelectedAssets([]);
        setKeyEvent("");
    };

    return (
        <DistanceFindingControls
            boundingBoxRef={boundingBoxRef}
            object={movedObjects.length}
        />
    );
}

export default MoveControls;
