//Get the data models
const { Supplier, DeliveryBoy } = require("../models/supplier");
const { FriendRequest } = require("../models/supplier");
const { ProfilePicture, User } = require("../models/User");
const supplierController = require("../controllers/supplierController");
const customJwtAuth = require("../customAuthJwt");
const fastify = require("fastify")({
  logger: true,
  //disableRequestLogging: true,
  genReqId(req) {
    // you get access to the req here if you need it - must be a synchronous function
    return uuidv4();
  },
});

const fastifyEnv = require("fastify-env");

const boom = require("boom");
const emailValidator = require("email-validator");
const libphonenumberjs = require("libphonenumber-js");

fastify.register(customJwtAuth);

const schema = {
  type: "object",
  required: ["PORT"],
  properties: {
    PORT: {
      type: "string",
      default: 3000,
    },
    APIVERSION: {
      type: "string",
      default: "1.0.0",
    },
  },
};

const options = {
  confKey: "config", // optional, default: 'config'
  schema: schema,
  // data: data // optional, default: process.env
};
fastify.register(fastifyEnv, options).ready((err) => {
  if (err) console.error(err);

  console.log(fastify.config.PORT); // or fastify[options.confKey]
  // output: { PORT: 3000 }
  fastify.decorate("conf", {
    port: fastify.config.PORT,
    APIVERSION: fastify.config.APIVERSION,
  });
});

const apiversion = "1.0.0";

// fastify.register(require('fastify-cookie'))
// fastify.register(require('fastify-session'), {
//   secret: 'my-secret-key',
//   cookie: { secure: true }
// });

isSupplierFormUrlEncoded = (req) => {
  var isSupplierFormUrlEncoded = false;
  console.log("check is Supplier encoe url funtion");
  // This iterates through the req headers object.
  // could not access req.headers.content-type due to the hyphen in the content-type key.
  // console.log(`${key}: ${value}`);
  for (const [key, value] of Object.entries(req.headers)) {
    if (`${key}` === "content-type") {
      if (`${value}` == "application/x-www-form-urlencoded") {
        // console.log( "data supplied is with content type," , `${value}`)
        // set isUserFormUrlEncoded value to true
        isSupplierFormUrlEncoded = true;

        // create user object with form variables . Password is used from the request object directly.
        s_data = {
          suppliername: req.body.suppliername,
          phone: req.body.phone,
          office_address: req.body.office_address,
          password: req.body.password,
          emails: [
            {
              email: req.body.email,
            },
          ],
          profile: {
            firstName: req.body.firstName,
            lastName: req.body.lastName,
          },
        };

        return {
          isSupplierFormUrlEncoded: isSupplierFormUrlEncoded,
          supplier: s_data,
        };
      } else {
        return { isSupplierFormUrlEncoded: false, s_data: "" };
      }
    }
  }
};

fastify.register((fastify, opts, done) => {
  fastify.addContentTypeParser(
    "application/json",
    { parseAs: "buffer" },
    function (_req, body, done) {
      try {
        done(null, body);
      } catch (error) {
        error.statusCode = 400;
        done(error, undefined);
      }
    }
  );

  done(null);
});

