import { Request, Response } from "express";
import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
import pointModel from "../../../shared/model/builder/assets/assetPoint-Model.ts";
import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";

export class AssetsFloorService {
  static async updateAssetPositionRotation(
    req: Request,
    res: Response
  ): Promise<any> {
    try {
      const {
        modelUuid,
        modelName,
        position,
        rotation,
        isLocked,
        isVisible,
        organization,
        // modelfileID, //optional
        // eventData, // Optional
      } = req.body;

      const existingAsset = await assetModel(organization).findOne({
        modelUuid: modelUuid,
        isArchive: false,
      });
      if (!existingAsset) return res.send("Asset not found");
      const updateAsset = await assetModel(organization).updateMany(
        { modelUuid: modelUuid, modelName: modelName, isArchive: false },
        {
          position: position,
          rotation: rotation,
          isVisible: isVisible,
          isLocked: isLocked,
        }
      );
      if (updateAsset)
        return res.status(200).json({ message: "Asset updated successfully" });
    } catch (error: any) {
      return res.send(error.message);
    }
  }
  static async replaceEventDatas(req: Request, res: Response): Promise<any> {
    const { organization, modelUuid, eventData } = req.body;
    try {
      const existingModel = await assetModel(organization).findOne({
        modelUuid: modelUuid,
        isArchive: false,
      });
      if (!existingModel)
        return res.json({ message: "Model not for this UUID" });
      else {
        let speed;
        if (existingModel.type === "Conveyor") {
          speed = eventData?.speed;
        }
        const updatedModel = await assetModel(organization).findOneAndUpdate(
          { modelUuid, isArchive: false },
          {
            points: eventData?.points,
            type: eventData?.type || existingModel?.type,
          },
          { new: true }
        );

        if (updatedModel)
          return res.status(200).json({ message: "Data updated successfully" });
      }
    } catch (error: any) {
      return res.status(500).send(error.message);
    }
  }
  static async setFloorassets(req: Request, res: Response): Promise<any> {
    try {
      const {
        modelUuid,
        modelName,
        position,
        modelfileID,
        rotation,
        isLocked,
        isVisible,
        organization,
        eventData,
      } = req.body;
      console.log("req.body: ", req.body);

      const findvalue = await assetModel(organization).findOne({
        modelUuid,
        // modelName,
        isArchive: false,
      });
      await pointModel(organization).findOne({
        modelfileID: modelfileID,
        isArchive: false,
      });

      if (findvalue) {
        const updatevalue = await assetModel(organization).findOneAndUpdate(
          { modelUuid, isArchive: false },
          {
            modelName: modelName,
            position,
            rotation,
            isVisible,
            isLocked,
          },
          { new: true }
        );
        return res.status(201).json(updatevalue);
      } else {
        let assetData: any = {
          modelUuid,
          modelName,
          position,
          modelfileID,
          rotation,
          isLocked,
          isVisible,
          eventData,
        };

        if (eventData) {
          if (eventData.type === "Conveyor") {
            assetData.speed = eventData.speed;
          } else if (eventData.type === "Vehicle") {
            assetData.speed = eventData.points.speed;
            if (!eventData.points) {
              return res
                .status(400)
                .json({ message: "Vehicle points must be a single object" });
            }
            if (eventData.points.triggers) {
              return res.status(400).json({
                message: "triggers is not allowed for Vehicle points",
              });
            }
          }
          assetData.points = eventData.points;
          assetData.type = eventData.type;
        }
        const assetDoc = await assetModel(organization).create(assetData);
        await assetDoc.save();

        return res.status(201).json({
          message: "Model stored successfully",
          modelId: assetDoc._id,
        });
      }
    } catch (error) {
      console.error("Error creating flooritems:", error);
      res.status(500).json({ message: "Failed to create flooritems" });
    }
  }
  static async getFloorItems(req: Request, res: Response): Promise<any> {
    try {
      const { organization } = req.params;
      const findValues = await assetModel(organization)
        .find({ isArchive: false })
        .select("-_id -isArchive");

      if (!findValues || findValues.length === 0) {
        return res.status(200).json({ message: "floorItems not found" });
      }

      const response = findValues.map((item) => {
        const responseItem: any = {
          modelUuid: item.modelUuid,
          modelName: item.modelName,
          position: item.position,
          rotation: item.rotation,
          modelfileID: item.modelfileID,
          isLocked: item.isLocked,
          isVisible: item.isVisible,
          eventData: item.eventData,
        };
        return responseItem;
      });

      return res.status(200).json(response);
    } catch (error) {
      res.status(500).json({ error: "Failed to get flooritems" });
    }
  }
  static async deleteFloorItems(req: Request, res: Response): Promise<any> {
    try {
      const { modelUuid, modelName, organization } = req.body;

      const asset = await assetModel(organization).findOne({
        modelUuid,
        modelName,
        isArchive: false,
      });

      if (!asset) {
        return res.status(404).json({ message: "Model not found" });
      }

      const archivedAsset = await assetModel(organization).findOneAndUpdate(
        { modelUuid, modelName },
        { $set: { isArchive: true } },
        { new: true }
      );

      if (!archivedAsset) {
        return res.status(500).json({ message: "Failed to archive asset" });
      }

      const updatedEvents = await EventsDataModel(organization).updateMany(
        { modelUuid },
        { $set: { isArchive: true } }
      );

      console.log("Archived asset:", archivedAsset);
      console.log("Updated events:", updatedEvents.modifiedCount);

      return res.status(200).json({ message: "delete Asset successfully" });
    } catch (error) {
      console.error("Error deleting floor items:", error);
      return res.status(500).json({ error: "Failed to delete floor items" });
    }
  }
}