import * as THREE from "three";
import { useEffect, useMemo, useRef } from "react";
import { useFrame, useThree } from "@react-three/fiber";
import { useSelectedAssets, useSocketStore, useToggleView } from "../../../../../store/builder/store";
import * as Types from "../../../../../types/world/worldTypes";
import { upsertProductOrEventApi } from "../../../../../services/simulation/products/UpsertProductOrEventApi";
import { useParams } from "react-router-dom";
import { useProductContext } from "../../../../simulation/products/productContext";
import { getUserData } from "../../../../../functions/getUserData";
import { useSceneContext } from "../../../sceneContext";
import { useVersionContext } from "../../../../builder/version/versionContext";

// import { setAssetsApi } from '../../../../../services/factoryBuilder/asset/floorAsset/setAssetsApi';

function RotateControls3D({
    rotatedObjects,
    setRotatedObjects,
    movedObjects,
    setMovedObjects,
    pastedObjects,
    setpastedObjects,
    duplicatedObjects,
    setDuplicatedObjects,
    selectionGroup
}: 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 { selectedProductStore } = useProductContext();
    const { selectedProduct } = selectedProductStore();
    const { socket } = useSocketStore();
    const { userId, organization } = getUserData();
    const { projectId } = useParams();
    const { assetStore, eventStore, productStore } = useSceneContext();
    const { updateAsset } = assetStore();
    const AssetGroup = useRef<THREE.Group | undefined>(undefined);
    const { selectedVersionStore } = useVersionContext();
    const { selectedVersion } = selectedVersionStore();

    const updateBackend = (
        productName: string,
        productUuid: string,
        projectId: string,
        eventData: EventsSchema
    ) => {
        upsertProductOrEventApi({
            productName: productName,
            productUuid: productUuid,
            projectId: projectId,
            eventDatas: eventData,
            versionId: selectedVersion?.versionId || '',
        })
    }

    const prevPointerPosition = useRef<THREE.Vector2 | null>(null);

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

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

        const itemsGroup: any = scene.getObjectByName("Asset Group");
        AssetGroup.current = itemsGroup;

        if (!AssetGroup.current) {
            console.error("Asset Group not found in the scene.");
            return;
        }

        let isMoving = false;

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

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

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

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

                setRotatedObjects([]);
            }
        };

        const onKeyDown = (event: KeyboardEvent) => {
            if (pastedObjects.length > 0 || duplicatedObjects.length > 0 || movedObjects.length > 0) return;
            if (event.key.toLowerCase() === "r") {
                if (selectedAssets.length > 0) {
                    rotateAssets();
                }
            }
            if (event.key.toLowerCase() === "escape") {
                event.preventDefault();

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


                setRotatedObjects([]);
            }
        };

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

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

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

            if (point && prevPointerPosition.current) {
                const box = new THREE.Box3();
                rotatedObjects.forEach((obj: THREE.Object3D) => box.expandByObject(obj));
                const center = new THREE.Vector3();
                box.getCenter(center);

                const delta = new THREE.Vector3().subVectors(point, center);
                const prevPointerPosition3D = new THREE.Vector3(prevPointerPosition.current.x, 0, prevPointerPosition.current.y);

                const angle = Math.atan2(delta.z, delta.x) - Math.atan2(prevPointerPosition3D.z - center.z, prevPointerPosition3D.x - center.x);

                selectionGroup.current.rotation.y += -angle;

                selectionGroup.current.position.sub(center);
                selectionGroup.current.position.applyAxisAngle(new THREE.Vector3(0, 1, 0), -angle);
                selectionGroup.current.position.add(center);

                prevPointerPosition.current = new THREE.Vector2(point.x, point.z);
            }
        }
    });

    const rotateAssets = () => {
        const box = new THREE.Box3();
        selectedAssets.forEach((asset: any) => box.expandByObject(asset));
        const center = new THREE.Vector3();
        box.getCenter(center);

        const intersectionPoint = new THREE.Vector3();
        raycaster.setFromCamera(pointer, camera);
        const point = raycaster.ray.intersectPlane(plane, intersectionPoint);

        if (point) {
            prevPointerPosition.current = new THREE.Vector2(point.x, point.z);
        }

        selectedAssets.forEach((asset: any) => {
            selectionGroup.current.attach(asset);
        });

        setRotatedObjects(selectedAssets);
    };

    const placeRotatedAssets = () => {
        if (rotatedObjects.length === 0) return;

        rotatedObjects.forEach(async (obj: THREE.Object3D) => {
            if (obj && AssetGroup.current) {
                const worldPosition = new THREE.Vector3();
                const worldQuaternion = new THREE.Quaternion();

                obj.getWorldPosition(worldPosition);
                obj.getWorldQuaternion(worldQuaternion);

                selectionGroup.current.remove(obj);

                obj.position.copy(worldPosition);
                obj.quaternion.copy(worldQuaternion);

                const newFloorItem: Types.FloorItemType = {
                    modelUuid: obj.userData.modelUuid,
                    modelName: obj.userData.modelName,
                    assetId: obj.userData.assetId,
                    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 = eventStore.getState().getEventByModelUuid(obj.userData.modelUuid);
                    const productData = productStore.getState().getEventByModelUuid(selectedProductStore.getState().selectedProduct.productUuid, obj.userData.modelUuid);

                    if (eventData) {
                        eventStore.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 = productStore.getState().updateEvent(selectedProductStore.getState().selectedProduct.productUuid, obj.userData.modelUuid, {
                            position: [worldPosition.x, worldPosition.y, worldPosition.z],
                            rotation: [obj.rotation.x, obj.rotation.y, obj.rotation.z],
                        })

                        if (event && organization) {
                            updateBackend(
                                selectedProduct.productName,
                                selectedProduct.productUuid,
                                projectId || '',
                                event
                            );
                        }

                        newFloorItem.eventData = eventData;
                    }
                }

                updateAsset(obj.userData.modelUuid, {
                    position: [worldPosition.x, worldPosition.y, worldPosition.z],
                    rotation: [obj.rotation.x, obj.rotation.y, obj.rotation.z],
                });

                //REST

                // await setAssetsApi(
                //     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,
                    assetId: newFloorItem.assetId,
                    position: newFloorItem.position,
                    rotation: { x: obj.rotation.x, y: obj.rotation.y, z: obj.rotation.z },
                    isLocked: false,
                    isVisible: true,
                    socketId: socket.id,
                    versionId: selectedVersion?.versionId || '',
                    projectId,
                    userId
                };

                // console.log('data: ', data);
                socket.emit("v1:model-asset:add", data);

                AssetGroup.current.add(obj);
            }
        });
        echo.success("Object rotated!");

        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([]);
    }

    return null;
}

export default RotateControls3D