import { Request, Response } from "express";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
export class ZoneService {
  static async addandUpdateZone(req: Request, res: Response): Promise<any> {
    try {
      const organization = req.body.organization;
      const zoneDatas = req.body.zonesdata;
      const existingZone = await zoneSchema(organization).findOne({
        zoneId: zoneDatas.zoneId,
        isArchive: false,
      });
      if (!existingZone) {
        const newZone = await zoneSchema(organization).create({
          zoneName: zoneDatas.zoneName,
          zoneId: zoneDatas.zoneId,
          zonePoints: zoneDatas.points,
          viewPortposition: zoneDatas.viewportPosition,
          viewPortCenter: zoneDatas.viewPortCenter,
          createdBy: zoneDatas.userid,
          layer: zoneDatas.layer,
          sceneID: zoneDatas.sceneID,
        });
        if (newZone)
          return res.status(200).json({
            message: "Zone created successfully",
            zoneData: {
              zoneName: newZone.zoneName,
              points: newZone.zonePoints,
              viewPortposition: zoneDatas.viewPortposition,
              viewPortCenter: zoneDatas.viewPortCenter,
            },
          });
      } else {
        const replaceZone = await zoneSchema(organization).findOneAndUpdate(
          { zoneId: zoneDatas.zoneId, isArchive: false },
          {
            zoneName: zoneDatas.zoneName,
            zonePoints: zoneDatas.points,
            viewPortposition: zoneDatas.viewPortposition,
            viewPortCenter: zoneDatas.viewPortCenter,
          },
          { new: true }
        );
        if (!replaceZone)
          return res.status(404).json({ message: "Zone not updated" });
        else
          return res.status(200).json({
            message: "updated successfully",
            zoneData: {
              zoneName: replaceZone.zoneName,
              points: replaceZone.zonePoints,
              viewPortposition: replaceZone.viewPortposition,
              viewPortCenter: replaceZone.viewPortCenter,
            },
          });
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async deleteAZone(req: Request, res: Response): Promise<any> {
    const organization = req.query.organization;
    const zoneId = req.params.zoneId;
    try {
      const existingZone = await zoneSchema(organization).findOne({
        zoneId: zoneId,
        isArchive: false,
      });
      if (!existingZone) {
        return res.status(404).json({ message: "Zone not found for the UUID" });
      } else {
        const deleteZone = await zoneSchema(organization).findOneAndUpdate(
          { zoneId: zoneId, isArchive: false },
          {
            isArchive: true,
          },
          { new: true }
        );

        if (deleteZone) {
          return res.status(200).json({ message: "Zone deleted successfully" });
        }
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async singleZonePanelDatas(req: Request, res: Response): Promise<any> {
    const organization = req.query.organization;
    const zoneId = req.params.zoneId;

    try {
      const existingZone = await zoneSchema(organization)
        .findOne({
          zoneId: zoneId,
          isArchive: false,
        })
        .select(
          "panelOrder zoneName zonePoints lockedPanel zoneId viewPortCenter viewPortposition points"
        );
      if (!existingZone) {
        return res.send({ message: "Zone not found for the UUID" });
      } else {
        const panelData = await panelSchema(organization).find({
          zoneId: zoneId,
          isArchive: false,
        });
        const zoneName = existingZone.zoneName as string;

        const widgets = await Promise.all(
          panelData.map(async (data) => {
            const widgetDataArray = await widgetSchema(organization).find({
              panelID: data._id,
              isArchive: false,
            });

            return widgetDataArray.map((widgetData) => ({
              id: widgetData.widgetID,
              type: widgetData.elementType,
              title: widgetData.widgetName,
              panel: widgetData.widgetside,
              data: widgetData.Data || [],
            }));
          })
        );

        const flattenedWidgets = widgets.flat();

        const objectData = {
          zoneName,
          viewPortposition: existingZone.viewPortposition,
          zoneId: existingZone.zoneId,
          viewPortCenter: existingZone.viewPortCenter,
          activeSides: existingZone.panelOrder || [],
          panelOrder: existingZone.panelOrder || [],
          lockedPanels: existingZone.lockedPanel || [],
          points: existingZone.points || [],
          widgets: flattenedWidgets,
        };

        return res.status(200).json(objectData);
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async vizAllDatas(req: Request, res: Response): Promise<any> {
    const organization = req.query.organization;
    try {
      const existingZones = await zoneSchema(organization)
        .find({
          isArchive: false,
        })
        .select(
          "panelOrder zoneName zonePoints lockedPanel zoneId viewPortCenter viewPortposition points"
        );
      if (!existingZones) {
        return res.send({ message: "Zone not found for the UUID" });
      } else {
        const response = await Promise.all(
          existingZones.map(async (zone) => {
            const panelData = await panelSchema(organization).find({
              zoneId: zone._id,
              isArchive: false,
            });

            const widgets = await Promise.all(
              panelData.map(async (panel) => {
                const widgetDataArray = await widgetSchema(organization).find({
                  panelID: panel._id,
                  isArchive: false,
                });

                return widgetDataArray.map((widget) => ({
                  id: widget.widgetID,
                  type: widget.elementType,
                  title: widget.widgetName,
                  panel: widget.widgetside,
                  data: widget.Data || [],
                }));
              })
            );

            return {
              zoneName: zone.zoneName,
              zoneId: zone.zoneId,
              viewPortposition: zone.viewPortposition,
              viewPortCenter: zone.viewPortCenter,
              activeSides: zone.panelOrder || [],
              panelOrder: zone.panelOrder || [],
              lockedPanels: zone.lockedPanel || [],
              points: zone.points || [],
              widgets: widgets.flat(),
            };
          })
        );

        return res.status(200).json(response);
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async allZones(req: Request, res: Response): Promise<any> {
    const organization = req.query.organization;
    const sceneID = req.params.sceneID || "scene123";
    try {
      const Allzones = await zoneSchema(organization)
        .find({ sceneID: sceneID, isArchive: false })
        .select("zoneName zoneId");

      if (!Allzones || Allzones.length === 0) {
        return res.status(404).json({ message: "Zone not found for the UUID" });
      }
      return res.status(200).json(Allzones);
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async ZoneData(req: Request, res: Response): Promise<any> {
    try {
      console.log("req.params: ", req.params);
      const organization = req.params.organization;
      const zoneId = req.params.zoneId;
      const findZone = await zoneSchema(organization).findOne({
        zoneId: zoneId,
      });

      if (findZone) return res.status(200).json(findZone);
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async lockedPanel(req: Request, res: Response): Promise<any> {
    console.log(req.body);
    const organization = req.body.organization;
    const zoneId = req.body.zoneId;
    const lockedPanel = req.body.lockedPanel;
    try {
      const existingZone = await zoneSchema(organization).findOne({
        zoneId: zoneId,
        isArchive: false,
      });
      if (!existingZone) {
        return res.status(404).json({ message: "Zone not found for the UUID" });
      } else {
        const updateLockedPanel = await zoneSchema(
          organization
        ).findOneAndUpdate(
          { zoneId: zoneId, isArchive: false },
          {
            lockedPanel: lockedPanel,
          },
          { new: true }
        );

        if (updateLockedPanel) {
          return res
            .status(200)
            .json({ message: "locked panel updated successfully" });
        }
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }

  static async getZones(req: Request, res: Response) {
    try {
      const { organization } = req.params;

      const findZoneId = await zoneSchema(organization)
        .find({ isArchive: false })
        .select(
          "zoneId zoneName layer points viewPortCenter viewPortposition -_id"
        );

      if (!findZoneId) {
        res.status(500).json({ message: "Invalid zone" });
      }
      res.status(200).json({ data: findZoneId, organization: organization });
    } catch (error) {
      console.log("error: ", error);
      res.status(500).json({ message: "Zone not found", error });
    }
  }
}