import { Server, Socket } from "socket.io";
import { EVENTS } from "./events.ts";
import { createCamera } from "../services/camera/camera-Controller.ts";
import { setEnvironment } from "../services/environments/environments-controller.ts";
import {
  deleteFloorItems,
  setFloorItems,
} from "../services/assets/flooritem-Controller.ts";
import {
  deleteWallItems,
  setWallItems,
} from "../services/assets/wallitem-Controller.ts";
import {
  deleteLineItems,
  deleteLinPoiteItems,
  updateLineItems,
  createLineItems,
  deleteLayer,
} from "../services/lines/line-Controller.ts";
import {
  activeUserOffline,
  activeUsers,
} from "../services/users/user-controller.ts";
import { deleteZone, setZone } from "../services/lines/zone-controller.ts";
import {
  addPanel,
  panelClear,
  panelDelete,
  panelLocked,
} from "../services/visualization/panel-Services.ts";
import {
  addWidget,
  Widgetdelete,
} from "../services/visualization/widget-Services.ts";
import {
  addfloat,
  deletefloat,
  duplicatefloat,
} from "../services/visualization/floatWidget-Service.ts";
import {
  addTemplate,
  addTemplateZone,
  TemplateZoneDelete,
} from "../services/visualization/templateServices.ts";
import {
  deleteAssetModel,
  replaceEventDatas,
  setAssetModel,
} from "../services/assets/asset-Controller.ts";
import {
  add3Dwidget,
  delete3Dwidget,
  update3D,
} from "../services/visualization/3dWidget-Service.ts";
import {
  projectDeleteHandleEvent,
  projectHandleEvent,
  projecUpdateHandleEvent,
} from "../controllers/project/projectController.ts";
import { getUserRole } from "../utils/getUsers.ts";

const cameraHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.setCamera: {
      result = await createCamera(data);

      if (result) {
        const responseEvent = EVENTS.cameraUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    // case EVENTS.deleteWidget: {
    //   const result = await Widgetdelete(data)
    //   if (result) {
    //     // console.log('result?.success: ', result.organization);
    //     const responseEvent = EVENTS.widgetDeleteResponse
    //     // console.log('responseEvent: ', responseEvent);
    //     const organization = result?.organization
    //     // console.log('organization: ', organization);
    //     // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
    //     // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
    //     // console.log('emitTarget: ', emitTarget);
    //     if (organization) {
    //       socket.emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }
  }
};
const EnvironmentHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.setenvironment: {
      result = await setEnvironment(data);

      if (result) {
        const responseEvent = EVENTS.EnvironmentUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    // case EVENTS.deleteWidget: {
    //   const result = await Widgetdelete(data)
    //   if (result) {
    //     // console.log('result?.success: ', result.organization);
    //     const responseEvent = EVENTS.widgetDeleteResponse
    //     // console.log('responseEvent: ', responseEvent);
    //     const organization = result?.organization
    //     // console.log('organization: ', organization);
    //     // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
    //     // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
    //     // console.log('emitTarget: ', emitTarget);
    //     if (organization) {
    //       socket.emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }

    default:
      return;
  }
};
const floorItemsHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  switch (event) {
    case EVENTS.setFloorItems: {
      const result = await setFloorItems(data);
      // console.log('result: ', result);
      if (result.success) {
        io.emit(EVENTS.FloorItemsUpdateResponse, {
          success: true || false,
          message: result.message,
          data: result.data,
          socketId: socket.id,
          organization: result.organization,
        });
      } else {
        // Emit error response
        socket.emit(EVENTS.floorItemError, {
          success: false,
          message: result.message,
          error: result.error,
          socketId: socket.id,
          organization: result.organization,
        });
      }
      break;
    }
    case EVENTS.deleteFloorItems: {
      const result = await deleteFloorItems(data);
      // console.log('result: ', result);
      if (result.success) {
        io.emit(EVENTS.FloorItemsDeleteResponse, {
          success: true || false,
          message: result.message,
          data: result.data,
          socketId: socket.id,
          organization: result.organization,
        });
      } else {
        // Emit error response
        socket.emit(EVENTS.floorItemError, {
          success: false,
          message: result.message,
          error: result.error,
          socketId: socket.id,
          organization: result.organization,
        });
      }
      break;
    }

    default:
    //      console.error(`Unhandled event type: ${event}`);
  }
};
const wallItemsHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.setWallItems: {
      result = await setWallItems(data);

      if (result) {
        const responseEvent = EVENTS.wallItemsUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteWallItems: {
      const result = await deleteWallItems(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.wallItemsDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        // console.log('organization: ', organization);
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        // console.log('emitTarget: ', emitTarget);
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    default:
      return;
  }
};
const lineHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.createLine: {
      result = await createLineItems(data);

      if (result) {
        const responseEvent = EVENTS.createLineResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.updateLine: {
      const result = await updateLineItems(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.updateLineResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        // console.log('organization: ', organization);
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        // console.log('emitTarget: ', emitTarget);
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteLine: {
      const result = await deleteLineItems(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.deleteLineResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        // console.log('organization: ', organization);
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        // console.log('emitTarget: ', emitTarget);
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deletePoint: {
      const result = await deleteLinPoiteItems(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.deletePointResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;

        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    default:
      return;
  }
};
const userStatus = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.connection: {
      result = await activeUsers(data);
      // console.log('result: ', result);

      if (result) {
        const responseEvent = EVENTS.userConnect;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.disconnect: {
      const result = await activeUserOffline(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.userDisConnect;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || "disconnectError",
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    default:
      return;
  }
};
const zoneHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  io: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.setZone: {
      result = await setZone(data);

      if (result) {
        const responseEvent = EVENTS.zoneUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteZone: {
      const result = await deleteZone(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.ZoneDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
  }
};
const panelHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.addPanel: {
      result = await addPanel(data);
      if (result) {
        const responseEvent = EVENTS.panelUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        // console.log('emitTarget: ', emitTarget);

        socket.to(organization).emit(responseEvent, {
          success: result.success,
          message: result.message,
          data: result.data,
          error: result.error,
          socketId: socket.id,
          organization: result.organization,
        });
      }
      break;
    }
    case EVENTS.deletePanel: {
      const result = await panelDelete(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.PanelDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.clearPanel: {
      const result = await panelClear(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.PanelClearResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.lockedPanel: {
      const result = await panelLocked(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.PanelLockedResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    default:
      return;
  }
};
const widgetHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false,
  callback: any
) => {
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.addWidget: {
      result = await addWidget(data, callback);
      // console.log('result: ', result);

      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.widgetUpdateResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteWidget: {
      const result = await Widgetdelete(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.widgetDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;

        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    default:
      return;
  }
};
const floatHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false,
  callback: any
) => {
  // console.log('data: ', data);
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.addFloat: {
      result = await addfloat(data);
      // console.log('result: ', result);

      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.floatUpdateResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteFloat: {
      const result = await deletefloat(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.floatDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.duplicatefloat: {
      const result = await duplicatefloat(data, callback);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.duplicatefloatUpdateResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    default:
      return;
  }
};
const templateHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false
) => {
  // console.log('data: ', data);
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.addTemplate: {
      result = await addTemplate(data);

      if (result) {
        const responseEvent = EVENTS.templateUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.addTemplateZone: {
      const result = await addTemplateZone(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.addTemplateZoneResponse;
        // console.log('responseEvent: ', responseEvent
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.deleteTemplate: {
      const result = await TemplateZoneDelete(data);
      if (result) {
        // console.log('result?.success: ', result.organization);
        const responseEvent = EVENTS.TemplateDeleteResponse;
        // console.log('responseEvent: ', responseEvent);
        const organization = result?.organization;
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    default:
      return;
  }
};
const Widget3DHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false,
  callback: any
) => {
  // console.log('data: ', data);
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.add3DWidget: {
      result = await add3Dwidget(data, callback);

      if (result) {
        const responseEvent = EVENTS.widget3DUpdateResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.update3dPosition: {
      result = await update3D(data);

      if (result) {
        const responseEvent = EVENTS.update3dPositionResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }
    case EVENTS.delete3DWidget: {
      result = await delete3Dwidget(data);

      if (result) {
        const responseEvent = EVENTS.widget3DDeleteResponse;
        const organization = result?.organization;
        // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
        // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
        if (organization) {
          socket.to(organization).emit(responseEvent, {
            success: result.success,
            message: result.message,
            data: result.data,
            error: result.error || null,
            socketId: socket.id,
            organization,
          });
        } else {
          console.warn(`Organization missing in response for event: ${event}`);
        }
      }
      break;
    }

    // case EVENTS.deleteWidget: {
    //   const result = await Widgetdelete(data)
    //   if (result) {
    //     // console.log('result?.success: ', result.organization);
    //     const responseEvent = EVENTS.widgetDeleteResponse
    //     // console.log('responseEvent: ', responseEvent);
    //     const organization = result?.organization
    //     // console.log('organization: ', organization);
    //     // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
    //     // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
    //     // console.log('emitTarget: ', emitTarget);
    //     if (organization) {
    //       socket.emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }

    default:
      return;
  }
};
const modelAssetHandleEvent = async (
  event: string,
  socket: Socket,
  data: any,
  namespace: any,
  notifySender: boolean = false
) => {
  // console.log('data: ', data);
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }

  let result;
  switch (event) {
    case EVENTS.setAssetModel:
      result = await setAssetModel(data);
      if (result)
        emitEventResponse(
          socket,
          result.organization,
          EVENTS.assetUpdateResponse,
          result
        );
      break;
    case EVENTS.deleteAssetModel:
      result = await deleteAssetModel(data);
      if (result)
        emitEventResponse(
          socket,
          result.organization,
          EVENTS.assetDeleteResponse,
          result
        );
      break;
    case EVENTS.assetEventData:
      result = await replaceEventDatas(data);
      if (result)
        emitEventResponse(
          socket,
          result.organization,
          EVENTS.assetEventDataResponse,
          result
        );
      break;
    // case EVENTS.setAssetModel: {
    //   result = await setAssetModel(data);

    //   if (result) {
    //     const responseEvent = EVENTS.assetUpdateResponse
    //     const organization = result?.organization
    //     // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
    //     // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
    //     if (organization) {
    //       socket.to(organization).emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }
    // case EVENTS.deleteAssetModel: {
    //   const result = await deleteAssetModel(data)
    //   if (result) {
    //     // console.log('result?.success: ', result.organization);
    //     const responseEvent = EVENTS.assetDeleteResponse
    //     // console.log('responseEvent: ', responseEvent);
    //     const organization = result?.organization
    //     if (organization) {
    //       socket.to(organization).emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }
    // case EVENTS.assetEventData: {
    //   const result = await replaceEventDatas(data)
    //   if (result) {
    //     // console.log('result?.success: ', result.organization);
    //     const responseEvent = EVENTS.assetEventDataResponse
    //     // console.log('responseEvent: ', responseEvent);
    //     const organization = result?.organization
    //     if (organization) {
    //       socket.to(organization).emit(responseEvent, {
    //         success: result.success,
    //         message: result.message,
    //         data: result.data,
    //         error: result.error || null,
    //         socketId: socket.id,
    //         organization,
    //       });
    //     } else {
    //       console.warn(`Organization missing in response for event: ${event}`);
    //     }
    //   }
    //   break
    // }
    default:
      return;
  }
};
const simulationHandleEvent = async (
  event: string,
  socket: Socket,
  data: any
) => {
  // console.log('data: ', data);
  if (!data?.organization) {
    console.warn(`Missing organization for event: ${event}`);
    return;
  }
  let result;
  try {
    switch (event) {
      case EVENTS.setAssetModel:
        result = await addTemplate(data);
        if (result)
          emitEventResponse(
            socket,
            result.organization,
            EVENTS.zoneUpdateResponse,
            result
          );
        break;
      default:
        console.warn(`❌ Unknown event received: ${event}`);
    }
  } catch (error) {
    console.error(`❌ Error handling event ${event}:`, error);
  }
};
const emitEventResponse = (
  socket: Socket,
  organization: string,
  event: string,
  result: any
) => {
  if (organization) {
    socket.to(organization).emit(event, {
      success: result.success,
      message: result.message,
      data: result.data,
      error: result.error || null,
      socketId: socket.id,
      organization,
    });
  } else {
    console.warn(`Organization missing in response for event: ${event}`);
  }
};
interface UserSocketInfo {
  socketId: string;
  userId: string;
  role: string; // e.g., "admin" or "user"
}

const connectedUsersByOrg: { [organization: string]: UserSocketInfo[] } = {};

export const initSocketServer = (httpServer: any) => {
  const io = new Server(httpServer, {
    cors: {
      origin: "*", // Allow CORS for all origins (adjust in production)
      methods: ["GET", "POST"],
    },
  });

  // 🔹 Create different namespaces
  const namespaces = {
    Builder: io.of("/Builder"),
    visualization: io.of("/Visualization"),
    project: io.of("/project"),
  };

  // const onlineUsers = new Map<string, Set<string>>();
  const onlineUsers: { [organization: string]: Set<string> } = {};

  const handleNamespace = (
    namespaceName: string,
    namespace: any,
    ...eventHandlers: Function[]
  ) => {
    namespace.on("connection", async (socket: Socket) => {
      // const organization = socket.handshake.query.organization as string;
      // const email = socket.handshake.query.email as string;
      const { organization, email, userId } = socket.handshake.auth;
      // console.log(' socket.handshake.auth: ', socket.handshake.auth);

      if (organization) {
        socket.join(organization);
        // console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
      }
      // Handle all events
      if (organization && email) {
        if (!onlineUsers[organization]) {
          onlineUsers[organization] = new Set();
        }
        onlineUsers[organization].add(socket.id);
      }

      const role = await getUserRole(userId, organization);
      // console.log('role: ', role);
      if (role === "Admin") {
        socket.join(`${organization}_admins`);
      }
      // Save user info somewhere
      if (organization && userId && role) {
        if (!connectedUsersByOrg[organization]) {
          connectedUsersByOrg[organization] = [];
        }

        connectedUsersByOrg[organization].push({
          socketId: socket.id,
          userId,
          role,
        });

        // console.log(`🔗 User connected: ${userId} with role ${role} in ${organization}`);
        // console.log("🧩 connectedUsersByOrg: ", connectedUsersByOrg);
      } else {
        // console.warn(`❌ Cannot store user. Missing data:`,);
      }

      userStatus(EVENTS.connection, socket, socket.handshake.auth, socket);
      socket.onAny((event: string, data: any, callback: any) => {
        eventHandlers.forEach((handler) =>
          handler(event, socket, io, data, connectedUsersByOrg, callback)
        );
      });

      // Handle disconnection
      socket.on("disconnect", () => {
        onlineUsers[organization]?.delete(socket.id);
        if (onlineUsers[organization]?.size === 0)
          delete onlineUsers[organization];
        userStatus(EVENTS.disconnect, socket, socket.handshake.auth, socket);
        connectedUsersByOrg[organization] = connectedUsersByOrg[
          organization
        ].filter((u) => u.socketId !== socket.id);
      });

      // Handle reconnection (Auto rejoin)
      socket.on("reconnect", (attempt: number) => {
        // console.log(`🔄 Socket ${socket.id} reconnected to ${namespaceName} (Attempt ${attempt})`);
        if (organization) {
          socket.join(organization);
          // console.log(`♻️ Rejoined room: ${organization}`);
        }
      });
    });
  };

  handleNamespace(
    "Builder",
    namespaces.Builder,
    userStatus,
    modelAssetHandleEvent,
    cameraHandleEvent,
    EnvironmentHandleEvent,
    wallItemsHandleEvent,
    lineHandleEvent,
    zoneHandleEvent
  );
  handleNamespace(
    "Visualization",
    namespaces.visualization,
    panelHandleEvent,
    widgetHandleEvent,
    floatHandleEvent,
    templateHandleEvent,
    Widget3DHandleEvent
  );
  handleNamespace(
    "project",
    namespaces.project,
    projectHandleEvent,
    projectDeleteHandleEvent,
    projecUpdateHandleEvent
  );
  return io;
};