//Login Supplier Handler
exports.loginSupplier = async (request, reply) => {
  loginObject = await supplierController.loginSupplier(request);
  console.log("loginObject...", loginObject);
  if (loginObject.same) {
    const phoneVerified = loginObject.supplier.phoneVerified;
    const oneTimePasswordSetFlag = loginObject.supplier.oneTimePasswordSetFlag;
    console.log(
      "oneTimePasswordSetFlag is ......",
      oneTimePasswordSetFlag,
      typeof oneTimePasswordSetFlag,
      typeof phoneVerified
    );
    if (!phoneVerified) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: false,

          phone: loginObject.supplier.phone,
          oneTimePasswordSetFlag: oneTimePasswordSetFlag,
          message: "Please Verify your phone number",
        },
      });
    } else if (oneTimePasswordSetFlag) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: phoneVerified,
          phone: loginObject.supplier.phone,
          oneTimePasswordSetFlag: true,
          message: "Password must be reset",
        },
      });
    } else {
      const token = fastify.jwt.sign(
        {
          suppliername: loginObject.supplier.suppliername,
          supplierId: loginObject.supplier._id,
          roles: loginObject.supplier.profile.role,
        },
        //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
        //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
        //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
        { expiresIn: "30d" }
      );
      console.log(token, "..token");

      var arr = loginObject.supplier.profile.role;
      var arrayToString = JSON.stringify(Object.assign({}, arr)); // convert array to string
      var stringToJsonObject = JSON.parse(arrayToString); // convert string to json object
      var s_id = loginObject.supplier.supplierId;

      console.log(s_id, "supplierId");
      var profilePicture = await ProfilePicture.findOne({ supplierId: s_id });

      // request.session.set('supplierId', loginObject.supplier._id)

      if (!profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,

            email: loginObject.supplier.emails,
            phone: loginObject.supplier.phone,
            supplierId: loginObject.supplier.supplierId,
            suppliername: loginObject.supplier.suppliername,
            office_address: loginObject.supplier.profile.office_address,
            phoneVerified: loginObject.supplier.phoneVerified,
            oneTimePasswordSetFlag: loginObject.supplier.oneTimePasswordSetFlag,
            latitude: loginObject.supplier.latitude,
            longitude: loginObject.supplier.longitude,
            type: loginObject.supplier.profile.role,
            typeasobj: stringToJsonObject,
          },
        });
      }
      if (profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,
            picture: profilePicture.picture,
            email: loginObject.supplier.emails,
            phone: loginObject.supplier.phone,
            supplierId: loginObject.supplier.supplierId,
            suppliername: loginObject.supplier.suppliername,
            office_address: loginObject.supplier.profile.office_address,
            phoneVerified: loginObject.supplier.phoneVerified,
            oneTimePasswordSetFlag: loginObject.supplier.oneTimePasswordSetFlag,
            latitude: loginObject.supplier.latitude,
            longitude: loginObject.supplier.longitude,
            type: loginObject.supplier.profile.role,
            typeasobj: stringToJsonObject,
          },
        });
      }
    }
  } else {
    error = {
      simplydata: {
        error: true,
        code: 400,
        message: "Invalid SupplierId , Password supplied",
      },
    };
    reply.send(error);
  }
};

