const CartItem = require("../models/CartItem");
const Order = require("../models/Order");
const User = require("../models/User");
const Food = require("../models/Food");
const Payment = require("../models/Payment");
const DiscountCode = require("../models/DiscountCode");
const StoreInfo = require("../models/StoreInfo");
const { body, validationResult } = require("express-validator");
const { res404, res500, checkValidations } = require("../plugins/controllersHelperFunctions");
const { _sr } = require("../plugins/serverResponses");
const axios = require("axios");
const zarinpal = require("./../zarinpal");
const { sendSingle, sendMulti } = require("./../plugins/pushNotif").notification;
const { sendNotifyOrder } = require("./../socket/adminNotify");
const moment = require("moment-jalaali");
const { sms } = require("./../SMSModule");
const CronJob = require("cron").CronJob;

/////////// variables
const apiKey =
  "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIn0.eyJhdWQiOiIxNDk3OSIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIiwiaWF0IjoxNjI3MzI2Mzc0LCJuYmYiOjE2MjczMjYzNzQsImV4cCI6MTYyOTkxODM3NCwic3ViIjoiIiwic2NvcGVzIjpbImJhc2ljIl19.hyKNSy4fmPps6yIdm33Wof-mES9ujh5lmI3VFWyecbkNCm9ATPwsZ9s53A3a1wPJmHfLBXpCcob5NGL-GjZlVfqfRBiReRMr_iniCjUOnqENfFwVEJutxI-xrzVe7PZzOgx1Vr6WwSUHvQ36eJSS1lBlHlqCgwRbkG0hs4YdZsKhzhfYdlAluNw9djjUAMbRWZVL0EluP9CYko4w8tB0KHUZMZYGQcevCfb_3OU9ygHo7B--Z5aTPfm7IK4eP0gHsZ_t857B3tu3ZJB1mkgxc2R9gZUflKqj1ZqkYiR0uMGP-571enXh6pYQLXL2k-gOxLIedCaE6XytxVXhENnotA";
const limit = 20;
const zarinUrl = "https://www.zarinpal.com/pg/StartPay";
const timeToStart = 1800000;
// const timeToStart = 1800000

////////// functions
const deg2rad = (deg) => {
  return deg * (Math.PI / 180);
};

const _computeShippingCost = async (addresses, location) => {
  try {
    if (addresses.length && location) {
      const address = addresses[0];

      const R = 6371; // Radius of the earth in km
      const dLat = deg2rad(address.location.coordinates[1] - location.coordinates[1]); // deg2rad below
      const dLon = deg2rad(address.location.coordinates[0] - location.coordinates[0]);
      const a =
        Math.sin(dLat / 2) * Math.sin(dLat / 2) +
        Math.cos(deg2rad(address.location.coordinates[1])) *
          Math.cos(deg2rad(location.coordinates[1])) *
          Math.sin(dLon / 2) *
          Math.sin(dLon / 2);
      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
      // Distance in km
      return R * c;
    } else {
      return 0;
    }
  } catch (error) {
    return 0;
  }
};

const _computeShippingCostByRoad = async (addresses, storeLocation) => {
  try {
    if (addresses.length && storeLocation) {
      const address = addresses.find((item2) => item2.used === true);
      const lng = address.location.coordinates[0];
      const lat = address.location.coordinates[1];

      const storeLng = storeLocation.coordinates[0];
      const storeLat = storeLocation.coordinates[1];

      const getDistance = await axios.get(`https://map.ir/routes/route/v1/driving/${lng},${lat};${storeLng},${storeLat}`, {
        headers: {
          "x-api-key": apiKey,
        },
      });

      if (getDistance.data.code !== "Ok") return new Error(_sr["fa"].response.unknownError);

      //@todo if distance under 1000 meter equal to 0
      return getDistance.data.routes[0].distance <= 1000 ? 0 : Math.round(getDistance.data.routes[0].distance / 1000);
    } else {
      return 0;
    }
  } catch (error) {
    return 0;
  }
};

const getMinutes = (str) => {
  var time = str.split(":");
  return time[0] * 60 + time[1] * 1;
};

const getMinutesNow = (timezone) => {
  var timeNow = new Date();
  return timeNow.getUTCHours() * 60 + timeNow.getUTCMinutes();
};

const _computeHavePointPrice = async (items) => {
  try {
    let total = 0;
    for (const item of items) {
      if (item.havePoint) {
        let priceItem = item.price - (item.price * item.static_discount || 0 / 100);
        let totalPrice = priceItem * item.quantity;
        total += totalPrice;
      }
    }

    return total;
  } catch (error) {
    return 0;
  }
};

