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

export class assetsFloorservice {
  static async setFloorassets(req: Request, res: Response): Promise<any> {
    try {
      const {
        modeluuid,
        modelname,
        position,
        modelfileID,
        rotation,
        isLocked,
        isVisible,
        organization,
        eventData,
      } = req.body;

      const findvalue = await assetModel(organization).findOne({
        modeluuid,
        modelname,
        isArchive: false,
      });
      const checkpointType = await pointModel(organization).findOne({
        modelfileID: modelfileID,
        isArchive: false,
      });

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

        console.log("eventData: ", 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.rotation) {
              return res.status(400).json({
                message: "Rotation is not allowed for Vehicle points",
              });
            }

            if (eventData.points.triggers) {
              return res.status(400).json({
                message: "triggers is not allowed for Vehicle points",
              });
            }
          } 
          // else if(eventData.type === "ArmBot"){
          //   assetData.speed = eventData.position;
          // }else if(eventData.type === "StaticMachine"){
          //   assetData.speed = eventData.position;
          // }

          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) => {
        // console.log("item: ", item);
        // console.log("item: ", item.type);
        // console.log('findValues: ', findValues);
        // console.log("item.points: ", item.points);
        const responseItem: any = {
          modeluuid: item.modeluuid,
          modelname: item.modelname,
          position: item.position,
          rotation: item.rotation,
          modelfileID: item.modelfileID,
          isLocked: item.isLocked,
          isVisible: item.isVisible,
        };
        if (item.type === "Conveyor" && item.points.length > 0) {
          responseItem.eventData = {
            speed: item.speed,
            points: item.points,
            type: item.type,
          };
        }

        if (item.type === "Vehicle" && item.points) {
          responseItem.eventData = {
            type: item.type,
            points: item.points,
          };
        }
        if (item.type === "ArmBot" && item.points) {
          responseItem.eventData = {
            type: item.type,
            points: item.points,
          };
        }
        if (item.type === "StaticMachine" && item.points) {
          responseItem.eventData = {
            type: item.type,
            points: item.points,
          };
        }
        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 findValue = await assetModel(organization).findOneAndDelete({
        modeluuid: modeluuid,
        modelname: modelname,
        isArchive: false,
      });
      if (!findValue) {
        res.status(200).json("user not found");
      } else {
        res.status(201).json(findValue);
      }
    } catch (error) {
      res.status(500).json({ error: "Failed to get flooritems" });
    }
  }
  static async updateAssetPositionRotation(
    req: Request,
    res: Response
  ): Promise<any> {
    try {
      const {
        modeluuid,
        modelname,
        position,
        modelfileID,
        rotation,
        isLocked,
        isVisible,
        organization,
        // 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);
    }
  }
}