import express from "express";
import bodyParser from "body-parser";
import mongoose from "mongoose";
import cors from "cors";
import atob from "atob";

import dotenv from "dotenv";
import multer from "multer";
import helmet from "helmet";
import morgan from "morgan";
import path from "path";
import { fileURLToPath } from "url";
import authRoutes from "./routes/auth.js";
import userRoutes from "./routes/users.js";
import kdsRoutes from "./routes/kds.js";

import Odoo from "odoo-xmlrpc";

// import webemailRoutes from "./routes/webemail.js";
import axios from "axios";
import WebSocket, { WebSocketServer } from "ws";

// import nodemailer from "nodemailer";
// export const ws = new WebSocket("ws://192.168.50.15:4028/sT1eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY2NDE3OTI4MmE3M2ZlZWQ3MjgyM2ViOCIsImlhdCI6MTcxNTY2ODI4Nn0.ziEOLreXbCJRlyjRyIVLDsJNpeIvk73rf3kU7_HtO8E"
//  );
// ws.onopen = () => {
//   console.log("WebSocket connected------------------------------------------");

//   // You can send initial messages after the connection is established if needed
//   // ws.send("Hello, server!");
//   // const userId = "meeeee2";
//   ws.send(JSON.stringify({ type: "join", userId: "obnPay_test" }));

//   // ws.send(encryptedMessage2);
// };
// ws.onclose = () => {
//   console.log("Connection closed");
// };
/* CONFIGURATIONS */
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
dotenv.config();

const app = express();
app.use(express.json());
app.use(helmet());
app.use(helmet.crossOriginResourcePolicy({ policy: "cross-origin" }));
app.use(morgan("common"));
app.use(bodyParser.json({ limit: "30mb", extended: true }));
app.use(bodyParser.urlencoded({ limit: "30mb", extended: true }));
app.use(cors());
app.use("/assets", express.static(path.join(__dirname, "upload_files")));

/* FILE STORAGE */
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const category = req.body.category;
    // if (category == "message") {
    //   cb(null, "message_uploads");
    // } else if (category == "user") {
    //   cb(null, "user_uploads");
    // } else {
    cb(null, "upload_files");
    // }
  },
  filename: (req, file, cb) => {
    const image_id = req.body.image_id;
    cb(null, image_id + "-" + file.originalname);
  },
});

const upload = multer({ storage });

/* ROUTES */
app.use("/api/auth", authRoutes);
app.use("/api/users", userRoutes);
app.use("/api/kds", kdsRoutes);

// app.use("/api/web-emails", webemailRoutes);
app.post("/api/upload_images", upload.single("image"), async (req, res) => {
  try {
    const { filename } = req.file;

    const { image_id, category } = req.body;

    res.status(201).send({ filename, category, image_id });
  } catch (error) {
    res.status(400).send(error);
  }
});
function sendEmail(req, res, next) {
  const apiKey =
    "ODA4MDc4ZThjMDA4NjVhYzU4MTcyNDJjNTMxY2JlZGU6MGQ4ODg3ZTdiZjY1ZWNkMmQ0NzdiOWJhZGIyYTJhY2Q=";
  const apiUrl = "https://api.mailjet.com/v3.1/send";

  // const otp = generateOTP(6); // You should have a function to generate the OTP
  const email2 = "kramblooda@gmail.com";
  const min = 100000; // Minimum 6-digit number
  const max = 999999; // Maximum 6-digit number
  const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
  const requestData = {
    Messages: [
      {
        From: {
          Email: "webdev@obanana.com",
          Name: "Obanana B2B",
        },
        To: [
          {
            Email: req.body.email,
            Name: "Subscriber",
          },
        ],
        Subject: "Obanana OTP",
        TextPart: "Greetings from Obanana!",
        HTMLPart: req.body.html,
      },
    ],
  };

  const config = {
    headers: {
      "Content-Type": "application/json",
      Authorization: `Basic ${apiKey}`,
    },     
  }; 
        
  axios 
    .post(apiUrl, requestData, config)
    .then((response) => {
      // const status = response.data.Messages[0].Status;
      // console.log(response.data.Messages[0].Status);
      // console.log(randomNumber);
      // setotpSent(randomNumber);
      res.status(200).json(response.data);

      // return `${status},${randomNumber}`;
    })
    .catch((error) => {
      res.status(404).json({ message: error });

      // console.error("Error sending OTP email:", error);
      // Handle the error here
    });
}
app.post("/api/send-email/", sendEmail);