//////////////////////////////////////////////////////////////////public
////////////////////////////////////// cart
module.exports.addToCart = [
  //// check start time and end time
  // async (req, res, next) => {
  //   try {
  //     const getTime = await StoreInfo.findOne()
  //
  //     if (getTime) {
  //       if (getTime?.open24){
  //         return next()
  //       } else if (getTime?.utcStartTime && getTime?.utcEndTime) {
  //         let start = getMinutes(getTime.utcStartTime)
  //         let end = getMinutes(getTime.utcEndTime)
  //         let now = getMinutesNow(getTime.timezone)
  //
  //         if (
  //            (start < now && end > now) || (start > end && (now < end || now > start))
  //         ) {
  //           return next()
  //         } else if (start === end) {
  //           return res.status(503).json({message: `در حال حاظر پذیرش سفارش نداریم`})
  //         }else {
  //           return res.status(503).json({message: `پذیرش سفارش از ساعت ${getTime?.startTime} تا ${getTime?.endTime} می باشد`})
  //         }
  //
  //       } else {
  //         return next()
  //       }
  //     } else {
  //       return next()
  //     }
  //
  //   } catch (error) {
  //     return res500(res, _sr['fa'].response.unknownError)
  //   }
  // },
  [
    body("product_id").custom((value, { req }) => {
      return Food.findById(value)
        .then((product) => {
          if (product) return true;
          else return Promise.reject(_sr["fa"].not_found.item_id);
        })
        .catch((err) => {
          return Promise.reject(_sr["fa"].not_found.item_id);
        });
    }),
    body("type").notEmpty().withMessage(`نوع عملی که باید انجام شود را بفرستید`),

    body("branchId")
      .notEmpty()
      .withMessage(_sr["fa"].required.field)
      .bail()
      .custom((value, { req }) => {
        return StoreInfo.findOne({ _id: value }).then((store) => {
          if (!store) return Promise.reject(_sr["fa"].not_found.item_id);
          else return true;
        });
      }),
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const { product_id, type, branchId } = req.body;
      const checkCart = await CartItem.findOne({ branchId, product_id, user_id: req.user._id }).populate("product_id");

      if (checkCart) {
        if (Number(checkCart.quantity) > 0) {
          if (type === "positive") {
            checkCart.quantity = Number(checkCart.quantity) + 1;
          } else if (type === "negative") {
            checkCart.quantity = Number(checkCart.quantity) - 1;
          }
          await checkCart.save();

          if (Number(checkCart.quantity) === 0 || checkCart.product_id.stock === 0) {
            await checkCart.deleteOne();
          }
        }

        return res.json({ message: _sr["fa"].response.success_save });
      } else {
        const addCart = await CartItem.create({
          branchId,
          product_id,
          user_id: req.user._id,
          quantity: 1,
        });

        if (!addCart) return res500(res, _sr["fa"].response.unknownError);

        return res.json({ message: _sr["fa"].response.success_save });
      }
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.getCartItems = [
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId;

      const allCartItems = await CartItem.find({ branchId, user_id: req.user._id })
        .populate({
          path: "user_id",
          select: "-password -token",
          sort: { useRate: -1 },
        })
        .populate("product_id");

      return res.json(allCartItems);
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.updateCart = [
  [
    body("quantity")
      .notEmpty()
      .withMessage((value, { req }) => {
        return _sr["fa"].required.quantity;
      })
      .bail()
      .isNumeric()
      .withMessage((value, { req }) => {
        return _sr["fa"].format.number;
      }),
  ],
  checkValidations(validationResult),
  (req, res) => {
    CartItem.findById(req.params.item_id)
      .then((item) => {
        if (!item) return res404(res, _sr["fa"].not_found.item_id);
        item.quantity = Number(req.body.quantity);
        item.save();
        return res.json({ message: _sr["fa"].response.success_save });
      })
      .catch((err) => {
        return res404(res, err);
      });
  },
];

module.exports.deleteAllCartItem = [
  (req, res) => {
    CartItem.deleteMany({ user_id: req.user._id }, (err, result) => {
      if (err) return res500(res, _sr["fa"].response.unknownError);
      else return res.json({ message: _sr["fa"].response.success_remove });
    });
  },
];

/////////////////////////////////// reorder
module.exports.reOrder = [
  //////////////////// validation step
  // (req, res, next) => {
  //   CartItem.find({user_id: req.user._id})
  //      .then(items => {
  //        // check if cart is not empty
  //        if (items.length) {
  //          // check product stock
  //          let outOfRun = []
  //          items.forEach(async (item, index) => {
  //            await Food.findById(item.product_id)
  //               .then(product => {
  //                 if (product.stock < item.quantity) {
  //                   outOfRun.push({
  //                     product_id: product._id,
  //                     category_id: product.category,
  //                     stock: product.stock
  //                   })
  //                   item.remove()
  //                 }
  //                 if (index + 1 === items.length) {
  //                   if (!outOfRun.length) return next()
  //                   else return res.status(422).json(outOfRun)
  //                 }
  //               })
  //          })
  //        } else {
  //          return res.status(404).json({message: _sr['fa'].response.cart_empty})
  //        }
  //      })
  // },
  async (req, res) => {
    try {
      const orderId = req.params?.orderId;
      const checkOrder = await Order.findOne({ status: "delivered", user_id: req.user._id, _id: orderId }).populate("product_id");

      if (!checkOrder) return res404(res, `سفارش کاربر یافت نشد`);

      await CartItem.deleteMany({ user_id: req.user._id });

      for (const food of checkOrder.order_items) {
        if (food.product_id && !food.product_id?.deleted) {
          await CartItem.create({
            product_id: food.product_id._id,
            user_id: req.user._id,
            quantity: food.quantity,
          });
        }
      }

      return res.json({ message: _sr["fa"].response.success_save });
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

////////////////////////////////////// order
module.exports.addOrder = [
  [
    body("description").optional().isString().withMessage(`توضیحات سفارش باید به صورت رشته فرستاده شود`),

    body("bag").optional().isBoolean().withMessage(_sr["fa"].format.boolean),

    body("score").optional().isBoolean().withMessage(_sr["fa"].format.boolean),

    body("discountCode")
      .if((value, { req }) => {
        return value;
      })
      .custom((value, { req }) => {
        return DiscountCode.findOne({ discount_code: value })
          .then((discount) => {
            if (!discount) return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`);
            if (Number(discount.discount_expire_date) > Date.now()) return Promise.reject(`تاریخ مصرف کد تخفیف به اتمام رشیده است`);
            if (discount.used_by.includes(req?.user?._id)) return Promise.reject(`کد تخفیف قبلا استفاده شده است`);
            if (!discount.isPublic) {
              if (discount?.discount_user_id?.toString() !== req?.user?._id.toString())
                return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`);
            } else return true;
          })
          .catch((error) => {
            return Promise.reject(`کد تخفیف وارد شده صحیح نمیباشد`);
          });
      }),

    body("branchId")
      .notEmpty()
      .withMessage(_sr["fa"].required.field)
      .bail()
      .custom((value, { req }) => {
        return StoreInfo.findOne({ _id: value }).then((store) => {
          if (!store) return Promise.reject(_sr["fa"].not_found.item_id);
          else return true;
        });
      }),
  ],
  checkValidations(validationResult),
  //////////////////// validation step
  (req, res, next) => {
    CartItem.find({ branchId: req?.body?.branchId, user_id: req.user._id }).then((items) => {
      // check if cart is not empty
      if (items.length) {
        // check product stock
        let outOfRun = [];
        items.forEach(async (item, index) => {
          await Food.findById(item.product_id).then((product) => {
            if (product.stock < item.quantity) {
              outOfRun.push({
                name: product.name,
                product_id: product._id,
                category_id: product.category,
                stock: product.stock,
              });
              item.remove();
            }
            if (index + 1 === items.length) {
              if (!outOfRun.length) return next();
              else return res.status(422).json(outOfRun);
            }
          });
        });
      } else {
        return res.status(404).json({ message: _sr["fa"].response.cart_empty });
      }
    });
  },
  //////////////////// save order
  async (req, res) => {
    try {
      const { branchId, description, bag, score, discountCode } = req.body;
      const cartItems = await CartItem.find({ branchId, user_id: req.user._id }).populate("product_id");
      const getUserInfo = await User.findById(req.user._id);
      const getDiscountCode = await DiscountCode.findOne({ branchId, discount_code: discountCode });

      if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);

      if (!cartItems.length) return res.status(404).json({ message: `هیچ محصولی در سبد خرید شما وجود ندارد` });

      await Order.deleteMany({ branchId, status: "incomplete", user_id: req.user._id });

      /// check order exist or not
      // const checkOrder = await Order.findOne({'status': 'incomplete', user_id: req.user._id});
      //
      // if (checkOrder) {
      //   await checkOrder.remove()
      // }

      const orderItems = [];
      for (const item of cartItems) {
        orderItems.push({
          product_id: item.product_id._id,
          name: item.product_id.name,
          quantity: item.quantity,
          price: item.product_id.price,
          static_discount: item.product_id.static_discount,
          havePoint: item.product_id.havePoint,
        });
      }

      if (score && bag) return res.status(422).json({ message: "استفاده همزمان از کیف پول و امتیاز برای خرید مجاز نمی باشد" });

      const orderData = {
        branchId,
        user_id: req.user._id,
        number: Date.now(),
        order_items: orderItems,
        statuses: [
          {
            status: "incomplete",
          },
        ],
        description,
        bag,
        score,
        discount_code: getDiscountCode?.discount_code,
        discount_amount: getDiscountCode?.discount_amount,
        discount_menuType: getDiscountCode?.menuTypeId,
      };
      await Order.create(orderData);

      return res.json({ message: _sr["fa"].response.success_save });
    } catch (error) {
      console.log(error);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.orderPay = [
  [
    body("branchId")
      .notEmpty()
      .withMessage(_sr["fa"].required.field)
      .bail()
      .custom((value, { req }) => {
        return StoreInfo.findOne({ _id: value }).then((store) => {
          if (!store) return Promise.reject(_sr["fa"].not_found.item_id);
          else return true;
        });
      }),
  ],
  checkValidations(validationResult),
  (req, res, next) => {
    CartItem.find({ branchId: req?.body?.branchId, user_id: req.user._id }).then((items) => {
      // check if cart is not empty
      if (items.length) {
        // check product stock
        let outOfRun = [];
        items.forEach(async (item, index) => {
          await Food.findById(item.product_id).then((product) => {
            if (product.stock < item.quantity) {
              outOfRun.push({
                product_id: product._id,
                category_id: product.category,
                stock: product.stock,
              });
              item.remove();
            }
            if (index + 1 === items.length) {
              if (!outOfRun.length) return next();
              else return res.status(422).json(outOfRun);
            }
          });
        });
      } else {
        return res.status(404).json({ message: _sr["fa"].response.cart_empty });
      }
    });
  },
  async (req, res) => {
    try {
      const branchId = req?.body?.branchId;
      const cartItems = await CartItem.find({ branchId, user_id: req.user._id }).populate("product_id");
      const checkOrder = await Order.findOne({ branchId, status: "incomplete", user_id: req.user._id });
      const getUserInfo = await User.findById(req.user._id);
      const getStoreInfo = await StoreInfo.findOne({ _id: branchId });

      if (!checkOrder) return res404(res, "لطفا از مرحله سبد خرید دوباره ادامه دهید");

      let pricePoint = Math.floor(getStoreInfo?.priceForChange / getStoreInfo?.pointForChange) || 0;
      let totalPricePoint = getStoreInfo?.totalPricePoint || 0;
      let pointForBuy = getStoreInfo?.pointForBuy || 0;

      let discount_percent = checkOrder?.discount_amount || 0;
      let discount_menuType = checkOrder?.discount_menuType;
      let specialDiscountMenuType = false;
      let routePrice = 0;
      let sum = 0;
      let sumFoodByPercent = 0;
      let sumFoodByPercentForDiscount = 0;
      let total = 0;
      let firstTotal = 0;
      let percent = 0;
      let tax = 0;

      if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);

      if (!cartItems.length) return res.status(404).json({ message: `هیچ محصولی در سبد خرید شما وجود ندارد` });

      const orderItems = [];
      for (const item of cartItems) {
        orderItems.push({
          product_id: item.product_id._id,
          name: item.product_id.name,
          quantity: item.quantity,
          price: item.product_id.price,
          static_discount: item.product_id.static_discount,
          havePoint: item.product_id.havePoint,
        });

        const itemPercent = (item.product_id.price * item.product_id.static_discount) / 100;
        const sumPercent = itemPercent * item.quantity;
        const price = item.product_id.price;
        const sumPriceItem = price * item.quantity;

        let sumByPercentForDiscount = sumPriceItem - sumPercent;

        if (Boolean(discount_percent) && discount_menuType) {
          specialDiscountMenuType = true;
          if (item?.product_id?.category.type?.toString() === discount_menuType?.toString()) {
            sumFoodByPercentForDiscount += sumByPercentForDiscount;
          }
        }

        sum = sum + sumPriceItem; /// sum food price without percent
        percent = percent + sumPercent; /// sum all food percent
      }

      /// sum food price with percent
      sumFoodByPercent = sum - percent;

      /// compute shipping cost
      if (getStoreInfo) {
        if (getStoreInfo?.shippingType) {
          routePrice = getStoreInfo?.shippingCost || 0;
        } else {
          routePrice =
            (await _computeShippingCostByRoad(getUserInfo?.addresses, getStoreInfo?.location)) * (getStoreInfo?.shippingCost || 0) || 0;
        }

        /// compute tax of order
        if (getStoreInfo?.tax) {
          tax = (sumFoodByPercent * 9) / 100;
        }
      }

      /// compute discount code
      if (Boolean(discount_percent)) {
        let discountPercent = ((specialDiscountMenuType ? sumFoodByPercentForDiscount : sumFoodByPercent) * discount_percent) / 100;
        percent = percent + discountPercent;
        /// compute sum food with discount percent
        sumFoodByPercent = sumFoodByPercent - discountPercent;
      }

      /// compute total of order
      total = sumFoodByPercent + tax + routePrice;

      checkOrder.order_items = orderItems;
      checkOrder.createdOn = Date.now();
      checkOrder.address = getUserInfo.addresses.find((item) => item.used);
      checkOrder.sum = Math.ceil(sum);
      checkOrder.routePrice = Math.ceil(routePrice);
      checkOrder.tax = Math.ceil(tax);
      checkOrder.percent = Math.ceil(percent);
      checkOrder.total = Math.ceil(total);
      checkOrder.pricePoint = pricePoint;
      firstTotal = Math.ceil(total);

      if (checkOrder.bag) {
        const payPrice = total - getUserInfo?.bagAmount;
        total = payPrice <= 0 ? 0 : payPrice;
      }

      if (checkOrder.score && pricePoint > 0) {
        const payScore = total - getUserInfo?.score * pricePoint;
        total = payScore <= 0 ? 0 : payScore;
      }

      checkOrder.payTotal = Math.ceil(total);

      console.log("total", total);
      console.log("payTotal", checkOrder?.payTotal);

      /// if total pay is zero dont move to pay method
      if (checkOrder?.payTotal <= 0) {
        /// if bag true use the bagAmount of user
        if (checkOrder?.bag) {
          getUserInfo.bagAmount -= firstTotal;

          // add point for user only for available product
          const computeAvaPro = await _computeHavePointPrice(checkOrder.order_items);
          /// add score for order
          if (computeAvaPro >= totalPricePoint && totalPricePoint > 0) {
            const point = Math.floor(computeAvaPro / totalPricePoint) * pointForBuy;

            if (point > 0) {
              getUserInfo.score = getUserInfo.score + point;
              getUserInfo.scoreLogs = [
                {
                  score: point,
                  order_id: getUserInfo._id,
                  forWhat: "buy",
                  action: "increase",
                },
              ];
            }
          }
          await getUserInfo.save();

          if (Boolean(discount_percent)) {
            const updateDiscount = await DiscountCode.findOne({ discount_code: checkOrder.discount_code });

            if (!updateDiscount || Number(updateDiscount.discount_expire_date) > Date.now())
              return res.status(403).json({ message: "مشکلی در پرداخت و ثبت سفارش پیش آمده است لطفا با پشتیبانی تماس بگیرید" });

            updateDiscount.used_by.push(getUserInfo._id);
            await updateDiscount.save();
          }

          const addPayment = await Payment.create({
            user_id: getUserInfo._id,
            order_id: checkOrder._id,
            transactionId: Date.now(),
            refId: Date.now(),
            getPayment: true,
            action: "decreaseBag",
            status: "paid",
            cost: firstTotal,
          });

          checkOrder.payment.push(addPayment._id);
          checkOrder.bagCost = firstTotal;
        } /// it was ok!

        /// if score true use the score of user
        if (checkOrder?.score && pricePoint > 0) {
          const point = Math.ceil(firstTotal / pricePoint);
          checkOrder.scoreCost = point * pricePoint;
          checkOrder.scorePoint = point;
          getUserInfo.score -= point;
          getUserInfo.scoreLogs = [
            {
              score: point,
              order_id: checkOrder._id,
              forWhat: "buy",
              action: "decrease",
            },
          ];

          await getUserInfo.save();
        }

        checkOrder.statuses.push({
          status: "processing",
        });
        checkOrder.status = "processing";
        checkOrder.paymentStatus = "paid";
        await checkOrder.save();

        for (const food of checkOrder.order_items) {
          const getFood = await Food.findById(food.product_id);

          if (getFood) {
            getFood.stock = getFood.stock - food.quantity;
            // getFood.canReview.push(req.user._id)///add user id for review
            getFood.save();
          }
        }

        /// remove cart item
        await CartItem.deleteMany({ user_id: getUserInfo._id });

        //----------------------- send notif for admins -----------------
        const fcmTokens = [];
        const allAdmins = await User.find({ scope: "admin" });
        for (const admin of allAdmins) {
          if (admin.fcmToken) fcmTokens.push(admin.fcmToken);
        }
        const objNotif = {
          title: "سفارش جدید!",
          body: "یک سفارش جدید در پنل برگ من ثبت گردید",
        };
        const payload = {
          notification: objNotif,
        };
        const input = {
          registrationTokens: fcmTokens,
          payload,
        };
        await sendMulti(input);

        sendNotifyOrder(checkOrder?.branchId);
        //----------------------------------------------------------------

        //--------------------- send notif to user --------------------------
        const messageUser = {
          title: "ثبت سفارش",
          body: "با تشکر از اعتماد شما سفارش شما با موفقیت ثبت شد",
        };
        const payloadUser = {
          notification: messageUser,
        };
        const inputUser = {
          registrationTokens: getUserInfo.fcmToken,
          payload: payloadUser,
        };
        await sendSingle(inputUser);
        //-------------------------------------------------------------------

        //------------------------------- send sms --------------------------
        const smsTemplate = `سفارش شما با موفقیت ثبت شد با تشکر از اعتماد شما برگ من لغو11`;

        const smsResult = await sms(getUserInfo.mobile_number, smsTemplate);

        if (!smsResult) {
          return res500(res, `مشکلی در ارسال پیامک پیش آمده است`);
        }
        //-------------------------------------------------------------------
        return res.json({ message: _sr["fa"].response.success_save });
      }

      const request = await zarinpal.request(checkOrder?.payTotal, checkOrder?.number?.toString(), req.user);

      if (!request.status) {
        console.log(request);
        return res500(res, _sr["fa"].response.unknownError);
      }

      // add payment to order
      const addPayment = await Payment.create({
        user_id: getUserInfo._id,
        order_id: checkOrder._id,
        transactionId: request.response.authority,
        cost: checkOrder.payTotal,
      });

      if (addPayment) {
        checkOrder.payment = addPayment._id;
        await checkOrder.save();
      } else {
        return res500(res, _sr["fa"].response.unknownError);
      }

      /// remove cart item
      await CartItem.deleteMany({ branchId, user_id: req.user._id });

      return res.json({ paymentUrl: `${zarinUrl}/${request.response.authority}` });
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.getPaymentResponse = [
  async (req, res) => {
    try {
      const checkPayment = await Payment.findOne({ transactionId: req?.query?.Authority }).populate("order_id");

      const user = await User.findById(checkPayment.user_id);

      ///check duplicate transaction
      if (!checkPayment || checkPayment.getPayment || checkPayment.action === "decreaseBag") {
        return res.json({
          status: false,
          fromWhere: user?.fromWhere || "app",
          message: "پرداخت ناموفق بود",
        });
      }

      /// verify transaction
      const verify = await zarinpal.verify(
        checkPayment.action === "increaseBag" ? checkPayment.cost : checkPayment.order_id.payTotal,
        checkPayment.transactionId,
      );

      console.log(verify);

      if (verify.status) {
        if (verify.code === 101) {
          console.log(verify);
          return res.json({
            status: false,
            message: "پرداخت ناموفق بود",
          });
        }

        checkPayment.status = "paid";
        checkPayment.refId = verify?.response?.ref_id;
        checkPayment.getPayment = true;
        checkPayment.fee_type = verify?.response?.fee_type;
        checkPayment.card_hash = verify?.response?.card_hash;
        checkPayment.card_pan = verify?.response?.card_pan;
        checkPayment.fee = verify?.response?.fee;
        checkPayment.created_at = Date.now();
        checkPayment.createdOn = Date.now();

        await checkPayment.save();

        /// only for buy food execute this action
        if (checkPayment.action === "payOrder") {
          const getOrder = await Order.findById(checkPayment.order_id._id);

          if (!getOrder) return res404(res, "سفارش پیدا نشد");

          for (const food of getOrder.order_items) {
            const getFood = await Food.findById(food.product_id);

            if (getFood) {
              getFood.stock = getFood.stock - food.quantity;
              // getFood.canReview.push(req.user._id)///add user id for review
              getFood.save();
            }
          }

          if (getOrder.discount_code) {
            const discount = await DiscountCode.findOne({ discount_code: getOrder.discount_code });

            if (discount) {
              discount.used_by.push(getOrder.user_id);

              await discount.save();
            }
          }

          if (user) {
            /// decrease score
            if (getOrder?.score) {
              getOrder.scorePoint = user.score;
              getOrder.scoreCost = user.score * getOrder?.pricePoint;
              user.scoreLogs = [
                {
                  score: user.score,
                  order_id: getOrder._id,
                  forWhat: "buy",
                  action: "decrease",
                },
              ];
              user.score = 0;
              await user.save();
            }

            /// decrease bag
            if (getOrder.bag) {
              const addPayment = await Payment.create({
                user_id: user._id,
                order_id: getOrder._id,
                transactionId: Date.now(),
                refId: Date.now(),
                getPayment: true,
                action: "decreaseBag",
                status: "paid",
                cost: user.bagAmount,
              });
              getOrder.payment.push(addPayment._id);
              getOrder.bagCost = user.bagAmount;
              user.bagAmount = 0;
              await user.save();
            }

            if (!getOrder.score || !getOrder?.discount_code) {
              // add point for user only for available product
              const computeAvaPro = await _computeHavePointPrice(getOrder?.order_items);

              /// add score for order
              if (computeAvaPro >= getOrder?.totalPricePoint && getOrder?.totalPricePoint > 0) {
                const point = Math.floor(computeAvaPro / getOrder?.totalPricePoint) * getOrder?.pointForBuy;

                if (point > 0) {
                  user.score = user.score + point;
                  user.scoreLogs = [
                    {
                      score: point,
                      order_id: getOrder._id,
                      forWhat: "buy",
                      action: "increase",
                    },
                  ];
                  await user.save();
                }
              }
            }
          }

          getOrder.statuses.push({
            status: "processing",
          });
          getOrder.status = "processing";
          getOrder.paymentStatus = "paid";

          await getOrder.save();

          //----------------------- send notif for admins -----------------
          const fcmTokens = [];
          const allAdmins = await User.find({ scope: "admin" });
          for (const admin of allAdmins) {
            if (admin.fcmToken) fcmTokens.push(admin.fcmToken);
          }
          const objNotif = {
            title: "سفارش جدید!",
            body: "یک سفارش جدید در پنل برگ من ثبت گردید",
          };
          const payload = {
            notification: objNotif,
          };
          const input = {
            registrationTokens: fcmTokens,
            payload,
          };
          await sendMulti(input);

          sendNotifyOrder(getOrder?.branchId);
          //----------------------------------------------------------------

          //--------------------- send notif to user --------------------------
          const messageUser = {
            title: "ثبت سفارش",
            body: "با تشکر از اعتماد شما سفارش شما با موفقیت ثبت شد",
          };
          const payloadUser = {
            notification: messageUser,
          };
          const inputUser = {
            registrationTokens: user.fcmToken,
            payload: payloadUser,
          };
          await sendSingle(inputUser);
          //-------------------------------------------------------------------

          //------------------------------- send sms --------------------------
          const smsTemplate = `سفارش شما با موفقیت ثبت شد با تشکر از اعتماد شما برگ من لغو11`;

          const smsResult = await sms(user.mobile_number, smsTemplate);

          if (!smsResult) {
            return res500(res, `مشکلی در ارسال پیامک پیش آمده است`);
          }
          //-------------------------------------------------------------------
        } else if (checkPayment.action === "increaseBag") {
          if (!user)
            return res.json({
              status: false,
              message: "مشکلی در افزایش موجودی کیف پول شما پیش آمده است لطفا با پشتیبانی تماس بگیرید",
            });

          user.bagAmount = user.bagAmount + checkPayment?.cost;

          await user.save();
          //--------------------- send notif to user --------------------------
          const messageUser = {
            title: "افزایش موجودی",
            body: "با تشکر از اعتماد شما کیف پول شما با موفقیت شارژ شد برگ من",
          };
          const payloadUser = {
            notification: messageUser,
          };
          const inputUser = {
            registrationTokens: user.fcmToken,
            payload: payloadUser,
          };
          await sendSingle(inputUser);
          //-------------------------------------------------------------------

          //------------------------------- send sms --------------------------
          const smsTemplate = `با تشکر از اعتماد شما کیف پول شما با موفقیت شارژ شد برگ من لغو11`;

          const smsResult = await sms(user.mobile_number, smsTemplate);

          if (!smsResult) {
            return res500(res, `مشکلی در ارسال پیامک پیش آمده است`);
          }
          //-------------------------------------------------------------------
        }

        return res.json({
          status: true,
          refId: verify?.response?.ref_id,
          fromWhere: user?.fromWhere || "app",
          message: "پرداخت با موفقیت انجام شد",
        });
      } else {
        /// only for buy food execute this action
        if (checkPayment.action === "payOrder") {
          let getOrder = await Order.findById(checkPayment.order_id._id);

          if (getOrder) {
            getOrder.statuses.push({
              status: "void",
            });
            getOrder.status = "void";
            getOrder.paymentStatus = "unpaid";

            await getOrder.save();
          }

          checkPayment.getPayment = true;
          checkPayment.created_at = new Date();
          await checkPayment.save();
        }

        return res.json({
          status: false,
          fromWhere: user?.fromWhere || "app",
          message: "پرداخت ناموفق بود",
        });
      }
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.addAddressToOrder = [
  (req, res) => {
    Order.findById(req.params.order_id)
      .then((order) => {
        if (!order.address) {
          User.findOne({ "addresses._id": req.body.address_id })
            .then((user) => {
              order.address = user.addresses.id(req.body.address_id);
              // add processing status to order
              order.statuses.push({
                status: "processing",
              });
              order.save();
              return res.json(order);
            })
            .catch((err) => {
              return res500(res, err);
            });
        } else {
          return res.status(500).json({ message: v_m[req.body.locale].response.already_has_address });
        }
      })
      .catch((err) => {
        return res404(res, err);
      });
  },
];

module.exports.addStatusToOrder = [
  async (req, res) => {
    try {
      const order = await Order.findById(req.params.order_id).populate("user_id");

      if (!order) return res404(res, "سفارش مورد نظر یافت نشد");

      order.statuses.push({
        status: req.body.status,
      });
      order.status = req.body.status;
      order.save();

      if (req.body.status === "delivered") {
        //--------------------- send notif to user --------------------------
        const messageUser = {
          title: "ارسال سفارش",
          body: "سفارش شما ارسال گردید با تشکر برگ من",
        };
        const payloadUser = {
          notification: messageUser,
        };
        const inputUser = {
          registrationTokens: order?.user_id?.fcmToken,
          payload: payloadUser,
        };
        await sendSingle(inputUser);
        //-------------------------------------------------------------------

        setTimeout(async () => {
          let smsTemplate = "";
          if (order.user_id.fromWhere === "app")
            smsTemplate = `لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر برگ من`;
          else
            smsTemplate = `لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر برگ من لغو11
          لینک : https://app.bargrestaurant.com/rate/${req.params.order_id}`;
          const smsResult = await sms(order?.user_id?.mobile_number, smsTemplate);

          //--------------------- send notif to user --------------------------
          const messageUser = {
            title: "ثبت نظر",
            body: "لطفا با ثبت نظر برای سفارش خود به ما برای خدمات بهتر کمک کنید با تشکر",
          };
          const payloadUser = {
            notification: messageUser,
          };
          const inputUser = {
            registrationTokens: order?.user_id?.fcmToken,
            payload: payloadUser,
          };
          await sendSingle(inputUser);
          //-------------------------------------------------------------------

          if (!smsResult) {
            console.log("order sms", smsResult);
          }
        }, timeToStart);
      }
      return res.json(order);
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.changePayStatus = [
  [
    body("status")
      .notEmpty()
      .withMessage(_sr["fa"].required.field)
      .bail()
      .isIn(["refund", "unpaid", "paid"])
      .withMessage("وضعیت ارسال شده صحیح نمی باشد"),
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const targetOrder = await Order.findById(req.params.id);

      if (!targetOrder) return res404(res, "سفارش مورد نظر پیدا نشد");

      const targetPayment = await Payment.findById(targetOrder.payment);

      if (targetPayment) {
        targetPayment.status = req.body.status;
        await targetPayment.save();
      }

      targetOrder.paymentStatus = req.body.status;
      await targetOrder.save();

      return res.json({ message: _sr["fa"].response.success_save });
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.getOrders = [
  (req, res) => {
    const branchId = req?.params?.branchId;
    Order.find({
      branchId,
      user_id: req.user._id,
      status: { $in: ["canceled", "processing", "sent", "delivered"] },
      paymentStatus: "paid",
    })
      .populate({
        path: "order_items.product_id",
        select: "name canReview ratings",
      })
      .sort({ _id: -1 })
      .then((orders) => {
        const allOrders = [];

        for (const item of orders) {
          let clone = JSON.parse(JSON.stringify(item.order_items));

          clone.map((food) => {
            // food.review = food?.product_id?.canReview?.includes(req.user._id.toString())
            // food.rating = food?.product_id?.ratings?.find(rate => rate.user_id.toString() === req.user._id.toString() && rate?.order_id?.toString() === item?._id?.toString())?.rate || 0
            food.rating = food?.product_id?.ratings?.find((rate) => rate?.user_id?.toString() === req?.user?._id.toString())?.rate || 0;
          });

          allOrders.push({
            _id: item._id,
            address: item.address,
            status: item.status,
            items: clone,
            orderType: item.orderType,
            review: item.rating.rate,
            created_at: item.createdOn,
            total: item.total,
          });
        }

        return res.json(allOrders);
      })
      .catch((err) => {
        console.log(err.message);
        return res500(res, _sr["fa"].response.unknownError);
      });
  },
];

module.exports.getOrdersForReport = [
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId;
      const orders = await Order.find({
        branchId,
        status: { $in: ["canceled", "processing", "sent", "delivered"] },
        paymentStatus: "paid",
      });
      return res.json(orders);
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.getOneOrderByUser = [
  async (req, res) => {
    try {
      const targetOrder = await Order.findOne({ _id: req.params.id, user_id: req.user._id }).select("status");

      if (!targetOrder) return res404(res, "سفارش مورد نظر پیدا نشد");

      return res.json(targetOrder);
    } catch (error) {
      console.log("get one order by user |", error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.deleteOrder = [
  async (req, res) => {
    try {
      const targetOrder = await Order.findById(req.params.id);

      if (!targetOrder) return res404(res, "سفارش مورد نظر پیدا نشد");

      /// @todo maybe delete payment too

      await targetOrder.deleteOne();

      return res.json({ message: _sr["fa"].response.success_remove });
    } catch (error) {
      console.log("delete order: ", error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.increaseBag = [
  [body("price").notEmpty().withMessage(`لطفا یک مقدار مشخص کنید`)],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const cost = req.body.price;
      const user = await User.findById(req.user._id);

      if (!user) return res404(res, `اطلاعات کاربر پیدا نشد`);

      const request = await zarinpal.request(cost, "کیف پول", req.user);

      if (!request.status) {
        console.log(request);
        return res500(res, _sr["fa"].response.unknownError);
      }

      // add payment to order
      await Payment.create({
        user_id: user._id,
        order_id: null,
        transactionId: request.response.authority,
        cost: cost,
        action: "increaseBag",
      });

      return res.json({ paymentUrl: `${zarinUrl}/${request.response.authority}` });
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

/////// admin panel
module.exports.getOneOrder = [
  (req, res) => {
    Order.findById(req.params.id)
      .populate({
        path: "user_id",
        select: "first_name last_name scoreLogs",
      })
      .populate("order_items.product_id")
      .populate("payment")
      .then((order) => {
        return res.json(order);
      })
      .catch((err) => {
        return res404(res, err);
      });
  },
];

module.exports.search = [
  async (req, res) => {
    try {
      let { branchId, number, orderStatus, paymentStatus, userId, date } = req.body;

      let findQuery = {
        branchId,
        status: { $nin: ["incomplete", "void"] },
      };
      findQuery["$and"] = [];
      findQuery["$or"] = [];

      /** search by number */
      if (number && !_.isEmpty(number)) {
        findQuery["$and"].push({
          number,
        });
      }

      /** search by orderStatus */
      if (orderStatus && !_.isEmpty(orderStatus)) {
        findQuery["$and"].push({
          status: {
            $in: orderStatus,
          },
        });
      }

      /** search by paymentStatus */
      if (paymentStatus && !_.isEmpty(paymentStatus)) {
        findQuery["$and"].push({
          paymentStatus: {
            $in: paymentStatus,
          },
        });
      }

      /** search by user_id */
      if (userId && !_.isEmpty(userId)) {
        findQuery["$and"].push({
          user_id: userId,
        });
      }

      /** search by date */
      if (date && !_.isEmpty(date)) {
        if (date.length === 1) {
          findQuery["$and"].push({
            createdOn: {
              $gte: moment(date[0]).startOf("days"),
              $lt: moment(date[0]).endOf("days"),
            },
          });
        } else {
          findQuery["$and"].push({
            createdOn: {
              $gte: new Date(date[0]),
              $lt: new Date(date[1]),
            },
          });
        }
      }

      _.isEmpty(findQuery["$and"]) && delete findQuery["$and"];
      _.isEmpty(findQuery["$or"]) && delete findQuery["$or"];

      /** get news */
      const orders = await Order.paginate(findQuery, {
        page: req.query.page,
        limit,
        populate: [{ path: "user_id", select: "first_name last_name" }],
        sort: {
          _id: -1,
        },
      });

      /** show result */
      return res.json(orders);
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.reports = [
  // [
  //   body('startDate')
  //      .notEmpty().withMessage(_sr['fa'].required.date),
  //
  //   body('endDate')
  //      .notEmpty().withMessage(_sr['fa'].required.date),
  // ],
  // checkValidations(validationResult),
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId;
      let findQuery = {
        branchId,
        status: { $nin: ["incomplete", "void"] },
      };

      let { startDate, endDate } = req.body;

      // if (!startDate || !endDate){
      // findQuery.createdOn = {
      // createdOn: {
      // $gte: moment().startOf('days'),
      // $lt: moment().endOf('days')
      // }
      // }
      // }else {
      if (startDate && endDate) {
        findQuery.createdOn = {
          $gte: new Date(startDate),
          $lt: new Date(endDate),
        };
      } else if (startDate) {
        findQuery.createdOn = {
          $gte: moment(startDate),
          $lt: new Date(),
        };
      } else if (endDate) {
        findQuery.createdOn = {
          // $gte: '',
          $lt: moment(endDate),
        };
      }
      // }

      /** search by date */
      // if (startDate || endDate && !_.isEmpty(date)) {
      //   if (date.length === 1) {
      //     findQuery.createdOn = {
      //       $gte: moment(startDate),
      //       $lt: moment(startDate)
      //     }
      //   } else {
      //     findQuery.createdOn = {
      //       $gte: new Date(date[0]),
      //       $lt: new Date(date[1])
      //     }
      //   }
      // } else {
      //
      // }

      /** get news */
      const orders = await Order.find(findQuery).populate({ path: "user_id", select: "first_name last_name" }).sort({ _id: -1 });

      let result = {
        count: orders?.length || 0,
        total:
          orders?.reduce((total, item) => {
            return total + item?.total;
          }, 0) || 0,
        payOnline:
          orders?.reduce((total, item) => {
            return total + item?.payTotal;
          }, 0) || 0,
        routePrice:
          orders?.reduce((total, item) => {
            return total + item?.routePrice;
          }, 0) || 0,
        bagCost:
          orders?.reduce((total, item) => {
            return total + item?.bagCost;
          }, 0) || 0,
        scorePoint:
          orders?.reduce((total, item) => {
            return total + item?.scorePoint;
          }, 0) || 0,
        scoreCost:
          orders?.reduce((total, item) => {
            return total + item?.scoreCost;
          }, 0) || 0,
      };

      /** show result */
      return res.json(result);
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

//////////////////////////////////// compute price
module.exports.computePrice = [
  //////////////////// validation step
  (req, res, next) => {
    const branchId = req?.params?.branchId;
    CartItem.find({ branchId, user_id: req.user._id }).then((items) => {
      // check if cart is not empty
      if (items.length) {
        // check product stock
        let outOfRun = [];
        items.forEach(async (item, index) => {
          await Food.findById(item.product_id).then((product) => {
            if (product.stock < item.quantity) {
              outOfRun.push({
                product_id: product._id,
                category_id: product.category,
                stock: product.stock,
              });
              item.remove();
            }
            if (index + 1 === items.length) {
              if (!outOfRun.length) return next();
              else return res.status(422).json(outOfRun);
            }
          });
        });
      } else {
        return res.status(404).json({ message: _sr["fa"].response.cart_empty });
      }
    });
  },
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId;
      const cartItems = await CartItem.find({ branchId, user_id: req.user._id }).populate({
        path: "product_id",
        populate: {
          path: "category",
          model: "FoodCategory",
        },
      });
      const checkOrder = await Order.findOne({ branchId, status: "incomplete", user_id: req.user._id });
      const getUserInfo = await User.findById(req.user._id);
      const getStoreInfo = await StoreInfo.findOne({ _id: branchId });
      const product = [];
      const userAddress = getUserInfo.addresses.find((item) => item.used === true) || null;
      let specialDiscountMenuType = false;
      let discount_percent = checkOrder?.discount_amount || 0;
      let discount_menuType = checkOrder?.discount_menuType;
      let routePrice = 0;
      let sum = 0;
      let sumFoodByPercent = 0;
      let sumFoodByPercentForDiscount = 0;
      let total = 0;
      let percent = 0;
      let tax = 0;

      if (!getUserInfo) return res404(res, `اطلاعات کاربر یافت نشد`);

      if (!cartItems.length) return res.status(404).json({ message: `هیچ محصولی در سبد خرید شما وجود ندارد` });

      if (checkOrder) {
        const orderItems = [];
        for (const item of cartItems) {
          orderItems.push({
            product_id: item.product_id._id,
            name: item.product_id.name,
            quantity: item.quantity,
            price: item.product_id.price,
            static_discount: item.product_id.static_discount,
            havePoint: item.product_id.havePoint,
          });

          product.push({
            product: item.product_id,
            quantity: item.quantity,
          });

          const itemPercent = (item.product_id.price * item.product_id.static_discount) / 100;
          const sumPercent = itemPercent * item.quantity;
          const price = item.product_id.price;
          const sumPriceItem = price * item.quantity;

          let sumByPercentForDiscount = sumPriceItem - sumPercent;

          if (Boolean(discount_percent) && discount_menuType) {
            specialDiscountMenuType = true;
            if (item?.product_id?.category.type?.toString() === discount_menuType?.toString()) {
              sumFoodByPercentForDiscount += sumByPercentForDiscount;
            }
          }

          sum = sum + sumPriceItem; /// sum food price without percent
          percent = percent + sumPercent; /// sum all food percent
        }

        /// sum food price with percent
        sumFoodByPercent = sum - percent;

        /// compute shipping cost
        if (getStoreInfo) {
          if (getStoreInfo?.shippingType) {
            routePrice = getStoreInfo?.shippingCost || 0;
          } else {
            routePrice =
              (await _computeShippingCostByRoad(getUserInfo?.addresses, getStoreInfo?.location)) * (getStoreInfo?.shippingCost || 0) || 0;
          }

          /// compute tax of order
          if (getStoreInfo?.tax) {
            tax = (sumFoodByPercent * 9) / 100;
          }
        }

        /// compute discount code
        if (Boolean(discount_percent)) {
          let discountPercent = ((specialDiscountMenuType ? sumFoodByPercentForDiscount : sumFoodByPercent) * discount_percent) / 100;
          percent = percent + discountPercent;
          /// compute sum food with discount percent
          sumFoodByPercent = sumFoodByPercent - discountPercent;
        }

        /// compute total of order
        total = sumFoodByPercent + tax + routePrice;

        checkOrder.order_items = orderItems;
        checkOrder.createdOn = Date.now();
        checkOrder.sum = Math.ceil(sum);
        checkOrder.routePrice = Math.ceil(routePrice);
        checkOrder.tax = Math.ceil(tax);
        checkOrder.percent = Math.ceil(percent);
        checkOrder.total = Math.ceil(total);
        checkOrder.pricePoint = getStoreInfo?.pricePoint;

        if (checkOrder.bag) {
          const payPrice = total - getUserInfo?.bagAmount;
          total = payPrice <= 0 ? 0 : payPrice;
        }

        if (checkOrder.score && getStoreInfo?.pricePoint > 0) {
          const payScore = total - getUserInfo?.score * getStoreInfo?.pricePoint;
          total = payScore <= 0 ? 0 : payScore;
        }

        checkOrder.payTotal = Math.ceil(total);

        checkOrder.save();
      }

      return res.json({
        usePoint: getStoreInfo?.usePointWhenPay,
        product,
        userAddress,
        sum: Math.ceil(sum),
        routePrice: Math.ceil(routePrice),
        tax: Math.ceil(tax),
        percent: Math.ceil(percent),
        total: Math.ceil(checkOrder.payTotal),
      });
    } catch (error) {
      console.log(error.message);
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

////////////////////////////////////// get list of all orders for admin
module.exports.getAllOrders = [
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId;
      const orders = await Order.paginate(
        { branchId, status: { $nin: ["incomplete", "void"] } },
        {
          page: req.query.page || 1,
          limit,
          populate: [{ path: "user_id", select: "first_name last_name" }],
          sort: { _id: -1 },
        },
      );

      return res.json(orders);
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

///////////////////////////////////// get payment list
module.exports.getAllPaymentByUser = [
  async (req, res) => {
    try {
      const getAll = await Payment.find({ user_id: req.user._id }).sort({ _id: -1 });
      return res.json(getAll);
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

module.exports.getAllPaymentByAdmin = [
  async (req, res) => {
    try {
      const getAll = await Payment.paginate(
        { user_id: req.params.id },
        {
          page: req.query.page || 1,
          limit,
          sort: { _id: -1 },
        },
      );
      return res.json(getAll);
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

//////////////////////////////////// get all foods for rates
module.exports.getAllRateFood = [
  async (req, res) => {
    try {
      const getOrder = await Order.findOne({
        _id: req.params.order_id,
        user_id: req.user._id,
        status: "delivered",
        paymentStatus: "paid",
      }).populate({
        path: "order_items.product_id",
        select: "name ratings",
      });

      if (!getOrder) return res404(res, `سفارش مورد نظر پیدا نشد`);

      return res.json(getOrder);
    } catch (e) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

/////////////////////////////////// rate order
module.exports.rateOrderAndFood = [
  [body("rateOrder").notEmpty().withMessage(_sr["fa"].required.field)],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const orderId = req?.params?.order_id;
      const { rateOrder, reason, foods } = req.body;
      const getOrder = await Order.findOne({
        _id: orderId,
        user_id: req.user._id,
        status: "delivered",
        paymentStatus: "paid",
      });

      if (!getOrder) return res404(res, `سفارش مورد نظر پیدا نشد`);

      //// add rate for all foods
      for (const food of foods) {
        const data = {
          rate: food.rate,
          comment: food.comment,
          order_id: getOrder._id,
          user_id: getOrder.user_id,
        };
        //// check food exist or not
        const getFood = await Food.findById(food?.product_id?._id);

        if (getFood && getOrder?.order_items.some((item) => item?.product_id?._id?.toString() === getFood?._id?.toString())) {
          getFood.ratings.push(data);
          let rateSUM = 0;
          getFood?.ratings?.forEach((item) => (rateSUM += Number(item.rate)));
          getFood.rate = (rateSUM / getFood?.ratings?.length).toFixed(1);
          await getFood.save();
        }
      }

      //// add rate to order
      getOrder.rating = {
        rate: rateOrder,
        reasonForBad: reason,
      };

      await getOrder.save();

      return res.json({ message: _sr["fa"].response.success_save });
    } catch (e) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

////////////////////////////////// buy club
module.exports.buyClub = [
  [body("clubId").notEmpty().withMessage(_sr["fa"].required.field)],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const clubId = req.body?.clubId;

      const user = await User.findById(req.user._id);
      if (!user) return res404(res, "اطلاعات کاربر یافت نشد");

      const club = await Food.findOne({ _id: clubId, club: true });
      if (!club) return res404(res, "کلاب مورد نظر پیدا نشد");

      if (user.score < club.point) return res.status(422).json({ message: "امتیاز شما برای خرید این محصول کافی نمی باشد" });

      const data = {
        user_id: user._id,
        score: true,
        scorePoint: club.point,
        scoreCost: club.price,
        orderType: "club",
        number: Date.now(),
        address: user?.addresses.find((item) => item.used),
        createdOn: Date.now(),
        paymentStatus: "paid",
        statuses: [
          {
            status: "processing",
          },
        ],
        status: "processing",
        order_items: [
          {
            product_id: club._id,
            name: club.name,
            quantity: 1,
            price: club.price,
            point: club.point,
            havePoint: true,
          },
        ],
        sum: club.point,
        routePrice: 0,
        tax: 0,
        percent: 0,
        total: club.price,
      };

      const order = await Order.create(data);
      if (!order) return res500(res, _sr["fa"].response.unknownError);

      user.score -= club.point;
      user.scoreLogs = [
        {
          score: club.point,
          order_id: order._id,
          forWhat: "buy",
          action: "decrease",
        },
      ];
      await user.save();

      club.stock -= club?.clubQuantity || 1;
      await club.save();

      return res.json({ message: _sr["fa"].response.success_save });
    } catch (error) {
      return res500(res, _sr["fa"].response.unknownError);
    }
  },
];

////////////////////////////////// test notif
module.exports.testNotif = [
  async (req, res) => {
    try {
      sendNotifyOrder("6126313206f2593a6a4f71db");
      return res.json({});
    } catch (error) {
      return res500(res, error.message);
    }
  },
];

module.exports.chromeNotif = [
  async (req, res) => {
    try {
      const fcmTokens = [];
      const allAdmins = await User.find({ scope: "admin" });

      for (const admin of allAdmins) {
        if (admin.fcmToken) fcmTokens.push(admin.fcmToken);
      }

      const objNotif = {
        title: "سفارش جدید!",
        body: "یک سفارش جدید در پنل برگ من ثبت گردید",
      };

      const payload = {
        notification: objNotif,
        data: {
          routeName: "test",
          type: "bazaar",
          routeType: "viewBazaar",
        },
      };
      console.log(fcmTokens);

      const input = {
        registrationTokens: fcmTokens,
        payload,
      };

      console.log(input);

      const test = await sendMulti(input);

      return res.json(test);
      // const payload = JSON.stringify({
      //   title: 'Push notifications with Service Workers',
      // });
      //
      // webPush.sendNotification('test', payload)
      //    .catch(error => console.error(error));
    } catch (error) {}
  },
];