import PredefinedItemImageDB from "../../models/pre_defined_item_images.model.js"
import AddonSizeCafeItemDB from "../../models/addon_size_cafe_items.model.js"
import CafeMenuItemSizeDB from "../../models/cafe_menu_item_sizes.model.js"
import UserFavouriteCafeDB from "../../models/user_favorite_cafes.model.js"
import LoyaltyStampDB from "../../models/manage_loyalty_stamps.model.js"
import GroupCoffeeRunDB from "../../models/group_coffee_run.model.js"
import NotificationDB from "../../models/notification_list.model.js"
import CafeMenuItemDB from "../../models/cafe_menu_items.model.js"
import CafeTimingDB from "../../models/cafe_timings.model.js"
import GroupMemberDB from "../../models/group_members.model.js"
import { messages } from "../../config/response.messages.js"
import AddonSizeDB from "../../models/addon_sizes.model.js"
import GroupDB from "../../models/groups.model.js"
import OrderDB from "../../models/orders.model.js"
import CafeDB from "../../models/cafes.model.js"
import UserDB from "../../models/users.model.js"
import * as config from "../../config/config.js"
import SizeDB from "../../models/sizes.model.js"
import * as Helper from "../../helper/index.js"
import Sequelize, { json } from "sequelize"
import { Op } from "sequelize"
import moment from "moment"

// create Group
export async function saveGroupCoffeeRun(data, loggedInUser) {
  try {
    let request_unique_id = (
      await Helper.generateRandomString(15)
    ).toUpperCase();
    let createRequestObj = {
      request_unique_id: request_unique_id,
      cafe_id: data.cafe_id,
      group_id: data.group_id,
      request_created_by: loggedInUser.id,
      request_endtime: data.request_endtime,
      created_at: moment().unix(),
      updated_at: moment().unix(),
    };
    data.users.forEach(async (element) => {
      createRequestObj.user_id = element.id;
      createRequestObj.is_contributor_person = element.is_contributor_person;
      let requestResult = await GroupCoffeeRunDB.create(createRequestObj);

      // create notification obj
      if (element.id != loggedInUser.id) {
        await NotificationDB.create({
          sender_id: loggedInUser.id,
          receiver_id: element.id,
          reference_id: requestResult.id,
          notification_type: 2,
          is_read: 0,
          created_at: moment().unix(),
          updated_at: moment().unix(),
        });
        let title = messages.coffe_run;
        let body =
          "Hey there, " +
          loggedInUser.name +
          " " +
          messages.invited_to_join_group_coffee_run;
        // send push notification
        Helper.sendPushNotification(element.id, title, body, 2, {
          cafe_id: data.cafe_id,
          group_id: data.group_id,
          request_endtime: data.request_endtime
        });
      }
    });
    return true;
  } catch (error) {
    throw new Error(error);
  }
}

//get cafe list by group id and edit time
export async function getGroupCoffeeRun(data) {
  try {
    if ([null, undefined, 0, "", "0"].includes(data.cafe_id)) {
      let check = await GroupCoffeeRunDB.findOne({
        where: {
          group_id: data.group_id,
          request_endtime: {
            [Op.gte]: moment().unix(),
          },
        },
      });
      if (check) {
        data.cafe_id = check.cafe_id;
      } else {
        return []
      }
    }

    let result = await GroupCoffeeRunDB.findAll({
      order: [
        ['id', 'DESC']
      ],
      where: {
        group_id: parseInt(data.group_id),
        cafe_id: parseInt(data.cafe_id),
        request_endtime: {
          [Op.gte]: moment().unix(),
        },
        order_id: null,
        request_endtime: {
          [Op.gte]: moment().unix(),
        },
      },
      order: [['id', 'DESC']],
      include: [
        {
          model: UserDB,
          as: "creator_data",
          where: {
            is_deleted: 0,
            is_active: 1,
          },
          required: true,
          attributes: ["id", "name", "profile_picture", "email"],
        },

        {
          model: GroupDB,
          where: {
            is_active: 1,
          },
          include: [
            {
              model: GroupMemberDB,
              as: 'group_details',
              attributes: ['id', 'user_id'],
              include: [{
                model: UserDB,
                as: 'user_data',
                attributes: ['id', 'name', 'email', 'profile_picture'],
                where: { is_deleted: 0, is_active: 1, is_verified: 1 }
              }]
            }
          ],
          required: true,
          attributes: ["id", "group_name", "group_profile", "created_at", "group_code"],
        },

        {
          model: UserDB,
          as: "user_data",
          where: {
            is_deleted: 0,
            is_active: 1,
          },
          required: true,
          attributes: ["id", "name", "profile_picture", "email"],
        },
      ],
      attributes: [
        "id",
        "request_unique_id",
        "is_contributor_person",
        "is_order_place",
        "order_id",
        "request_endtime",
        "created_at",
        "cafe_id"
      ],
    });
    return result;
  } catch (error) {
    throw new Error(error);
  }
}