// const odooClient = new Odoo({
//   url: "http://192.168.50.15:8070",
//   db: "gis.pivi.com.ph",
//   username: "egalang@obanana.com",
//   password: "P@$$w0rd!",
// }); 
const odooClient2 = new Odoo({  
  url: "http://192.168.50.15:8071",
  db: "pos.obanana.com", 
  username: "mahipe@obanana.com",
  password: "P@$$w0rd!",
});
app.get("/get-assets", async (req, res) => {   
  try {
      const authHeader = req.headers.authorization;
      if (!authHeader || !authHeader.startsWith('Basic ')) {
        return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
      }
  
      const base64Credentials = authHeader.split(' ')[1]; 
      const decodedCredentials = atob(base64Credentials); 
      const [email, password] = decodedCredentials.split(':'); 
  
      if (!email || !password) {
        return res.status(400).json({ error: 'Invalid credentials format.' });
      }
      // console.log(email,password)
  
      const odooClient = new Odoo({
         url: "http://192.168.50.15:8070",
         db: "gis.pivi.com.ph",
        username: email, 
        password: password 
      });

    odooClient.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs 
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient.execute_kw(
        "pivi_assets.pivi_assets",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          const paramsRead = [inParamsRead];

          odooClient.execute_kw(
            "pivi_assets.pivi_assets",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                odooClient.execute_kw(
                  "pivi_assets.attributes",
                  "search",
                  params,
                  async function (err, ids) {
                    if (err) {
                      console.log(err);
                      return res
                        .status(500)
                        .json({ error: "Search Error: " + err.message });
                    }

                    if (ids.length === 0) {
                      return res.json([]); // No assets found
                    }

                    // Fetch asset records

                    const inParamsRead = [];
                    inParamsRead.push(ids); // IDs
                    inParamsRead.push([
                      "id",
                      "name",
                      "value",
                      "asset",
                      "__last_update",
                      "display_name",
                      "create_uid",
                      "create_date",
                      "write_uid",
                      "write_date",
                    ]);

                    const paramsRead = [inParamsRead];

                    odooClient.execute_kw(
                      "pivi_assets.attributes",
                      "read",
                      paramsRead,
                      async function (err2, attr) {
                        if (err2) {
                          console.log(err2);
                          return res
                            .status(500)
                            .json({ error: "Read Error: " + err2.message });
                        } else {
                          attributes = attr;
                          odooClient.execute_kw(
                            "pivi_assets.bounds",
                            "search",
                            params,
                            async function (err, ids) {
                              if (err) {
                                console.log(err);
                                return res.status(500).json({
                                  error: "Search Error: " + err.message,
                                });
                              }

                              if (ids.length === 0) {
                                return res.json([]); // No assets found
                              }

                              // Fetch asset records
                              const inParamsRead = [];
                              inParamsRead.push(ids); // IDs
                              inParamsRead.push([
                                "id",
                                "name",
                                "longitude",
                                "latitude",
                                "asset",
                                "__last_update",
                                "display_name",
                                "create_uid",
                                "create_date",
                                "write_uid",
                                "write_date",
                              ]);
                              const paramsRead = [inParamsRead];

                              odooClient.execute_kw(
                                "pivi_assets.bounds",
                                "read",
                                paramsRead,
                                async function (err2, bound) {
                                  if (err2) {
                                    console.log(err2);
                                    return res.status(500).json({
                                      error: "Read Error: " + err2.message,
                                    });
                                  } else {
                                    bounds = bound;
                                    odooClient.execute_kw(
                                      "ir.attachment",
                                      "search",
                                      params,
                                      async function (err, ids) {
                                        if (err) {
                                          console.log(err);
                                          return res.status(500).json({
                                            error:
                                              "Search Error: " + err.message,
                                          });
                                        }

                                        if (ids.length === 0) {
                                          return res.json([]); // No assets found
                                        }

                                        // Fetch asset records
                                        const inParamsRead = [];
                                        inParamsRead.push(ids); // IDs
                                        inParamsRead.push([
                                          "id",
                                          "name",
                                          "local_url",
                                          "res_id",
                                        ]);
                                        const paramsRead = [inParamsRead];

                                        odooClient.execute_kw(
                                          "ir.attachment",
                                          "read",
                                          paramsRead,
                                          async function (err2, image) {
                                            if (err2) {
                                              console.log(err2);
                                              return res.status(500).json({
                                                error:
                                                  "Read Error: " + err2.message,
                                              });
                                            } else {
                                              images = image;
                                              const inParams = [];
                                              inParams.push([["related_asset", "!=", false]]);
                                              inParams.push(parseInt(req.query.offset) || 0); //offset
                                              inParams.push(parseInt(req.query.limit) || 0); //Limit
                                              const params1 = [inParams];
                                              odooClient.execute_kw(
                                                "pivi_assets.related",
                                                "search",
                                                params1,
                                                async function (err, ids) {
                                                  if (err) {
                                                    console.log(err);
                                                    return res.status(500).json({
                                                      error:
                                                        "Search Error: " + err.message,
                                                    });
                                                  }
          
                                                  if (ids.length === 0) {
                                                    return res.json([]); // No assets found
                                                  }
          
                                                  // Fetch asset records
                                                  const inParamsRead = [];
                                                  inParamsRead.push(ids); // IDs
                                                  inParamsRead.push([
                                                    "id",
                                                    "related_asset",
                                                    "asset",
                                                  ]);
                                                  const paramsRead = [inParamsRead];
          
                                                  odooClient.execute_kw(
                                                    "pivi_assets.related",
                                                    "read",
                                                    paramsRead,
                                                    async function (err2, related) {
                                                      if (err2) {
                                                        console.log(err2);
                                                        return res.status(500).json({
                                                          error:
                                                            "Read Error: " + err2.message,
                                                        });
                                                      } else {
                                                        let relateds
                                                        relateds = related;
          
                                                        const asset = recordsArray.map(
                                                          (item) => {
                                                            // Find matching attributes based on the numeric part of attr.assets
                                                            const matchedAttr =
                                                              attributes.filter(
                                                                (attribute) =>
                                                                  item.attributes.some(
                                                                    (attrId) =>
                                                                      attrId ===
                                                                      attribute.id
                                                                  ) // Compare to the first element of attr.assets
                                                              );
          
                                                            // Find matching bounds based on the numeric part of bounds.assets
                                                            const matchedBounds =
                                                              bounds.filter(
                                                                (bound) =>
                                                                  item.bounds.some(
                                                                    (boundId) =>
                                                                      boundId === bound.id
                                                                  ) // Compare to the first element of bounds.assets
                                                              );
                                                               // Find matching bounds based on the numeric part of bounds.assets
                                                            const matchedRelated =
                                                            relateds.filter(
                                                              (related) =>
                                                                item.related.some(
                                                                  (relatedId) =>
                                                                    relatedId === related.id
                                                                )
                                                            );
          
                                                            // Find matching images based on data.id == images.res_id
                                                            const matchedImages =
                                                              images.filter(
                                                                (image) =>
                                                                  image.res_id === item.id
                                                              );
          
                                                            // Construct the asset object for this item
                                                            return {
                                                              attr: matchedAttr,
                                                              bounds: matchedBounds,
                                                              data: item,
                                                              images: matchedImages,
                                                              related: matchedRelated
                                                            };
                                                          }
                                                        );
                                                        // res.json({
                                                        //   data: recordsArray,
                                                        //   attr: attributes,
                                                        //   bounds: bounds,
                                                        //   images: images,
                                                        // });
                                                        res.json(asset);
                                                      }
          
                                                      let pendingRequests =
                                                        records.length;
                                                    }
                                                  );
                                                }
                                              );
                                            }

                                            let pendingRequests =
                                              records.length;
                                          }
                                        );
                                      }
                                    );
                                  }
                                }
                              );
                            }
                          );
                        }
                      }
                    );
                  }
                );
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-orders", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "pos.order",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "pos.order",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-products", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "product.template",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          inParamsRead.push(["id", "name"]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "product.template",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-product_ordered", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0); //offset
      inParams.push(parseInt(req.query.limit) || 0); //Limit
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "pos.order.line",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "pos.order.line",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
app.get("/get-stages", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0);
      inParams.push(parseInt(req.query.limit) || 0); 
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "kds.stages",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "kds.stages",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});
 
app.post('/update-order-state', async (req, res) => {
  const { id, state } = req.body; 
  if (!id || !state) {
    return res.status(400).json({ error: 'Order ID and state are required.' });
  }

  try {
    odooClient2.connect(function (err) {
      if (err) {
        console.log(err);
        return res.status(500).json({ error: 'Connection Error: ' + err.message });
      }
      console.log('Connected to Odoo server.');

      const inParams = [];
      inParams.push([['id', '=', id]]); 
      const params = [inParams];

      odooClient2.execute_kw('pos.order', 'search', params, function (err, orderIds) {
        if (err) {
          console.log(err);
          return res.status(500).json({ error: 'Search Error: ' + err.message });
        }

        if (orderIds.length === 0) {
          return res.status(404).json({ error: 'Order not found.' });
        }

        const inParamsUpdate = [];
        inParamsUpdate.push(orderIds);
        inParamsUpdate.push({ state: state }); 
        const paramsUpdate = [inParamsUpdate];

        odooClient2.execute_kw('pos.order', 'write', paramsUpdate, function (err2, result) {
          if (err2) {
            console.log(err2);
            return res.status(500).json({ error: 'Update Error: ' + err2.message });
          }

          if (result) {
            return res.json({ success: true, message: `Order ID ${id} updated to state: ${state}` });
          } else {
            return res.status(500).json({ error: 'Failed to update order state.' });
          }
        });
      });
    });
  } catch (error) {
    console.error('Error:', error);
    return res.status(500).json({ error: 'Update Error: ' + error.message });
  }
});
app.get("/get-tables", async (req, res) => {
  try {
    odooClient2.connect(async function (err) {
      if (err) {
        console.log(err);
        return res
          .status(500)
          .json({ error: "Connection Error: " + err.message });
      }
      console.log("Connected to Odoo server.");

      // Fetch asset IDs
      const inParams = [];
      inParams.push([["name", "!=", false]]);
      inParams.push(parseInt(req.query.offset) || 0);
      inParams.push(parseInt(req.query.limit) || 0); 
      const params = [inParams];
      const assets = [];
      let recordsArray = [];

      let attributes = [];
      let bounds = [];
      let images = [];

      odooClient2.execute_kw(
        "restaurant.table",
        "search",
        params,
        async function (err, ids) {
          if (err) {
            console.log(err);
            return res
              .status(500)
              .json({ error: "Search Error: " + err.message });
          }

          if (ids.length === 0) {
            return res.json([]); // No assets found
          }

          // Fetch asset records
          const inParamsRead = [];
          inParamsRead.push(ids); // IDs
          // inParamsRead.push([
          //   "id",
          //   "name",

          // ]);
          const paramsRead = [inParamsRead];

          odooClient2.execute_kw(
            "restaurant.table",
            "read",
            paramsRead,
            async function (err2, records) {
              if (err2) {
                console.log(err2);
                return res
                  .status(500)
                  .json({ error: "Read Error: " + err2.message });
              } else {
                recordsArray = records;
                res.json(recordsArray);
              }

              let pendingRequests = records.length;
            }
          );
        }
      );
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({ error: "Data Fetch Error: " + error.message });
  }
});

app.post('/create-asset-bounds', async (req, res) => {
  try {
    const postData = req.body;

    if (!postData || postData.length === 0) {
      return res.status(200).json({ error: 'No data provided.' });
    }

    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Basic ')) {
      return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
    }

    const base64Credentials = authHeader.split(' ')[1]; 
    const decodedCredentials = Buffer.from(base64Credentials, 'base64').toString('ascii'); // safer than `atob`
    const [email, password] = decodedCredentials.split(':'); 

    if (!email || !password) {
      return res.status(400).json({ error: 'Invalid credentials format.' });
    }

    const odooClient = new Odoo({
      url: "http://192.168.50.15:8070",
       db: "gis.pivi.com.ph",
      username: email, 
      password: password 
    });

    odooClient.connect(async function (err) {
      if (err) {
        console.log(err);
        return res.status(500).json({ error: 'Connection Error: ' + err.message });
      }

      console.log('Connected to Odoo server.');

      // Use Promise.all to wait for all async operations to finish
      try {
        const createdIds = await Promise.all(
          postData.map(async (data, index) => {
            const { asset, name, longitude, latitude } = data;

            if (!asset || !name || !longitude || !latitude) {
              throw new Error(`Missing required fields in entry ${index + 1}`);
            }

            const params = [
              {
                asset: asset,
                name: name,
                longitude: longitude,
                latitude: latitude,
              }
            ];

            // Return a promise for each create operation
            return new Promise((resolve, reject) => {
              odooClient.execute_kw('pivi_assets.bounds', 'create', [params], function (err2, id) {
                if (err2) {
                  console.log('Create Error:', err2);
                  return reject(new Error('Create Error: ' + err2.message));
                }

                resolve(id);
              });
            });
          })
        );

        return res.json({ success: true, createdIds });
      } catch (error) {
        return res.status(500).json({ error: error.message });
      }
    });
  } catch (error) {
    console.error('Error:', error);
    return res.status(500).json({ error: 'Server Error: ' + error.message });
  }
});

app.post('/odoo-webhook', (req, res) => {
  const newOrder = req.body;
  console.log('New POS order received:', newOrder);

  // Process the order data as needed
  // For example, send it to a WebSocket, log it, or store it in a database

  res.status(200).send('Webhook received');
});


app.delete('/delete-asset-bounds', async (req, res) => {
  try {
    const assetId = req.query.asset;
 console.log(assetId)
    if (!assetId) {
      return res.status(400).json({ error: 'Asset ID is required.' });
    }
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Basic ')) {
      return res.status(400).json({ error: 'Authorization header is missing or invalid.' });
    }
    const base64Credentials = authHeader.split(' ')[1]; 
    const decodedCredentials = atob(base64Credentials); 
    const [email, password] = decodedCredentials.split(':'); 

    if (!email || !password) {
      return res.status(400).json({ error: 'Invalid credentials format.' });
    }
    // console.log(email,password)

    const odooClient = new Odoo({
       url: "http://192.168.50.15:8070",
       db: "gis.pivi.com.ph",
      username: email, 
      password: password 
    });
    odooClient.connect(function (err) {
      if (err) {
        console.log(err);
        return res.status(500).json({ error: 'Connection Error: ' + err.message });
      }
      console.log('Connected to Odoo server.');

      
      const inParams = [];
      inParams.push([['id', '=', assetId]]); 
      const searchParamsAsset = [inParams];
      // const searchParamsAsset = [
      //   [['id', '=', assetId]] 
      // ];

      odooClient.execute_kw('pivi_assets.pivi_assets', 'search', searchParamsAsset, function (err2, assetIds) {
        if (err2) {
          console.log(assetIds+" id")
          console.log('Search Error:', err2);
          return res.status(500).json({ error: 'Search Asset Error: ' + err2.message });
        }
        if (assetIds.length === 0) {
          return res.status(404).json({ error: 'Asset not found.' });
        }

        odooClient.execute_kw('pivi_assets.pivi_assets', 'read', [assetIds], function (err3, assets) {
          if (err3) {
            console.log('Read Error:', err3);
            return res.status(500).json({ error: 'Read Error: ' + err3.message });
          }

          const assetName = assets[0].name;

          // const searchParamsBounds = [
          //   [['asset', '=', assetName]]
          // ];
          const inParams = [];
          inParams.push([['asset', '=', assetName]]); 
          const searchParamsBounds = [inParams];

          odooClient.execute_kw('pivi_assets.bounds', 'search', searchParamsBounds, function (err4, boundIds) {
            if (err4) {
              console.log('Search Bounds Error:', err4);
              return res.status(500).json({ error: 'Search Bounds Error: ' + err4.message });
            }

            if (boundIds.length === 0) {
              return res.status(200).json({ error: 'No bounds found for this asset.' });
            }

            odooClient.execute_kw('pivi_assets.bounds', 'read', [[boundIds]], function (err5, bounds) {
              if (err5) {
                console.log('Read Bounds Error:', err5);
                return res.status(500).json({ error: 'Read Bounds Error: ' + err5.message });
              }

              const deletedIds = [];
              bounds.forEach((bound, index) => {
                const boundId = bound.id;

                odooClient.execute_kw('pivi_assets.bounds', 'unlink', [[boundId]], function (err6) {
                  if (err6) {
                    console.log('Unlink Error:', err6);
                    return res.status(500).json({ error: 'Unlink Error: ' + err6.message });
                  }

                  deletedIds.push(boundId);

                  if (deletedIds.length === bounds.length) {
                    return res.json({ success: true, deletedIds });
                  }
                });
              });
            });
          });
        });
      });
    });
  } catch (error) {
    console.error('Error:', error);
    return res.status(500).json({ error: 'Server Error: ' + error.message });
  }
});


// function fetchOdooData(model, method, params) {
//   return new Promise((resolve, reject) => {
//     odooClient.execute_kw(model, method, params, (err, data) => {
//       if (err) return reject(err);
//       resolve(data);
//     });
//   });
// }

/* MONGOOSE SETUP */
const PORT = process.env.PORT || 3002;
// mongoose
//   .connect(process.env.MONGO_URL, {
//     useNewUrlParser: true,
//     useUnifiedTopology: true,
//   })
//   .then(() => {
//     app.listen(PORT, () => console.log(`Server Port: ${PORT}`));

//     // /* ADD DATA ONE TIME */
//   })
//   .catch((error) => console.log(`${error} did not connect`));

mongoose
  .connect(process.env.DATABASE_URL)
  .then(() => {
    app.listen(PORT, () => console.log(`Server Port: ${PORT}`));

    // /* ADD DATA ONE TIME */
  })
  .catch((error) => console.log(`${error} did not connect`));