import * as OrderService from "../../services/order/order.services.js";
import { messages } from "../../config/response.messages.js";
import * as Helper from "../../helper/index.js";
import moment from "moment";

//save group coffee run data
export async function saveGroupCoffeeRun(req, res) {
  try {
    req.body.loggedInUser = req.userData;
    let cafeRunExist = await OrderService.checkSameGroupCafeRunEndTime(req.body);
    if (cafeRunExist == null) {
      let coffeeRun = await OrderService.saveGroupCoffeeRun(req.body, req.userData);
      return res.status(201).send({
        status: 201,
        message: messages.group_coffee_run_saved_success,
        coffeeRun: coffeeRun.dataValues
      });
    } else if (cafeRunExist.dataValues.order_id == null && cafeRunExist.dataValues.type == 1) {
      return res.status(400).send({
        status: 400,
        message: 'Order not placed yet!',
        coffeeRun: cafeRunExist.dataValues,
      });
    } else {
      return res.status(203).send({
        status: 203,
        message: messages.group_cafe_run_already_added,
        coffeeRun: null
      });
    }
  } catch (error) {
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

//get group coffee run data
export async function getGroupCoffeeRun(req, res) {
  try {
    let result = await OrderService.getGroupCoffeeRun(req.query);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// place order
export async function placeOrder(req, res) {
  try {
    let result = await OrderService.placeOrder(req.body);
    return res.status(result.status).send({
      status: result.status,
      message: result.message,
      result: result.result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// save order
export async function saveOrder(req, res) {
  try {
    req.body.loggedInUser = req.userData.id;
    let result = await OrderService.saveOrder(req.body);
    return res.status(201).send({
      status: 201,
      message: messages.order_save_success,
      result: result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// get order list
export async function getOrder(req, res) {
  try {
    let result = await OrderService.getOrder(req.userData.id, req.query);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// get Individual order list
export async function getIndividualOrder(req, res) {
  try {
    let result = await OrderService.getIndividualOrder(req.user_id, req.query.order_id, req.query.cafe_id)
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result
    })
  } catch (error) {
    Helper.writeErrorLog(req, error)
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error
    })
  }
}

// change order status
export async function changeOrderStatus(req, res) {
  try {
    let result = await OrderService.changeOrderStatus(req.params.id, req.body);
    if (req.body.flag == 2) {
      let totalUniversalOrders = await OrderService.getUniversalOrders(req.user_id);
      let totalUniversalStamps = await OrderService.getUniversalStamp();
      if (totalUniversalOrders) {
        if (totalUniversalOrders >= totalUniversalStamps.stamp_no) {
          await OrderService.updateUniversalCoupon(req.user_id, req.params.id, totalUniversalStamps.stamp_no, totalUniversalStamps.stamp_expires_in)
        }
      }

      let totalOrder = await OrderService.getAllCafeOrders(req.user_id, result.data.cafe_id);
      let totalStamp = await OrderService.getStampsByCafe(result.data.cafe_id);
      if (totalStamp) {
        if (totalOrder >= totalStamp.stamp_no) {
          await OrderService.updateCouponByCafeId(req.user_id, req.params.id, result.data.cafe_id, totalStamp.stamp_no, totalStamp.stamp_expires_in)
        }
      }
      return res.status(result.status).send({
        status: result.status,
        message: result.message,
      });
    } else {
      return res.status(result.status).send({
        status: result.status,
        message: result.message,
      });
    }
  } catch (error) {
    console.log("error", error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// Loyalty List
export async function loyaltyList(req, res) {
  try {
    let result = await OrderService.loyaltyList(req.user_id, req.query);
    return res.status(200).send({
      status: 200,
      message: messages.loyalty_detail,
      data: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// Universal Card List API
export async function universalCardList(req, res) {
  try {
    let result = await OrderService.universalCardList(req.user_id);
    let getUniversalStamp = await OrderService.getUniversalStamp()
    return res.status(200).send({
      status: 200,
      message: messages.loyalty_detail,
      data: {
        count: result,
        universal: {
          stamp_no: getUniversalStamp.stamp_no,
          offer_text: getUniversalStamp.offer_text
        }
      },
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// Non Universal Card List API
export async function nonuniversalCardList(req, res) {
  try {
    let result = await OrderService.nonuniversalCardList(
      req.user_id,
      req.body.cafe_id
    );

    let getNonUniversalStamp = await OrderService.getnonUniversalStamp(
      req.body.cafe_id
    );
    return res.status(200).send({
      status: 200,
      message: messages.loyalty_detail,
      data: {
        count: result,
        universal: {
          stamp_no: getNonUniversalStamp.stamp_no,
          offer_text: getNonUniversalStamp.offer_text,
        },
      },
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// check redeem code
export async function checkRedeemCode(req, res) {
  try {
    let responseArray = []
    req.query.userId = req.userData.id
    let nonUniversalStampsDetails = await OrderService.getStampsByCafe(req.query.cafe_id);
    let totalOrder = await OrderService.getAllCafeOrders(req.user_id, req.query.cafe_id);
    let universalStampsDetails = await OrderService.getUniversalStamp();
    let totalUniversalOrders = await OrderService.getUniversalOrders(req.user_id);
    let lastExpireDate = await OrderService.getLastExpireDateUniversal(req.user_id);
    let cafeExpireDate = await OrderService.getLastExpireCafeDate(req.user_id, req.query.cafe_id)
    let currentDate = moment().format('YYYY-MM-DD')
    universalStampsDetails.dataValues.is_expired = 0;
    nonUniversalStampsDetails.dataValues.is_expired = 0;
    if (lastExpireDate) {
      if (currentDate > moment.unix(lastExpireDate.universal_coupon_expired_time).format("YYYY-MM-DD")) {
        universalStampsDetails.dataValues.is_expired = 1;
      }
    }
    if (cafeExpireDate) {
      if (currentDate > moment.unix(cafeExpireDate.cafe_coupon_expired_time).format("YYYY-MM-DD")) {
        nonUniversalStampsDetails.dataValues.is_expired = 1;
      }
    }
    const totalOrders = totalOrder / nonUniversalStampsDetails.stamp_no;
    if (Math.floor(totalOrders) > 0 && totalOrders == Math.floor(totalOrders)) {
      responseArray.push(nonUniversalStampsDetails);
    }
    const totalUniversalOrder =
      totalUniversalOrders / universalStampsDetails.stamp_no;
    //if ( Math.floor(totalUniversalOrder) > 0 && totalUniversalOrder == Math.floor(totalUniversalOrder)) {
      //responseArray.push(universalStampsDetails);
    //}
    //if (totalUniversalOrders >= universalStampsDetails.stamp_no) {
      //responseArray.push(universalStampsDetails)
    //}
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      data: responseArray
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// apply coupon

export async function applyCoupon(req, res) {
  try {
    req.query.userId = req.userData.id
    let result = await OrderService.applyRedeemCode(req.query.id);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      data: result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

// order list by group

export async function orderListByGroup(req, res) {
  try {
    req.query.userId = req.userData.id
    let result = await OrderService.orderListByGroup(req.query);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      data: result,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

//get group coffee run orders
export async function getGroupCoffeeRunOrders(req, res) {
  try {
    const groupCoffeeRunId = req.group_coffee_run_id;
    const groupId = req.body.group_id;
    let result = await OrderService.getGroupCoffeeRunOrders(groupCoffeeRunId, groupId, req.userData.id);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

//Mark order Collected
export async function markOrderCollected(req, res) {
  try {
    const groupCoffeeRunId = req.body.group_coffee_run_id;
    const type = req.body.type;
    let result = await OrderService.markOrderCollected(groupCoffeeRunId, type);
    return res.status(200).send({
      status: 200,
      message: messages.order_has_been_collected,
      result: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function getPastGroupCoffeeRunOrders(req, res) {
  try {
    const userId = req.user_id;
    let result = await OrderService.getPastCoffeeRunOrders(userId);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function orderDetails(req, res) {
  try {
    let result = await OrderService.getOrderDetails(req.params.id);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function updateOrderDetails(req, res) {
  try {
    let result = await OrderService.updateOrderDetails(req.params.id, req.body.transaction_id);
    return res.status(200).send({
      status: 200,
      message: messages.data_found,
      result: result,
    });
  } catch (error) {
    console.log(error);
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}