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 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) {
        let saveData = 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,
        });
      }
    });
    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 {
          docs: [],
          page: 1,
        };
      }
    }

    if ([null, undefined, "", 0].includes(data.page)) data.page = 1;
    data.page = parseInt(data.page);
    config.config.limit = parseInt(config.config.limit);
    let result = await GroupCoffeeRunDB.paginate({
      page: data.page,
      paginate: config.config.limit,
      where: {
        group_id: parseInt(data.group_id),
        cafe_id: parseInt(data.cafe_id),
        order_id: null,
      },
      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,
          },
          required: true,
          attributes: ["id", "group_name", "group_profile", "created_at"],
        },

        {
          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",
      ],
    });
    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,
        group_id: data.group_id,
        request_endtime: {
          [Op.gte]: data.request_endtime,
        },
      },
    });
  } catch (error) {
    return false;
  }
}

// place order
export async function placeOrder(data) {
  try {
    let todayDayId = new Date().getDay();
    let currentTime = moment().format("HH:mm");
    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,
              include: [
                {
                  model: SizeDB,
                  attributes: ["size_name"],
                },
              ],
              attributes: ["item_size_price"],
            },
            {
              model: AddonSizeCafeItemDB,
              include: [
                {
                  model: AddonSizeDB,
                  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: 550,
        message: messages.cafe_is_not_available,
      };
    } else if (result && result.time_sheet_data.length == 0) {
      final_result = {
        status: 550,
        message: messages.cafe_has_been_closed,
      };
    } else if (result && result.cafe_menu_items.length == 0) {
      final_result = {
        status: 550,
        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
          )
        ) {
          let tmp_qty = data.order_item_array.find((children) => {
            return children.item_id == element.id ? children.item_quantity : 1;
          });
          tmp_qty = tmp_qty ? tmp_qty.item_quantity : 1;
          items_prices = items_prices + Number(element.item_price) * tmp_qty;
          for (let i = 0; i < data.order_item_array.length; i++) {
            const element1 = data.order_item_array[i];
            if (
              element1.is_suggested_item == 0 &&
              element1.addon_sizes.some((children) => {
                return element.addon_size_cafe_items.some(
                  (grandChildren) =>
                    grandChildren.addon_size_id == children.addon_size_id &&
                    element1.item_id == element.id
                );
              })
            ) {
              var tmp = element.addon_size_cafe_items.find(function (
                childrenElement
              ) {
                var childtmp = element1.addon_sizes.find((grandChildren) => {
                  return childrenElement.addon_size_id ==
                    grandChildren.addon_size_id
                    ? childrenElement.addon_size.addon_size_price
                    : 0;
                });
                return childtmp;
              });
              items_prices += tmp ? tmp.addon_size.addon_size_price : 0;
            }
          }
        } 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 = element.cafe_menu_item_sizes.find(function (
                childrenElement
              ) {
                return childrenElement.size.size_name == element1.item_size
                  ? childrenElement.item_size_price
                  : 0;
              });
              items_prices += tmp
                ? tmp.item_size_price * element1.item_quantity
                : 0;
            }
            if (
              element1.is_suggested_item == 0 &&
              element1.addon_sizes.some((children) => {
                return element.addon_size_cafe_items.some(
                  (grandChildren) =>
                    grandChildren.addon_size_id == children.addon_size_id &&
                    element1.item_id == element.id
                );
              })
            ) {
              var tmp = element.addon_size_cafe_items.find(function (
                childrenElement
              ) {
                var childtmp = element1.addon_sizes.find((grandChildren) => {
                  return childrenElement.addon_size_id ==
                    grandChildren.addon_size_id
                    ? childrenElement.addon_size.addon_size_price
                    : 0;
                });
                return childtmp;
              });
              items_prices += tmp ? tmp.addon_size.addon_size_price : 0;
            }
          }
        }
      }
      if (message) {
        final_result = {
          status: 550,
          message: message + " items not available",
          result: result,
        };
      } else if (
        message == "" &&
        Number(items_prices) != Number(data.items_amount)
      ) {
        final_result = {
          status: 550,
          message: messages.item_price_updated_error,
          result: result,
        };
      } else {
        final_result = {
          status: 200,
          message: messages.data_found,
          result: result,
        };
      }
      console.log(items_prices);
      return final_result;
    }
    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: 550,
          message: messages.redeem_code_no_longer_available,
          result: result,
        };
      }
    }
    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,
      group_coffee_run_id: data.group_coffee_run_id,
      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: Number(data.total_amount),
      tax: Number(data.tax),
      discount_amount: Number(data.discount_amount),
      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,
          },
        }
      );
    }
    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', '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;
      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) {
  try {
    let result = await OrderDB.findOne({
      where: {
        user_id: user_id,
        id: order_id,
        cafe_id: order_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,
        };
      }
      return {
        status: 409,
        message:
          messages.order_has_been_already_collected +
          " at " +
          check.order_collected_at,
      };
    }
    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,
    };
  } 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 },
    });
    return loyaltyDetails;
  } catch (error) {
    throw new Error(error);
  }
}

// Get Loyalty list
export async function universalCardList(user_id) {
  try {
    let final_result = {}
    let usedloyaltyCupIds = []
    let result = await OrderDB.findAll({
      attributes: ['loyalty_stamp_id'],
      where: {
        user_id: parseInt(user_id),
        loyalty_stamp_id: {
          [Op.ne]: null
        }
      },
    })
    result.forEach(async (element) => {
      usedloyaltyCupIds.push(element.loyalty_stamp_id)
    })
    let checkTotalOrder = await OrderDB.count({
      where: {
        user_id: user_id,
      }
    })

    let universal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: null,
        is_universal: 1
      },
      attributes: ['stamp_no'],
    })
    final_result.universal = universal;
    final_result.checkTotalOrder = checkTotalOrder;
    return final_result;
  } catch (error) {
    console.log("error: ", error);
    throw new Error(error);
  }
}

// get redeem code

export async function getRedeemCode(data) {
  try {
    let final_result = {}
    let usedloyaltyCupIds = []
    let result = await OrderDB.findAll({
      where: {
        user_id: parseInt(data.userId),
        loyalty_stamp_id: {
          [Op.ne]: null
        }
      },
      attributes: ['loyalty_stamp_id']
    })
    result.forEach(async (element) => {
      usedloyaltyCupIds.push(element.loyalty_stamp_id)
    })
    let checkTotalOrder = await OrderDB.count({
      where: {
        user_id: data.userId,
      }
    })
    let nonUniversal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: parseInt(data.cafe_id),
        stamp_no: {
          [Op.lte]: checkTotalOrder
        },
        is_universal: 0
      }
    })
    let universal = await LoyaltyStampDB.findOne({
      where: {
        cafe_id: null,
        stamp_no: {
          [Op.lte]: checkTotalOrder
        },
        is_universal: 1
      }
    })
    final_result.universal = universal
    final_result.nonUniversal = nonUniversal
    return final_result
  } catch (error) {
    throw new Error(error)
  }
}