// check same time group cafe run can create or not
export async function checkSameGroupCafeRunEndTime(data) {
  try {
    return await GroupCoffeeRunDB.findOne({
      where: {
        // cafe_id: data.cafe_id,  //comment for resolve JG-548 bug
        group_id: data.group_id,
        request_endtime: {
          [Op.gte]: moment().unix(),
        },
      },
    });
  } catch (error) {
    return false;
  }
}

// place order
export async function placeOrder(data) {
  try {
    let todayDayId = new Date().getDay();
    let currentTime = moment().format("HH:mm");
    if (data.group_coffee_run_id) {
      let checkRequestEndTime = await GroupCoffeeRunDB.findOne({
        where: {
          id: parseInt(data.group_coffee_run_id)
        }
      })
      if (!checkRequestEndTime) {
        return {
          status: 203,
          message: messages.group_coffee_run_wrong_passed,
          result: {},
        };
      } else if (checkRequestEndTime && checkRequestEndTime.request_endtime < moment().unix()) {
        return {
          status: 203,
          message: messages.group_coffee_run_end_time_up,
          result: {},
        };
      }
    }
    let itemsArray = data.order_item_array.map(function (currentValue) {
      return currentValue.item_id;
    });
    let result = await CafeDB.findOne({
      where: {
        id: data.cafe_id,
        is_active: 1,
        deleted_at: 0,
      },
      include: [
        {
          model: CafeTimingDB,
          where: {
            day: todayDayId,
            open_time: {
              [Op.lte]: currentTime,
            },
            close_time: {
              [Op.gte]: currentTime,
            },
          },
          required: false,
          attributes: ["id"],
          as: "time_sheet_data",
        },
        {
          model: CafeMenuItemDB,
          where: {
            id: {
              [Op.in]: itemsArray,
            },
          },
          include: [
            {
              model: CafeMenuItemSizeDB,
              required: false,
              include: [
                {
                  model: SizeDB,
                  required: false,
                  attributes: ["size_name"],
                },
              ],
              attributes: ["item_size_price"],
            },
            {
              model: AddonSizeCafeItemDB,
              required: false,
              include: [
                {
                  model: AddonSizeDB,
                  required: false,
                  attributes: ["addon_size_price"],
                },
              ],
              attributes: ["addon_size_id"],
            },
          ],
          required: false,
          attributes: [
            "id",
            "item_price",
            "status",
            "item_deleted_at",
            "item_name",
          ],
        },
      ],
      attributes: ["id"],
    });
    let final_result;
    if (!result) {
      final_result = {
        status: 203,
        message: messages.cafe_is_not_available,
      };
    } else if (result && result.time_sheet_data.length == 0) {
      final_result = {
        status: 203,
        message: messages.cafe_has_been_closed,
      };
    } else if (result && result.cafe_menu_items.length == 0) {
      final_result = {
        status: 203,
        message: messages.cafe_selected_items_not_avaialble,
      };
    } else if (result && result.cafe_menu_items.length) {
      let message = "";
      let items_prices = 0;
      for (let index = 0; index < result.cafe_menu_items.length; index++) {
        const element = result.cafe_menu_items[index];
        if (element.status == 0 || element.item_deleted_at > 0) {
          message += element.item_name;
          if (
            result.cafe_menu_items.length > 1 &&
            index != parseInt(result.cafe_menu_items.length) - 1
          ) {
            message += ", ";
          }
        }
        if (
          data.order_item_array.some(
            (children) =>
              children.item_size == "Regular" && children.item_id == element.id
          )
        ) {
          var qty = 1
          data.order_item_array.map((children) => {
            if (children.item_id == element.id) {
              qty = children.item_quantity
            }
          });
          items_prices = items_prices + Number(element.item_price) * qty;

          // now check addons prices
          for (let i = 0; i < data.order_item_array.length; i++) {
            const element1 = data.order_item_array[i];
            if (element1.item_id == element.id) {
              for (let j = 0; j < element1.addon_sizes.length; j++) {
                const element2 = element1.addon_sizes[j];
                let check = 0
                element.addon_size_cafe_items.map(
                  (grandChildren) => {
                    if (grandChildren.addon_size_id == element2.addon_size_id &&
                      element1.item_id == element.id) {
                      check = grandChildren.addon_size.addon_size_price
                    }
                  });
                items_prices += check
              }
            }
          }
        } else if (
          data.order_item_array.some(
            (children) =>
              children.item_size != "Regular" && children.item_id == element.id
          )
        ) {
          for (let i = 0; i < data.order_item_array.length; i++) {
            const element1 = data.order_item_array[i];
            if (
              element1.item_size != "Regular" &&
              element.cafe_menu_item_sizes.some(
                (children) =>
                  children.size.size_name == element1.item_size &&
                  element1.item_id == element.id
              )
            ) {
              var tmp = 0
              element.cafe_menu_item_sizes.map(function (
                childrenElement
              ) {
                if (childrenElement.size.size_name == element1.item_size) {
                  tmp = childrenElement.item_size_price
                }
              });
              items_prices += tmp
                ? tmp * element1.item_quantity
                : 0;
            }
            // now check addons prices
            if (element1.item_id == element.id) {
              for (let j = 0; j < element1.addon_sizes.length; j++) {
                const element2 = element1.addon_sizes[j];
                let check = 0
                element.addon_size_cafe_items.map(
                  (grandChildren) => {
                    if (grandChildren.addon_size_id == element2.addon_size_id &&
                      element1.item_id == element.id) {
                      check = grandChildren.addon_size.addon_size_price
                    }
                  });
                items_prices += check
              }
            }
          }
        }
      }
      if (message) {
        final_result = {
          status: 203,
          message: message + " items not available",
          result: result,
        };
      } else if (
        message == "" &&
        Number(items_prices) != Number(data.items_amount)
      ) {
        final_result = {
          status: 203,
          message: messages.item_price_updated_error,
          result: result,
        };
      } else {
        if (data.loyalty_stamp_id) {
          let checkLoyaltyStamp = await LoyaltyStampDB.findOne({
            where: {
              id: parseInt(data.loyalty_stamp_id)
            }
          })
          if (checkLoyaltyStamp) {
            final_result = {
              status: 200,
              message: messages.data_found,
              result: result,
            };
          } else {
            final_result = {
              status: 203,
              message: messages.redeem_code_no_longer_available,
              result: result,
            };
          }

        } else {
          final_result = {
            status: 200,
            message: messages.data_found,
            result: result,
          };
        }
      }
      console.log(items_prices);
    }
    return final_result;
  } catch (error) {
    throw new Error(error);
  }
}

