import { useParams } from "react-router-dom";
import { getUserData } from "../../../../../functions/getUserData";
import { useSceneContext } from "../../../sceneContext";
import { useSocketStore } from "../../../../../store/builder/store";

import { upsertWallApi } from "../../../../../services/factoryBuilder/wall/upsertWallApi";
import { deleteWallApi } from "../../../../../services/factoryBuilder/wall/deleteWallApi";

import { upsertZoneApi } from "../../../../../services/factoryBuilder/zone/upsertZoneApi";
import { deleteZoneApi } from "../../../../../services/factoryBuilder/zone/deleteZoneApi";

import { upsertFloorApi } from "../../../../../services/factoryBuilder/floor/upsertFloorApi";
import { deleteFloorApi } from "../../../../../services/factoryBuilder/floor/deleteFloorApi";

import { upsertAisleApi } from "../../../../../services/factoryBuilder/aisle/upsertAisleApi";
import { deleteAisleApi } from "../../../../../services/factoryBuilder/aisle/deleteAisleApi";

function use2DRedoHandler() {
    const { undoRedo2DStore, wallStore, floorStore, zoneStore, aisleStore, versionStore } = useSceneContext();
    const { redo2D, peekRedo2D } = undoRedo2DStore();
    const { addWall, removeWall, updateWall } = wallStore();
    const { addFloor, removeFloor, updateFloor } = floorStore();
    const { addZone, removeZone, updateZone } = zoneStore();
    const { addAisle, removeAisle, updateAisle } = aisleStore();
    const { selectedVersion } = versionStore();
    const { userId, organization } = getUserData();
    const { projectId } = useParams();
    const { builderSocket } = useSocketStore();

    const handleRedo = () => {
        const redoData = peekRedo2D();
        if (!redoData) return;

        if (redoData.type === 'Draw') {
            const { actions } = redoData;

            actions.forEach(action => {
                const { actionType } = action;

                if ('point' in action) {
                    const point = action.point;

                    if (actionType === 'Line-Create') {
                        handleCreate(point);
                    } else if (actionType === 'Line-Update') {
                        handleUpdate(point);
                    } else if (actionType === 'Line-Delete') {
                        handleRemove(point);
                    }

                } else if ('points' in action) {
                    const points = action.points;

                    if (actionType === 'Lines-Create') {
                        points.forEach(handleCreate);
                    } else if (actionType === 'Lines-Update') {
                        points.forEach(handleUpdate);
                    } else if (actionType === 'Lines-Delete') {
                        points.forEach(handleRemove);
                    }
                }
            });
        } else if (redoData.type === 'UI') {
            // Handle UI actions if needed
        }

        redo2D();
    };

    const handleCreate = (point: UndoRedo2DDataTypeSchema) => {
        switch (point.type) {
            case 'Wall': createWallFromBackend(point.lineData); break;
            case 'Floor': createFloorFromBackend(point.lineData); break;
            case 'Zone': createZoneFromBackend(point.lineData); break;
            case 'Aisle': createAisleFromBackend(point.lineData); break;
        }
    };

    const handleRemove = (point: UndoRedo2DDataTypeSchema) => {
        switch (point.type) {
            case 'Wall': removeWallFromBackend(point.lineData.wallUuid); break;
            case 'Floor': removeFloorFromBackend(point.lineData.floorUuid); break;
            case 'Zone': removeZoneFromBackend(point.lineData.zoneUuid); break;
            case 'Aisle': removeAisleFromBackend(point.lineData.aisleUuid); break;
        }
    };

    const handleUpdate = (point: UndoRedo2DDataTypeSchema) => {
        if (!point.newData) return;
        switch (point.type) {
            case 'Wall': updateWallFromBackend(point.newData.wallUuid, point.newData); break;
            case 'Floor': updateFloorFromBackend(point.newData.floorUuid, point.newData); break;
            case 'Zone': updateZoneFromBackend(point.newData.zoneUuid, point.newData); break;
            case 'Aisle': updateAisleFromBackend(point.newData.aisleUuid, point.newData); break;
        }
    };

    const createWallFromBackend = (wallData: Wall) => {
        addWall(wallData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertWallApi(projectId, selectedVersion?.versionId || '', wallData);
            } else {

                // SOCKET

                const data = {
                    wallData: wallData,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Wall:add', data);
            }
        }
    };

    const removeWallFromBackend = (wallUuid: string) => {
        removeWall(wallUuid);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteWallApi(projectId, selectedVersion?.versionId || '', wallUuid);
            } else {

                // SOCKET

                const data = {
                    wallUuid: wallUuid,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Wall:delete', data);
            }
        }
    };

    const updateWallFromBackend = (wallUuid: string, updatedData: Wall) => {
        updateWall(wallUuid, updatedData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertWallApi(projectId, selectedVersion?.versionId || '', updatedData);
            } else {

                // SOCKET

                const data = {
                    wallData: updatedData,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Wall:add', data);
            }
        }
    };

    const createFloorFromBackend = (floorData: Floor) => {
        addFloor(floorData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertFloorApi(projectId, selectedVersion?.versionId || '', floorData);
            } else {

                // SOCKET

                const data = {
                    floorData: floorData,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Floor:add', data);
            }
        }
    };

    const removeFloorFromBackend = (floorUuid: string) => {
        removeFloor(floorUuid);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteFloorApi(projectId, selectedVersion?.versionId || '', floorUuid);
            } else {

                // SOCKET

                const data = {
                    floorUuid: floorUuid,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Floor:delete', data);
            }
        }
    };

    const updateFloorFromBackend = (floorUuid: string, updatedData: Floor) => {
        updateFloor(floorUuid, updatedData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertFloorApi(projectId, selectedVersion?.versionId || '', updatedData);
            } else {

                // SOCKET

                const data = {
                    floorData: updatedData,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:model-Floor:add', data);
            }
        }
    };

    const createZoneFromBackend = (zoneData: Zone) => {
        addZone(zoneData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertZoneApi(projectId, selectedVersion?.versionId || '', zoneData);
            } else {

                // SOCKET

                const data = {
                    zoneData: zoneData,
                    projectId: projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId: userId,
                    organization: organization
                }

                builderSocket.emit('v1:zone:add', data);
            }
        }
    };

    const removeZoneFromBackend = (zoneUuid: string) => {
        removeZone(zoneUuid);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteZoneApi(projectId, selectedVersion?.versionId || '', zoneUuid);
            } else {

                // SOCKET

                const data = {
                    zoneUuid,
                    projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId,
                    organization
                };

                builderSocket.emit('v1:zone:delete', data);
            }
        }
    };

    const updateZoneFromBackend = (zoneUuid: string, updatedData: Zone) => {
        updateZone(zoneUuid, updatedData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertZoneApi(projectId, selectedVersion?.versionId || '', updatedData);
            } else {

                // SOCKET

                const data = {
                    zoneData: updatedData,
                    projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId,
                    organization
                };

                builderSocket.emit('v1:zone:add', data);
            }
        }
    };

    const createAisleFromBackend = (aisleData: Aisle) => {
        addAisle(aisleData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertAisleApi(aisleData.aisleUuid, aisleData.points, aisleData.type, projectId, selectedVersion?.versionId || '');
            } else {

                // SOCKET

                const data = {
                    ...aisleData,
                    projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId,
                    organization
                };

                builderSocket.emit('v1:model-aisle:add', data);
            }
        }
    };

    const removeAisleFromBackend = (aisleUuid: string) => {
        removeAisle(aisleUuid);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteAisleApi(projectId, selectedVersion?.versionId || '', aisleUuid);
            } else {

                // SOCKET

                const data = {
                    aisleUuid,
                    projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId,
                    organization
                };

                builderSocket.emit('v1:model-aisle:delete', data);
            }
        }
    };

    const updateAisleFromBackend = (aisleUuid: string, updatedData: Aisle) => {
        updateAisle(aisleUuid, updatedData);
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertAisleApi(updatedData.aisleUuid, updatedData.points, updatedData.type, projectId, selectedVersion?.versionId || '');
            } else {

                // SOCKET

                const data = {
                    ...updatedData,
                    projectId,
                    versionId: selectedVersion?.versionId || '',
                    userId,
                    organization
                };

                builderSocket.emit('v1:model-aisle:add', data);
            }
        }
    };

    return { handleRedo };
}

export default use2DRedoHandler;