import { useParams } from "react-router-dom";
import { getUserData } from "../../../../../functions/getUserData";
import { useSceneContext } from "../../../sceneContext";
import { useSocketStore } from "../../../../../store/socket/useSocketStore";
import useWallResponseHandler from "../../../../collaboration/responseHandler/useWallResponseHandler";
import useAisleResponseHandler from "../../../../collaboration/responseHandler/useAisleResponseHandler";
import useFloorResponseHandler from "../../../../collaboration/responseHandler/useFloorResponseHandler";
import useZoneResponseHandler from "../../../../collaboration/responseHandler/useZoneResponseHandler";

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, versionStore } = useSceneContext();
    const { redo2D, peekRedo2D } = undoRedo2DStore();
    const { addWallToScene, removeWallFromScene, updateWallInScene } = useWallResponseHandler();
    const { addAisleToScene, removeAisleFromScene, updateAisleInScene } = useAisleResponseHandler();
    const { addFloorToScene, removeFloorFromScene, updateFloorInScene } = useFloorResponseHandler();
    const { addZoneToScene, removeZoneFromScene, updateZoneInScene } = useZoneResponseHandler();
    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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertWallApi(projectId, selectedVersion?.versionId || "", wallData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error adding wall`);
                            return;
                        }
                        if (data.message === "Wall Created Successfully") {
                            addWallToScene(wallData, () => {
                                echo.info(`Added wall: ${wallData.wallUuid}`);
                            });
                        } else {
                            echo.error(`Error adding wall: ${wallData.wallUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error adding wall: ${wallData.wallUuid}`);
                    });
            } 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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteWallApi(projectId, selectedVersion?.versionId || "", wallUuid)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error removing wall`);
                            return;
                        }
                        if (data.message === "Wall Deleted Successfully") {
                            removeWallFromScene(wallUuid, () => {
                                echo.info(`Removed wall: ${wallUuid}`);
                            });
                        } else {
                            echo.error(`Error removing wall: ${wallUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error removing wall: ${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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertWallApi(projectId, selectedVersion?.versionId || "", updatedData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error updating wall`);
                            return;
                        }
                        if (data.message === "Wall Updated Successfully") {
                            updateWallInScene(updatedData, () => {
                                echo.info(`Updated wall: ${wallUuid}`);
                            });
                        }
                    })
                    .catch(() => {
                        echo.error(`Error updating wall: ${wallUuid}`);
                    });
            } 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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertFloorApi(projectId, selectedVersion?.versionId || "", floorData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error adding floor: ${floorData.floorName}`);
                            return;
                        }
                        if (data.message === "Floor Created Successfully") {
                            addFloorToScene(floorData, () => {
                                echo.info(`Added floor: ${floorData.floorName}`);
                            });
                        } else {
                            echo.error(`Error adding floor: ${floorData.floorName}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error adding floor: ${floorData.floorName}`);
                    });
            } 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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteFloorApi(projectId, selectedVersion?.versionId || "", floorUuid)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error removing floor: ${floorUuid}`);
                            return;
                        }
                        if (data.message === "Floor Deleted Successfully") {
                            removeFloorFromScene(floorUuid, () => {
                                echo.info(`Removed floor: ${floorUuid}`);
                            });
                        } else {
                            echo.error(`Error removing floor: ${floorUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error removing floor: ${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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertFloorApi(projectId, selectedVersion?.versionId || "", updatedData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error updating floor: ${updatedData.floorName}`);
                            return;
                        }
                        if (data.message === "Floor Updated Successfully") {
                            updateFloorInScene(updatedData, () => {
                                echo.info(`Updated floor: ${updatedData.floorName}`);
                            });
                        }
                    })
                    .catch(() => {
                        echo.error(`Error updating floor: ${updatedData.floorName}`);
                    });
            } 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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertZoneApi(projectId, selectedVersion?.versionId || "", zoneData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error adding zone: ${zoneData.zoneName}`);
                            return;
                        }
                        if (data.message === "Zone Created Successfully") {
                            addZoneToScene(zoneData, () => {
                                echo.info(`Added zone: ${zoneData.zoneName}`);
                            });
                        } else {
                            echo.error(`Error adding zone: ${zoneData.zoneName}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error adding zone: ${zoneData.zoneName}`);
                    });
            } 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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                deleteZoneApi(projectId, selectedVersion?.versionId || "", zoneUuid)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error removing zone: ${zoneUuid}`);
                            return;
                        }
                        if (data.message === "Zone Deleted Successfully") {
                            removeZoneFromScene(zoneUuid, () => {
                                echo.info(`Removed zone: ${zoneUuid}`);
                            });
                        } else {
                            echo.error(`Error removing zone: ${zoneUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error removing zone: ${zoneUuid}`);
                    });
            } else {
                // SOCKET

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

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

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

                upsertZoneApi(projectId, selectedVersion?.versionId || "", updatedData)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error updating zone: ${updatedData.zoneName}`);
                            return;
                        }
                        if (data.message === "Zone Updated Successfully") {
                            updateZoneInScene(updatedData, () => {
                                echo.info(`Updated zone: ${updatedData.zoneName}`);
                            });
                        }
                    })
                    .catch(() => {
                        echo.error(`Error updating zone: ${updatedData.zoneName}`);
                    });
            } else {
                // SOCKET

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

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

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

                upsertAisleApi(aisleData.aisleUuid, aisleData.points, aisleData.type, projectId, selectedVersion?.versionId || "")
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error adding aisle`);
                            return;
                        }
                        if (data.message === "Aisle Created Successfully") {
                            addAisleToScene(aisleData, () => {
                                echo.info(`Added aisle: ${aisleData.aisleUuid}`);
                            });
                        } else {
                            echo.error(`Error adding aisle: ${aisleData.aisleUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error adding aisle: ${aisleData.aisleUuid}`);
                    });
            } else {
                // SOCKET

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

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

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

                deleteAisleApi(projectId, selectedVersion?.versionId || "", aisleUuid)
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error removing aisle`);
                            return;
                        }
                        if (data.message === "Aisle Deleted Successfully") {
                            removeAisleFromScene(aisleUuid, () => {
                                echo.info(`Removed aisle: ${aisleUuid}`);
                            });
                        } else {
                            echo.error(`Error removing aisle: ${aisleUuid}`);
                        }
                    })
                    .catch(() => {
                        echo.error(`Error removing aisle: ${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) => {
        if (projectId) {
            if (!builderSocket?.connected) {
                // API

                upsertAisleApi(aisleUuid, updatedData.points, updatedData.type, projectId, selectedVersion?.versionId || "")
                    .then((data) => {
                        if (!data.message || !data.data) {
                            echo.error(`Error updating aisle`);
                            return;
                        }
                        if (data.message === "Aisle Updated Successfully") {
                            updateAisleInScene(updatedData, () => {
                                echo.info(`Updated aisle: ${aisleUuid}`);
                            });
                        }
                    })
                    .catch(() => {
                        echo.error(`Error updating aisle: ${aisleUuid}`);
                    });
            } else {
                // SOCKET

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

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

    return { handleRedo };
}

export default use2DRedoHandler;