// save order
export async function saveOrder(data) {
  try {
    for (let index = 0; index < data.order_item_array.length; index++) {
      const element = data.order_item_array[index];
      let itemImageData = await CafeMenuItemDB.findByPk(element.item_id, {
        include: [
          {
            model: PredefinedItemImageDB,
            as: "image_data",
            required: true,
          },
        ],
      });
      element.item_image = itemImageData
        ? itemImageData.image_data.item_image
        : "";
    }

    let result = await OrderDB.create({
      order_number: await Helper.generateRandomString(6, true),
      user_id: data.loggedInUser,
      cafe_id: data.cafe_id,
      group_id: data.group_id ? data.group_id : null,
      group_coffee_run_id: data.group_coffee_run_id ? data.group_coffee_run_id : null,
      loyalty_stamp_id: data.loyalty_stamp_id ? data.loyalty_stamp_id : null,
      is_main_order: data.is_main_order,
      order_item_array: JSON.stringify(data.order_item_array),
      additional_note: data.additional_note,
      total_amount: data.total_amount ? Number(data.total_amount) : 0,
      tax: data.tax ? Number(data.tax) : 0,
      discount_amount: data.discount_amount ? Number(data.discount_amount) : 0,
      order_placed_at: moment().unix(),
      status: 1,
      created_at: moment().unix(),
      updated_at: moment().unix(),
    });
    if (data.group_coffee_run_id) {
      await GroupCoffeeRunDB.update(
        { order_id: result.id, updated_at: moment().unix() },
        {
          where: {
            id: parseInt(data.group_coffee_run_id),
          },
          returning: true,
          plain: true,
        }
      );
      let returnDoc = await GroupCoffeeRunDB.findOne({
        where: {
          id: parseInt(data.group_coffee_run_id),
        },
      });
      await OrderDB.update(
        {
          request_unique_id: returnDoc.request_unique_id,
        },
        {
          where: {
            id: result.id,
          },
        }
      );
    }
    if (typeof result.order_item_array == 'string') result.order_item_array = JSON.parse(result.order_item_array)
    return result;
  } catch (error) {
    throw new Error(error);
  }
}

