import inHouseItem from "../../models/in_house_items.model.js";
import inHouseItemType from "../../models/in_house_item_type.model.js";
import inHouseMenuDetails from "../../models/in_house_menu_details.model.js";
import inHouseOrder from "../../models/in_house_order.model.js";
import inHouseOrderItems from "../../models/in_house_order_items.model.js";
import CoffeeRunInHouseOrder from "../../models/coffee_run_inhouse_order.model.js";
import GroupCoffeeRunDB from "../../models/group_coffee_run.model.js";
import { Op } from "sequelize";
import moment from 'moment';

export async function GetInHouseMenu(page) {
  try {
    if (['', null, undefined, 0].includes(page)) {
      page = 1
    }
    page = parseInt(page)
    let menu = await inHouseItem.paginate({
      page: page,
      paginate: 10, // limit should go here
      attributes: ['id', 'item_name', 'item_image'],
      include: [
        {
          model: inHouseItemType,
          attributes: ['id', 'type_name'],
          where: {
            is_active: 1
          },
          required: false
        }
      ]
    });
    menu = JSON.stringify(menu)
    menu = JSON.parse(menu)
    for (let index = 0; index < menu.docs.length; index++) {
      const element = menu.docs[index];
      element.size_data = await inHouseMenuDetails.findAll({
        where: {
          type: 1,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
      element.milk_data = await inHouseMenuDetails.findAll({
        where: {
          type: 2,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
      element.sugar_data = await inHouseMenuDetails.findAll({
        where: {
          type: 3,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
    }
    return menu;
  } catch (error) {
    throw new Error(error)
  }
}

export async function GetInHouseItemById(item_id) {
  try {
    let menu = await inHouseItem.findAll(
      {
        where: {
          id: parseInt(item_id),
          is_active: 1
        },
        attributes: ['id', 'item_name', 'item_image'],
        include: [
          {
            model: inHouseItemType,
            attributes: ['id', 'type_name'],
            where: {
              is_active: 1
            },
            required: false
          }
        ]
      }
    );
    menu = JSON.stringify(menu)
    menu = JSON.parse(menu)
    for (let index = 0; index < menu.length; index++) {
      const element = menu[index];
      element.size_data = await inHouseMenuDetails.findAll({
        where: {
          type: 1,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
      element.milk_data = await inHouseMenuDetails.findAll({
        where: {
          type: 2,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
      element.sugar_data = await inHouseMenuDetails.findAll({
        where: {
          type: 3,
          is_active: 1,
          in_house_item_id: element.id
        },
        attributes: ['id', 'type_value']
      })
    }
    return menu;
  } catch (error) {
    throw new Error(error)
  }
}

export async function saveOrder(itemData) {
  try {
    let customisedOrderObj = {
      user_id: itemData.user_id,
      customized_order: itemData.customized_order,
      is_active: 1,
      created_at: moment().unix()
    }
    let result = await inHouseOrder.create(customisedOrderObj);
    let storeOrderObj = [];
    itemData.items.forEach(element => {
      storeOrderObj.push({
        in_house_order_id: result.id,
        in_house_item_id: element.in_house_item_id,
        item_type_id: element.item_type_id,
        size_id: element.size_id,
        milk_id: element.milk_id,
        sugar_id: element.sugar_id,
        qty: element.qty,
        created_at: moment().unix()
      })
    });
    let a = await inHouseOrderItems.bulkCreate(storeOrderObj);
    return a;
  } catch (error) {
    throw new Error(error)
  }
}

export async function addOrderItem(itemData) {
  try {
    let customisedOrderObj = {
      customized_order: itemData.customized_order
    }
    await inHouseOrder.update(customisedOrderObj, {
      where: { id: itemData.order_id }
    });

    let storeOrderObj = [];
    itemData.items.forEach(element => {
      storeOrderObj.push({
        in_house_order_id: itemData.order_id,
        in_house_item_id: element.in_house_item_id,
        item_type_id: element.item_type_id,
        size_id: element.size_id,
        milk_id: element.milk_id,
        sugar_id: element.sugar_id,
        qty: element.qty,
        created_at: moment().unix()
      })
    });
    let a = await inHouseOrderItems.bulkCreate(storeOrderObj);
    return a;
  } catch (error) {
    throw new Error(error)
  }
}

export async function getOrder(data) {
  try {
    const result = await inHouseOrder.findOne({
      where: {
        user_id: data.user_id,
        is_active: 1
      },
      attributes: ['id', 'user_id', 'customized_order'],
      include: [
        {
          model: inHouseOrderItems,
          required: false,
        },
      ],
      order: [
        ['id', 'DESC']
      ]
    });

    if (result == null) {
      return null;
    }

    const inHouseItems = result.dataValues.in_house_order_items;
    const inHouseOrders = [];
    for (let i = 0; i < inHouseItems.length; i++) {
      const itemsData = inHouseItems[i];
      const items = { id: itemsData.id };
      items.item_details = await inHouseItem.findOne({
        where: {
          is_active: 1,
          id: itemsData.in_house_item_id
        },
        attributes: ['id', 'item_name', 'item_image']
      });
      items.type = await inHouseItemType.findOne({
        where: {
          is_active: 1,
          id: itemsData.item_type_id
        },
        attributes: ['id', 'type_name']
      });
      items.size_data = await inHouseMenuDetails.findOne({
        where: {
          type: 1,
          is_active: 1,
          id: itemsData.size_id
        },
        attributes: ['id', 'type_value']
      })
      items.milk_data = await inHouseMenuDetails.findOne({
        where: {
          type: 2,
          is_active: 1,
          id: itemsData.milk_id
        },
        attributes: ['id', 'type_value']
      })
      items.sugar_data = await inHouseMenuDetails.findOne({
        where: {
          type: 3,
          is_active: 1,
          id: itemsData.sugar_id
        },
        attributes: ['id', 'type_value']
      });
      inHouseOrders.push(items);
    }

    delete result.dataValues.in_house_order_items;
    result.dataValues.data = inHouseOrders;

    return result;
  } catch (error) {
    throw new Error(error)
  }
}

// edit In house Order
export async function editOrder(itemData) {
  try {
    let customisedOrderObj = {
      customized_order: itemData.customized_order,
      is_active: 1,
      created_at: moment().unix()
    }
    let result = await inHouseOrder.update(customisedOrderObj, {
      where: { id: itemData.order_id, user_id: itemData.user_id }
    });

    itemData.items.forEach(async element => {
      let updateObj = {
        in_house_item_id: element.in_house_item_id,
        item_type_id: element.item_type_id,
        size_id: element.size_id,
        milk_id: element.milk_id,
        sugar_id: element.sugar_id,
        qty: element.qty,
        updated_at: moment().unix()
      }
      await inHouseOrderItems.update(updateObj, {
        where: {
          id: element.id
        }
      });
    });
    return result;
  } catch (error) {
    throw new Error(error)
  }
}

//delete item from in house order
export async function deleteInhouseItem(item_id) {
  try {
    let result = await inHouseOrderItems.destroy({
      where: { id: item_id }
    });
    return result;
  } catch (error) {
    throw new Error(error)
  }
}

export async function createInhouseOrder(data) {
  try {
    let result = await CoffeeRunInHouseOrder.create({
      user_id: data.user_id,
      group_id: data.group_id,
      in_house_order_items: data.in_house_order_items,
      customized_order: data.customized_order,
      coffee_run_id: data.coffee_run_id,
      updated_at: moment().unix(),
      created_at: moment().unix(),
    });

    await GroupCoffeeRunDB.update(
      { in_house_order_id: result.id, updated_at: moment().unix() },
      {
        where: {
          request_unique_id: data.coffee_run_id,
          user_id: data.user_id
        },
      }
    );
    return result;
  } catch (error) {
    throw new Error(error)
  }
}