//Login Delivery  Handler
exports.loginDeliveryBoy = async (request, reply) => {
  phone = request.body.phone;
  phoneVerificationCode = request.body.phoneVerificationCode;

  // check if user exists in the system. If user exists , display message that
  // username is not available
  console.log(
    "this is the phone and verification code",
    phone,
    phoneVerificationCode
  );
  deliveryBoyExists = await DeliveryBoy.findOne({
    phone: phone,
    phoneVerified: false,
    phoneVerificationCode: phoneVerificationCode,
  });
  console.log(deliveryBoyExists);
  if (deliveryBoyExists) {
    // update the phoneVerified flag to true.
    const filter = {
      phone: phone,
      phoneVerificationCode: phoneVerificationCode,
    };
    const update = { phoneVerified: true };
    const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
    updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });
  }
  loginObject = await supplierController.loginDeliveryBoy(request);
  console.log("loginObject...", loginObject);
  if (loginObject.same) {
    const phoneVerified = loginObject.delivery.phoneVerified;
    const oneTimePasswordSetFlag = loginObject.delivery.oneTimePasswordSetFlag;
    console.log(
      "oneTimePasswordSetFlag is ......",
      oneTimePasswordSetFlag,
      typeof oneTimePasswordSetFlag,
      typeof phoneVerified
    );
    if (!phoneVerified) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: false,

          phone: loginObject.delivery.phone,
          oneTimePasswordSetFlag: oneTimePasswordSetFlag,
          message: "Please Verify your phone number",
        },
      });
    } else if (oneTimePasswordSetFlag) {
      reply.send({
        simplydata: {
          error: false,
          phoneVerified: phoneVerified,
          phone: loginObject.delivery.phone,
          oneTimePasswordSetFlag: true,
          message: "Password must be reset",
        },
      });
    } else {
      const token = fastify.jwt.sign(
        {
          deliveryBoyname: loginObject.delivery.name,
          deliveryBoyId: loginObject.delivery._id,
        },
        //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
        //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
        //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
        { expiresIn: "30d" }
      );
      console.log(token, "..token");

      var d_id = loginObject.delivery._id;

      console.log(d_id, "deliveryId");
      var profilePicture = await ProfilePicture.findOne({
        deliveryBoyId: d_id,
      });

      // request.session.set('supplierId', loginObject.supplier._id)

      if (!profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,

            phone: loginObject.delivery.phone,
            deliveryBoyId: loginObject.delivery.deliveryBoyId,
            deliveryBoyname: loginObject.delivery.name,
            address: loginObject.delivery.address,
            phoneVerified: loginObject.delivery.phoneVerified,
            oneTimePasswordSetFlag: loginObject.delivery.oneTimePasswordSetFlag,
            supplierId: loginObject.delivery.supplierId,
            suppliername: loginObject.delivery.suppliername,
            longitude: loginObject.delivery.longitude,
            latitude: loginObject.delivery.latitude,
          },
        });
      }
      if (profilePicture) {
        reply.send({
          simplydata: {
            error: false,
            apiversion: fastify.config.APIVERSION,
            access_token: token,
            picture: profilePicture.picture,
            phone: loginObject.delivery.phone,
            deliveryBoyId: loginObject.delivery.deliveryBoyId,
            deliveryBoyname: loginObject.delivery.name,
            address: loginObject.delivery.address,
            phoneVerified: loginObject.delivery.phoneVerified,
            oneTimePasswordSetFlag: loginObject.delivery.oneTimePasswordSetFlag,
            supplierId: loginObject.delivery.supplierId,
            suppliername: loginObject.delivery.suppliername,
            longitude: loginObject.delivery.longitude,
            latitude: loginObject.delivery.latitude,
          },
        });
      }
    }
  } else {
    error = {
      simplydata: {
        error: true,
        code: 400,
        message: "Invalid Details",
      },
    };
    reply.send(error);
  }
};