// get order list
export async function getOrder(userId, data) {
  try {
    if ([null, undefined, "", 0].includes(data.page)) data.page = 1;
    data.page = parseInt(data.page);
    let result = await OrderDB.paginate({
      page: data.page,
      paginate: parseInt(config.config.limit),
      where: {
        user_id: userId,
      },
      include: [
        {
          model: CafeDB,
          where: {
            is_active: 1,
            deleted_at: 0,
          },
          include: [
            {
              model: UserFavouriteCafeDB,
              as: 'user_favorite_cafes',
              required: false,
              where: {
                is_favorite: 1,
                user_id: parseInt(userId)
              },
              attributes: ['is_favorite', 'user_id'],
            },
          ],
          required: false,
          attributes: ['id', 'cafe_name', 'phone', 'latitude', 'bio', 'email', 'cafe_tax', 'longitude', 'address', 'banner_image', 'postcode']
        },
        {
          model: GroupDB,
          required: false,
          attributes: ['id', 'group_name', 'group_profile'],
          include: [
            {
              model: GroupMemberDB,
              as: 'group_details',
              attributes: ['id', 'user_id'],
              include: [{
                model: UserDB,
                as: 'user_data',
                attributes: ['id', 'name', 'email', 'profile_picture'],
                where: { is_deleted: 0, is_active: 1, is_verified: 1 }
              }]
            }
          ]
        }
      ],
      attributes: [
        "id",
        "order_number",
        "created_at",
        "updated_at",
        "order_item_array",
        "additional_note",
        "total_amount",
        "tax",
        "discount_amount",
        "order_placed_at",
        "order_collected_at",
        "status",
      ],
      order: [["id", "DESC"]],
    });
    result = JSON.stringify(result);
    result = JSON.parse(result);
    for (let index = 0; index < result.docs.length; index++) {
      const element = result.docs[index];
      element.group_coffee_run = await GroupCoffeeRunDB.findAll({
        where: {
          order_id: element.id,
        },
        include: [
          {
            model: UserDB,
            attributes: ["id", "name", "profile_picture", "email"],
            required: true,
            where: {
              is_deleted: 0,
              is_active: 1,
            },
            as: "user_data",
          },
          {
            model: UserDB,
            attributes: ["id", "name", "profile_picture", "email"],
            required: true,
            where: {
              is_deleted: 0,
              is_active: 1,
            },
            as: "creator_data",
          },
        ],
        attributes: [
          'id', 'request_unique_id', 'is_contributor_person', 'is_order_place', 'request_endtime'
        ]
      })
      element.cafe.is_favorite = element.cafe.user_favorite_cafes.length > 0 ? 1 : 0;
      element.cafe.distance = 0;
      element.cafe.time_sheet_data = [];
      delete element.cafe.user_favorite_cafes
    }
    return result;
  } catch (error) {
    throw new Error(error);
  }
}

// get Individual order list
export async function getIndividualOrder(user_id, order_id, cafe_id) {
  try {
    let result = await OrderDB.findOne({
      where: {
        user_id: user_id,
        id: order_id,
        cafe_id: cafe_id
      },
      include: [
        {
          model: CafeDB,
          where: {
            is_active: 1,
            deleted_at: 0,
          },
          include: [
            {
              model: UserFavouriteCafeDB,
              as: 'user_favorite_cafes',
              required: false,
              where: {
                is_favorite: 1,
                user_id: parseInt(user_id)
              },
              attributes: ['is_favorite', 'user_id'],
            },
          ],
          required: false,
          attributes: ['id', 'cafe_name', 'phone', 'latitude', 'longitude', 'address', 'banner_image', 'postcode']
        },
        {
          model: GroupDB,
          required: false,
          attributes: ['id', 'group_name', 'group_profile'],
          include: [
            {
              model: GroupMemberDB,
              as: 'group_details',
              attributes: ['id', 'user_id'],
              include: [{
                model: UserDB,
                as: 'user_data',
                attributes: ['id', 'name', 'email', 'profile_picture'],
                where: { is_deleted: 0, is_active: 1, is_verified: 1 }
              }]
            }
          ]
        }
      ],
      attributes: [
        "id",
        "order_number",
        "created_at",
        "updated_at",
        "order_item_array",
        "additional_note",
        "total_amount",
        "tax",
        "discount_amount",
        "order_placed_at",
        "order_collected_at",
        "status",
      ],
    });
    return result
  } catch (error) {
    throw new Error(error);
  }
}

// change order status
export async function changeOrderStatus(orderId, data) {
  try {
    let check = await OrderDB.findByPk(orderId);
    if (!check) {
      return {
        status: 501,
        message: messages.wrong_order_id_applied,
      };
    }
    if (check.status == parseInt(data.flag)) {
      if (check.status == 1) {
        return {
          status: 409,
          message:
            messages.order_has_been_already_placed +
            " at " +
            check.order_placed_at,
          data: {
            cafe_id: check.cafe_id
          }
        };
      }
      return {
        status: 409,
        message:
          messages.order_has_been_already_collected +
          " at " +
          check.order_collected_at,
        data: {
          cafe_id: check.cafe_id
        }
      };
    }
    let updateObj = {
      status: parseInt(data.flag),
      updated_at: moment().unix(),
    };
    if (parseInt(data.flag) == 1) {
      updateObj.order_placed_at = moment().unix();
    } else {
      updateObj.order_collected_at = moment().unix();
    }
    let result = await OrderDB.update(updateObj, {
      where: {
        id: orderId,
      },
    });
    return {
      status: 202,
      message:
        parseInt(data.flag) == 1
          ? messages.order_has_been_placed
          : messages.order_has_been_collected,
      data: {
        cafe_id: check.cafe_id
      }
    };
  } catch (error) {
    throw new Error(error);
  }
}

// Get Total Order cafe wise
export async function getAllCafeOrders(user_id, cafe_id) {
  try {
    return await OrderDB.count({
      where: {
        user_id: parseInt(user_id),
        cafe_id: cafe_id,
        status: 2,
        loyalty_stamp_id: null
        // cafe_coupon_expired_time: 0
      },
    })
  } catch (error) {
    throw new Error(error);
  }
}

// Get Total Order
export async function getUniversalOrders(user_id) {
  try {
    return await OrderDB.count({
      where: {
        user_id: parseInt(user_id),
        status: 2,
        universal_coupon_expired_time: 0
      },
    })
  } catch (error) {
    throw new Error(error);
  }
}

// Get last universal expires time
export async function getLastExpireDateUniversal(user_id) {
  try {
    return await OrderDB.findOne({
      where: {
        user_id: parseInt(user_id),
        status: 2,
        universal_coupon_expired_time: {
          [Op.ne]: 0
        }
      },
      order: [["id", "DESC"]],
    })
  } catch (error) {
    throw new Error(error);
  }
}

// Get last universal expires time
export async function getLastExpireCafeDate(user_id, cafe_id) {
  try {
    return await OrderDB.findOne({
      where: {
        user_id: parseInt(user_id),
        status: 2,
        cafe_id: cafe_id,
        cafe_coupon_expired_time: {
          [Op.ne]: 0
        }
      },
      order: [["id", "DESC"]],
    })
  } catch (error) {
    throw new Error(error);
  }
}

//Get cafe universal stamp
export async function getUniversalStamp() {
  try {
    let nonUniversal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: null,
        is_universal: 1
      }
    })
    return nonUniversal;
  } catch (error) {
    throw new Error(error);
  }
}