exports.deliveryBoyVerifyPhone = async (req, reply) => {
  console.log("-------------------------------------------------");
  try {
    phone = req.body.phone;
    phoneVerificationCode = req.body.phoneVerificationCode;

    // check if user exists in the system. If user exists , display message that
    // username is not available
    console.log(
      "this is the phone and verification code",
      phone,
      phoneVerificationCode
    );
    deliveryBoyExists = await DeliveryBoy.findOne({
      phone: phone,
      //phoneVerified: false,
      phoneVerificationCode: phoneVerificationCode,
    });
    console.log(deliveryBoyExists);
    if (deliveryBoyExists) {
      // update the phoneVerified flag to true.
      const filter = {
        phone: phone,
        phoneVerificationCode: phoneVerificationCode,
      };
      const update = { phoneVerified: true };
      const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
      updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });

      if (updatedDeliveryBoy.phoneVerified) {
        loginObject = await supplierController.loginDeliveryBoy(req);
        console.log("loginObject...", loginObject);
        if (loginObject.same) {
          const phoneVerified = loginObject.delivery.phoneVerified;
          const oneTimePasswordSetFlag =
            loginObject.delivery.oneTimePasswordSetFlag;
          console.log(
            "oneTimePasswordSetFlag is ......",
            oneTimePasswordSetFlag,
            typeof oneTimePasswordSetFlag,
            typeof phoneVerified
          );
          if (!phoneVerified) {
            reply.send({
              simplydata: {
                error: false,
                phoneVerified: false,

                phone: loginObject.delivery.phone,
                oneTimePasswordSetFlag: oneTimePasswordSetFlag,
                message: "Please Verify your phone number",
              },
            });
          } else if (oneTimePasswordSetFlag) {
            reply.send({
              simplydata: {
                error: false,
                phoneVerified: phoneVerified,
                phone: loginObject.delivery.phone,
                oneTimePasswordSetFlag: true,
                message: "Password must be reset",
              },
            });
          } else {
            const token = fastify.jwt.sign(
              {
                deliveryBoyname: loginObject.delivery.name,
                deliveryBoyId: loginObject.delivery._id,
              },
              //expiresIn: expressed in seconds or a string describing a time span zeit/ms. Eg: 60, "2 days", "10h", "7d".
              //A numeric value is interpreted as a seconds count. If you use a string be sure you provide the time units (days, hours, etc),
              //otherwise milliseconds unit is used by default ("120" is equal to "120ms").
              { expiresIn: "30d" }
            );
            console.log(token, "..token");

            var d_id = loginObject.delivery._id;

            console.log(d_id, "deliveryId");
            var profilePicture = await ProfilePicture.findOne({
              deliveryBoyId: d_id,
            });

            // request.session.set('supplierId', loginObject.supplier._id)

            if (!profilePicture) {
              reply.send({
                simplydata: {
                  error: false,
                  apiversion: fastify.config.APIVERSION,
                  access_token: token,

                  phone: loginObject.delivery.phone,
                  deliveryBoyId: loginObject.delivery.deliveryBoyId,
                  deliveryBoyname: loginObject.delivery.name,
                  address: loginObject.delivery.address,
                  phoneVerified: loginObject.delivery.phoneVerified,
                  oneTimePasswordSetFlag:
                    loginObject.delivery.oneTimePasswordSetFlag,
                  supplierId: loginObject.delivery.supplierId,
                  suppliername: loginObject.delivery.suppliername,
                  longitude: loginObject.delivery.longitude,
                  latitude: loginObject.delivery.latitude,
                },
              });
            }
            if (profilePicture) {
              reply.send({
                simplydata: {
                  error: false,
                  apiversion: fastify.config.APIVERSION,
                  access_token: token,
                  picture: profilePicture.picture,
                  phone: loginObject.delivery.phone,
                  deliveryBoyId: loginObject.delivery.deliveryBoyId,
                  deliveryBoyname: loginObject.delivery.name,
                  address: loginObject.delivery.address,
                  phoneVerified: loginObject.delivery.phoneVerified,
                  oneTimePasswordSetFlag:
                    loginObject.delivery.oneTimePasswordSetFlag,
                  supplierId: loginObject.delivery.supplierId,
                  suppliername: loginObject.delivery.suppliername,
                  longitude: loginObject.delivery.longitude,
                  latitude: loginObject.delivery.latitude,
                },
              });
            }
          }
        } else {
          error = {
            simplydata: {
              error: true,
              code: 400,
              message: "Invalid Details",
            },
          };
          reply.send(error);
        }
      } 
    }else {
      error = {
        armintatankdata: {
          error: true,
          code: 10005,
          message: "10005 - Verification code entered cannot be validated.",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Check if all the required fields are supplied by the user

exports.fieldCheck = async (req, reply) => {
  try {
    s_Data = {
      suppliername: req.body.suppliername,
      emails: req.body.emails,
      password: req.body.password,
      services: { password: { bcrypt: req.body.password } },
      phone: req.body.phone,
      profile: {
        firstName: req.body.firstName,
        lastName: req.body.lastName,
        contactNumber: req.body.phone,
        alternativeContactNumber: req.body.alternativeContactNumber,
        country: req.body.country,
        state: req.body.state,
        city: req.body.city,
        office_address: req.body.office_adress,
        zip: req.body.zip,
      },
    };

    var supplier = new Supplier(s_Data);

    console.log(supplier, "..supplier");
    //password is not at the top level in the collection.
    password = req.body.password;

    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
      password = suppliertobeInserted.password;
    }
    console.log(
      "User to be inserted is ",
      supplier.suppliername,
      password,
      supplier.phone,
      supplier.profile
    );
    // check if all rerquired fields are passed.
    if (
      !(
        supplier.suppliername &&
        password &&
        supplier.phone &&
        // user.profile.firstName &&
        // user.profile.lastName &&
        // user.profile.address1 &&
        supplier.emails[0].email
      )
    ) {
      console.log(
        supplier.suppliername,
        password,
        supplier.phone,
        // user.profile.firstName,
        // user.profile.lastName,
        supplier.emails[0].email
      );
      // Required Fields are missing
      suppliedvalues =
        supplier.suppliername +
        " ," +
        password +
        " ," +
        supplier.phone +
        " ," +
        supplier.firstName +
        " ," +
        supplier.lastName +
        " ," +
        supplier.emails[0].email;
      error = {
        armintatankdata: {
          error: true,
          code: 10004,
          message:
            "10004 - suppliername, password, phone , firstname , lastname email city country state address1 and zip are required fields. Supplied values are " +
            suppliedvalues,
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.validatePhoneFormat = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);

    // check if user supplied phone is of the right format.
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    console.log(checkFormEncoding);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplierser.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplier.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    if (supplier) {
      const phoneNumber = libphonenumberjs.parsePhoneNumber(supplier.phone);
      if (phoneNumber) {
        // access returned collection
        if (!phoneNumber.isValid()) {
          error = {
            armintatankdata: {
              error: true,
              code: 10002,
              message:
                "10002 - Phone # " +
                supplier.phone +
                " is not a valid phone number",
            },
          };
          req.body.regError = error;
          reply.status(406).send(error);
        }
      }
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.verifySupplier = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplierr.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    phone = supplier.phone;
    supplierpass = req.body.password;

    // check if user exists in the system. If user exists , display message that
    // phone number is not available

    supplierExists = await Supplier.findOne({ phone: phone });
    if (supplierExists) {
      // return user exists message
      error = {
        armintatankdata: {
          error: true,
          code: 10001,
          message:
            "10001 - Phone " +
            supplierExists.phone +
            " is not available. please use a different phone number",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.validateEmailFormat = async (req, reply) => {
  try {
    var supplier = new Supplier(req.body);
    // Handle if the user data is supplied via a url encoded form
    // capture fields if data is sent via form instead of json encoding

    checkFormEncoding = isSupplierFormUrlEncoded(req);
    if (checkFormEncoding.isSupplierFormUrlEncoded) {
      suppliertobeInserted = checkFormEncoding.supplier;
      supplier.suppliername = suppliertobeInserted.suppliername;
      supplier.firstName = suppliertobeInserted.firstName;
      supplier.lastName = suppliertobeInserted.lastName;
      supplierr.phone = suppliertobeInserted.phone;
      supplier.emails = suppliertobeInserted.emails;
    }
    supplieremail = await supplier.emails[0].email;
    // check if user supplied email is of the right format.
    if (supplier) {
      const isValidEmail = emailValidator.validate(supplieremail.trim());
      if (!isValidEmail) {
        // Return email invalid format message
        error = {
          armintatankdata: {
            error: true,
            code: 10003,
            message:
              "10003 - Email " +
              supplier.emails[0].email +
              " is not a valid email",
          },
        };
        req.body.regError = error;
        reply.send(error);
      }
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.logoutsupplier = async (request, reply) => {
  // request.session.delete();

  // // send response to clear token
  // reply.send({ message: 'Successfully logged out' })

  const invalidatedTokens = {};
  const accessToken =
    request.headers.authorization && request.body.access_token;
  invalidatedTokens[accessToken] = true;

  //   // localStorage.removeItem(invalidatedTokens[accessToken])

  reply.send({ message: "Logout successful" });
};

exports.verifyPhone = async (req, reply) => {
  console.log("-------------------------------------------------");
  try {
    phone = req.body.phone;
    phoneVerificationCode = req.body.phoneVerificationCode;

    // check if user exists in the system. If user exists , display message that
    // username is not available
    console.log(
      "this is the phone and verification code",
      phone,
      phoneVerificationCode
    );
    supplierExists = await Supplier.findOne({
      phone: phone,
      phoneVerified: false,
      phoneVerificationCode: phoneVerificationCode,
    });
    console.log(supplierExists);
    if (supplierExists) {
      // update the phoneVerified flag to true.
      const filter = {
        phone: phone,
        phoneVerificationCode: phoneVerificationCode,
      };
      const update = { phoneVerified: true };
      const doc = await Supplier.findOneAndUpdate(filter, update);
      updatedSupplier = await Supplier.findOne({ phone: phone });

      if (updatedSupplier.phoneVerified) {
        reply.send('{"armintatankdata":{"error":false,"verified": true}}');
      } else {
        error = {
          armintatankdata: {
            error: true,
            code: 10005,
            message: "10005 - Verification code entered cannot be validated.",
          },
        };
        req.body.regError = error;
        reply.send(error);
      }
    } else {
      error = {
        armintatankdata: {
          error: true,
          code: 10005,
          message: "10005 - Verification code entered cannot be validated.",
        },
      };
      req.body.regError = error;
      reply.send(error);
    }
  } catch (err) {
    throw boom.boomify(err);
  }
};

// exports.deliveryBoyVerifyPhone = async (req, reply) => {
//   console.log("-------------------------------------------------");
//   try {
//     phone = req.body.phone;
//     phoneVerificationCode = req.body.phoneVerificationCode;

//     // check if user exists in the system. If user exists , display message that
//     // username is not available
//     console.log(
//       "this is the phone and verification code",
//       phone,
//       phoneVerificationCode
//     );
//     deliveryBoyExists = await DeliveryBoy.findOne({
//       phone: phone,
//       phoneVerified: false,
//       phoneVerificationCode: phoneVerificationCode,
//     });
//     console.log(deliveryBoyExists);
//     if (deliveryBoyExists) {
//       // update the phoneVerified flag to true.
//       const filter = {
//         phone: phone,
//         phoneVerificationCode: phoneVerificationCode,
//       };
//       const update = { phoneVerified: true };
//       const doc = await DeliveryBoy.findOneAndUpdate(filter, update);
//       updatedDeliveryBoy = await DeliveryBoy.findOne({ phone: phone });

//       if (updatedDeliveryBoy.phoneVerified) {
//         reply.send('{"armintatankdata":{"error":false,"verified": true}}');
//       } else {
//         error = {
//           armintatankdata: {
//             error: true,
//             code: 10005,
//             message: "10005 - Verification code entered cannot be validated.",
//           },
//         };
//         req.body.regError = error;
//         reply.send(error);
//       }
//     }
//   } catch (err) {
//     throw boom.boomify(err);
//   }
// };

//delete selected deliveryboy
exports.deleteDeliveryBoy = async (req, reply) => {
  try {
    var supplierId = req.params.supplierId;
    var phone = req.query.phone;
    const delivery = await DeliveryBoy.findOneAndDelete({
      phone: phone,
      supplierId: supplierId,
    });

    reply.send({ status_code: 200, data: delivery });
    // return tank;
  } catch (err) {
    throw boom.boomify(err);
  }
};

//update selected Delivery Boy Details
exports.updateDeliveryBoy = async (req, reply) => {
  try {
    var supplierId = req.params.supplierId;
    var phone = req.query.phone;
    const delivery = req.body;
    const { ...updateData } = delivery;
    const update = await DeliveryBoy.findOneAndUpdate(
      { phone: phone, supplierId: supplierId },
      updateData,
      { new: true }
    );
    console.log(update);
    //return update;

    reply.send({ status_code: 200, data: update });
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Get current supplier
exports.getCurrentSupplier = async (req, reply) => {
  try {
    const supplierId = req.body.supplierId;
    const suppliers = await Supplier.findOne({ supplierId: supplierId });
    return suppliers;
  } catch (err) {
    throw boom.boomify(err);
  }
};
// Get all suppliers
// exports.getSuppliers = async (req, reply) => {
//   const limit = parseInt(req.query.limit) || 100;
//   const page = parseInt(req.query.page) || 1;
//   const startindex = (page - 1) * limit;
//   try {
//     await Supplier.find()
//       .limit(limit)
//       .skip(startindex)
//       .exec()
//       .then((docs) => {
//         reply.send({ status_code: 200, data: docs, count: docs.length });
//       })
//       .catch((err) => {
//         console.log(err);
//         reply.send({ error: err });
//       });
//   } catch (err) {
//     throw boom.boomify(err);
//   }
// };

exports.getSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object
  try {
    const friendRequests = await FriendRequest.find({ customerId });
    const supplierIdsToExclude = friendRequests.map(
      (request) => request.supplierId
    );
    await Supplier.find({ supplierId: { $nin: supplierIdsToExclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

// Get single user by ID
exports.getSingleSupplier = async (req, reply) => {
  try {
    const supplierId = req.params.supplierId;
    const supplier = await Supplier.findOne({ supplierId: supplierId });
    return supplier;
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getConnectedSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object
  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: "accepted",
    });
    //   console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getPendingSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: ["pending"],
    });
    // console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    console.log(supplierIdsToInclude, "SUPLIERINCLUDE");
    const timestamps = friendRequests.map((request) => request.timestamp);
    console.log(timestamps, "timestamps");
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        // const supplierDataWithTimestamp = docs.map((doc, index) => ({
        //   data: doc,
        //   //timestamp: timestamps[index],
        // }));
        // reply.send({
        //   status_code: 200,
        //   data: supplierDataWithTimestamp,
        //   count: docs.length,
        // });
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getRejectSuppliers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const customerId = req.params.customerId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      customerId,
      status: ["rejected"],
    });
    // console.log(friendRequests,customerId)
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.supplierId
    );
    //   console.log(supplierIdsToInclude)
    await Supplier.find({ supplierId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getPendingCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["pending"],
    });
    console.log(friendRequests, supplierId, "su....");
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    console.log(supplierIdsToInclude, "supplierIdsToInclude..");
    const timestamps = friendRequests.map((request) => request.timestamp);
    console.log(timestamps, "timestamps");
    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        // const customerDataWithTimestamp = docs.map((doc, index) => ({
        //   data: doc,
        //   //timestamp: timestamps[index],
        // }));
        reply.send({ status_code: 200, data: docs, count: docs.length });
        // reply.send({
        //   status_code: 200,
        //   data: customerDataWithTimestamp,
        //   count: docs.length,
        // });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getRejectCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["rejected"],
    });
    console.log(friendRequests, supplierId, "su....");
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    console.log(supplierIdsToInclude, "supplierIdsToInclude..");
    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getconnectedCustomers = async (req, reply) => {
  const limit = parseInt(req.query.limit) || 100;
  const page = parseInt(req.query.page) || 1;
  const startindex = (page - 1) * limit;
  const supplierId = req.params.supplierId; // Assuming you have already authenticated the user and stored their ID in the request object

  try {
    const friendRequests = await FriendRequest.find({
      supplierId,
      status: ["accepted"],
    });
    console.log(friendRequests, supplierId, "su....");
    const supplierIdsToInclude = friendRequests.map(
      (request) => request.customerId
    );
    console.log(supplierIdsToInclude, "supplierIdsToInclude..");
    await User.find({ customerId: { $in: supplierIdsToInclude } })
      .limit(limit)
      .skip(startindex)
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};