//Get cafe stemp by cafe ID
export async function getStampsByCafe(cafe_id) {
  try {
    let nonUniversal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: parseInt(cafe_id),
        is_universal: 0
      }
    })
    return nonUniversal;
  } catch (error) {
    throw new Error(error);
  }
}

//update coupons by cafe
export async function updateCouponByCafeId(user_id, coupon_id, cafe_id, stamp_no, stamp_expires_in) {
  try {
    let orderIds = [];
    let expireDay = moment().unix()
    let orderDetails = await OrderDB.findAll({
      where: {
        user_id: parseInt(user_id),
        status: 2,
        cafe_coupon_expired_time: 0,
        cafe_id: cafe_id
      },
      attributes: ['id'],
      order: [["id", "ASC"]],
      limit: stamp_no
    })
    for (let i = 0; i < orderDetails.length; i++) {
      orderIds.push(orderDetails[i].id)
    }
    return await OrderDB.update(
      {
        cafe_coupon_order_id: coupon_id,
        cafe_coupon_expired_time: moment(expireDay, 'X').add(stamp_expires_in, 'days').unix(),
      },
      {
        where: {
          cafe_id: parseInt(cafe_id),
          user_id: user_id,
          id: {
            [Op.in]: orderIds
          }
        },
      }
    )
  } catch (error) {
    console.log("error: ", error);
    throw new Error(error);
  }
}

//update universal coupons 
export async function updateUniversalCoupon(user_id, coupon_id, stamp_no, stamp_expires_in) {
  try {
    let orderIds = [];
    let expireDay = moment().unix()
    let orderDetails = await OrderDB.findAll({
      where: {
        user_id: parseInt(user_id),
        status: 2,
        universal_coupon_expired_time: 0
      },
      attributes: ['id'],
      order: [["id", "ASC"]],
      limit: stamp_no
    })
    for (let i = 0; i < orderDetails.length; i++) {
      orderIds.push(orderDetails[i].id)
    }
    return await OrderDB.update(
      {
        universal_coupon_order_id: coupon_id,
        universal_coupon_expired_time: moment(expireDay, 'X').add(stamp_expires_in, 'days').unix(),
      },
      {
        where: {
          user_id: user_id,
          id: {
            [Op.in]: orderIds
          }
        },
      }
    )
  } catch (error) {
    throw new Error(error);
  }
}

// Get Loyalty list
export async function loyaltyList(data, query) {
  try {
    let loyaltyDetails = await OrderDB.paginate({
      paginate: 10,
      page: query.page,
      order: [["id", "ASC"]],
      attributes: [
        "user_id",
        "cafe_id",
        [Sequelize.fn("COUNT", Sequelize.col("orders.id")), "Count"],
      ],
      include: [
        {
          model: CafeDB,
          attributes: ["id", "cafe_name"],
          include: [
            {
              model: LoyaltyStampDB,
              attributes: ["stamp_no", "cafe_id", "offer_text"],
            },
          ],
        },
      ],
      distinct: false,
      col: "status",
      group: ["cafe_id"],
      where: { user_id: data, status: 2, cafe_coupon_expired_time: 0, cafe_coupon_order_id: null },
    });
    return loyaltyDetails;
  } catch (error) {
    throw new Error(error);
  }
}

// Get universal Loyalty list
export async function universalCardList(user_id) {
  try {
    return await OrderDB.count({
      where: {
        user_id: parseInt(user_id),
        // universal_coupon_order_id: null,
        universal_coupon_expired_time: 0,
        status: 2
      },
    })
  } catch (error) {
    throw new Error(error);
  }
}

// get redeem code
export async function getRedeemCode(data) {
  try {
    let final_result = {
      universal: {},
      nonUniversal: {}
    }
    let checkTotalOrder = await OrderDB.count({
      where: {
        user_id: data.userId,
        status: 2
      }
    })
    let nonUniversal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: parseInt(data.cafe_id),
        is_universal: 0
      }
    })
    let universal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: null,
        is_universal: 1
      }
    })
    let checkTotalRedeem = await OrderDB.count({
      where: {
        user_id: parseInt(data.userId),
        loyalty_stamp_id: universal.id,
        status: 2
      },
    })
    let checkTotalCafeRedeem = await OrderDB.count({
      where: {
        user_id: parseInt(data.userId),
        loyalty_stamp_id: parseInt(data.cafe_id),
        status: 2
      },
    })
    if (universal.stamp_no <= checkTotalOrder) {
      let deno = checkTotalRedeem > 0 ? checkTotalOrder - (checkTotalRedeem * universal.stamp_no) : checkTotalOrder;
      final_result.universal = deno >= universal.stamp_no ? universal : {};
    }
    if (nonUniversal.stamp_no <= checkTotalOrder) {
      let deno = checkTotalCafeRedeem > 0 ? checkTotalOrder - (checkTotalCafeRedeem * nonUniversal.stamp_no) : checkTotalOrder;
      final_result.nonUniversal = deno >= nonUniversal.stamp_no ? nonUniversal : {};
    }
    return final_result
  } catch (error) {
    throw new Error(error)
  }
}

// apply redeem code
export async function applyRedeemCode(order_id) {
  try {
    let final_result = await OrderDB.update(
      {
        cafe_coupon_order_id: order_id
      },
      {
        where: {
          id: order_id,
        },
      }
    );
    return final_result
  } catch (error) {
    throw new Error(error)
  }
}

export async function orderListByGroup(data) {
  try {
    if ([null, undefined, "", 0].includes(data.page)) data.page = 1;
    data.page = parseInt(data.page);
    let result = await OrderDB.paginate({
      page: data.page,
      paginate: parseInt(config.config.limit),
      where: {
        group_id: parseInt(data.group_id),
      },
      include: [
        {
          model: CafeDB,
          where: {
            is_active: 1,
            deleted_at: 0,
          },
          include: [
            {
              model: UserFavouriteCafeDB,
              as: 'user_favorite_cafes',
              required: false,
              where: {
                is_favorite: 1,
                user_id: parseInt(data.userId)
              },
              attributes: ['is_favorite', 'user_id'],
            },
          ],
          required: false,
          attributes: ['id', 'cafe_name', 'phone', 'latitude', 'bio', 'email', 'cafe_tax', 'longitude', 'address', 'banner_image', 'postcode']
        },
        {
          model: GroupDB,
          required: false,
          attributes: ['id', 'group_name', 'group_profile'],
          include: [
            {
              model: GroupMemberDB,
              as: 'group_details',
              attributes: ['id', 'user_id'],
              include: [{
                model: UserDB,
                as: 'user_data',
                attributes: ['id', 'name', 'email', 'profile_picture'],
                where: { is_deleted: 0, is_active: 1, is_verified: 1 }
              }]
            }
          ]
        }
      ],
      attributes: [
        "id",
        "order_number",
        "created_at",
        "updated_at",
        "order_item_array",
        "additional_note",
        "total_amount",
        "tax",
        "discount_amount",
        "order_placed_at",
        "order_collected_at",
        "status",
      ],
      order: [["id", "DESC"]],
    });
    result = JSON.stringify(result);
    result = JSON.parse(result);
    for (let index = 0; index < result.docs.length; index++) {
      const element = result.docs[index];
      element.group_coffee_run = await GroupCoffeeRunDB.findAll({
        where: {
          order_id: element.id,
        },
        include: [
          {
            model: UserDB,
            attributes: ["id", "name", "profile_picture", "email"],
            required: true,
            where: {
              is_deleted: 0,
              is_active: 1,
            },
            as: "user_data",
          },
          {
            model: UserDB,
            attributes: ["id", "name", "profile_picture", "email"],
            required: true,
            where: {
              is_deleted: 0,
              is_active: 1,
            },
            as: "creator_data",
          },
        ],
        attributes: [
          'id', 'request_unique_id', 'is_contributor_person', 'is_order_place', 'request_endtime'
        ]
      })
      element.cafe.is_favorite = element.cafe.user_favorite_cafes.length > 0 ? 1 : 0;
      element.cafe.distance = 0;
      element.cafe.time_sheet_data = [];
      if (typeof element.order_item_array == 'string') element.order_item_array = JSON.parse(element.order_item_array)
      delete element.cafe.user_favorite_cafes
    }
    return result;
  } catch (error) {
    throw new Error(error);
  }
}