import * as eventHelper from "../../lib/eventHelper";
import { Action, Message } from "../../types/primitives";
import Order from "@webresto/core/models/Order"

type CheckResponse = {
  order?: Order
  message: Message
  action?: Action
}

import graphqlHelper from "../../lib/graphqlHelper";
import Address from "@webresto/core/interfaces/Address";
import Customer from "@webresto/core/interfaces/Customer";
import { SpendBonus } from "@webresto/core/interfaces/SpendBonus";
import { JWTAuth } from "../../lib/jwt";
import checkDeviceId from "../../lib/helper/checkDeviceId";


interface InputOrderCheckout {
  orderId: string
  paymentMethodId: string
  selfService?: boolean
  pickupPointId?: string
  address?: Address
  locationId: string
  customer: Customer
  date?: string
  personsCount?: number
  comment: string
  spendBonus: SpendBonus
  customData: { [key: string]: string | number }
}

graphqlHelper.addType(`#graphql    
  input InputOrderCheckout {
    orderId: String! 
    paymentMethodId: String!
    customer: Customer! 
    spendBonus: InputSpendBonus 
    selfService: Boolean
    pickupPointId: String 
    locationId: String
    address: Address
    date: String
    comment: String 
    personsCount: Int
    customData: Json
  }
`);

graphqlHelper.addType(`#graphql    
  input InputSpendBonus {
    bonusProgramId: String!
    amount: Int!
    adapter: String!
    bonusProgramName: String!
  } 
`);



export default {
  Mutation: {
    checkOrder: {
      def: `#graphql
        checkOrder(orderCheckout: InputOrderCheckout): CheckResponse`,
      fn: async function (parent, args: { orderCheckout: InputOrderCheckout }, context): Promise<CheckResponse> {
        let data = args.orderCheckout;

        checkDeviceId(context);


        // if (data.date) {
        //     let date = moment(data.date)
        //     if(!date.isValid()){
        //         return eventHelper.sendMessage(args.orderId, "Please order.date format is ISO (YYYY-MM-DD HH:mm:ss)");
        //     } else {
        //     data.date = date.format('YYYY-MM-DD HH:mm:ss');
        //     }
        // }

        let isSelfService: boolean;


        let message;
        try {
          var order = await Order.findOne(data.orderId);
          const shouldSendSucessMessage = order.state !== "CHECKOUT"
          if (!order) {
            message = eventHelper.sendMessage({
              deviceId: context.connectionParams.deviceId,
              type: "error",
              title: context.i18n.__("Order not found"),
              message: context.i18n.__("Order with id %s not found", data.orderId),
            });
          }

          let address: Address = null;

          //@ts-ignore
          if (data.selfService) {
            isSelfService = true;
            order.pickupPoint = data.pickupPointId;
          } else {
            order.pickupPoint = null;
            if (!data.address && !data.locationId) throw `Address is required for non self service orders`

            address = {
              city: address.city || (await Settings.use("city") as string),
              street: address.street,
              ...address.streetId && { streetId: address.streetId },
              home: address.home,
              ...address.housing && { housing: address.housing },
              ...address.apartment && { apartment: address.apartment },
              ...address.index && { index: address.index },
              ...address.entrance && { entrance: address.entrance },
              ...address.floor && { floor: address.floor },
              ...address.apartment && { apartment: address.apartment },
              ...address.comment && { comment: address.comment },
            }
            
          }

          if (order.state === "ORDER") {
            message = eventHelper.sendMessage({
              deviceId: context.connectionParams.deviceId,
              type: "error",
              title: context.i18n.__("Error"),
              message: context.i18n.__("Cart was ordered"),
            });
          }

          if (data.paymentMethodId) {
            if (!PaymentMethod.checkAvailable(data.paymentMethodId)) {
              message = eventHelper.sendMessage({
                deviceId: context.connectionParams.deviceId,
                type: "error",
                title: context.i18n.__("Error"),
                message: context.i18n.__("Checking the payment system ended in failure"),
              });
            }
          }

          if(!isSelfService){
            if (data.locationId) {
              address = await UserLocation.findOne({ id: data.locationId }) as Address;
              if (!address) throw `locationId not found`
            } else {
              if (data.address) {
                address = data.address;
              }
            }
          }

          order.personsCount = data.personsCount ? data.personsCount + "" : "";
          if (data.comment) order.comment = data.comment;

          order.date = data.date;

          // callback: boolean -call back to clarify details
          if (data.customData && data.customData.callback) {
            if (!order.customData) order.customData = {};
            order.customData.callback = data.customData.callback;
          }

          await Order.update({ id: order.id }, order).fetch();

          let userId = null;
          if (context && context.connectionParams.authorization) {
            userId = (await JWTAuth.verify(context.connectionParams.authorization)).userId;
          }

          await Order.check(
            { id: order.id },
            data.customer,
            isSelfService,
            isSelfService ? undefined : data.address,
            data.paymentMethodId,
            userId,
            data.spendBonus !== undefined && userId !== null ? data.spendBonus : null
          );

          order = await Order.findOne(data.orderId);

          if (order.state === "CHECKOUT" && shouldSendSucessMessage) {
            message = {
              deviceId: context.connectionParams.deviceId,
              type: "info",
              title: context.i18n.__("Attention"),
              message: order.message
                ? context.i18n.__(order.message)
                : context.i18n.__("Ready for order"),
            };

          } else {
            if (order.message) {
              message = {
                deviceId: context.connectionParams.deviceId,
                type: "error",
                title: "Attention",
                message: order.message
                  ? context.i18n.__(order.message)
                  : context.i18n.__("It was not possible to check the order"),
              }
            }
          }

          if (message) {
            eventHelper.sendMessage(message);
          }

          return {
            order: order,
            ...message && { message: message }
          };
        } catch (e) {
          let message = {
            type: "error",
            title: context.i18n.__("Error"),
            message: "",
          } as Message;
          if (e.code === 1) {
            message.message = context.i18n.__("Enter the name of the customer");
          } else if (e.code === 2) {
            message.message = context.i18n.__("Enter the customer's phone");
          } else if (e.code === 3) {
            message.message = context.i18n.__("The wrong format of the name of the customer");
          } else if (e.code === 4) {
            message.message = context.i18n.__("The wrong format of the customer number");
          } else if (e.code === 5) {
            message.message = context.i18n.__("No point of Street");
          } else if (e.code === 6) {
            message.message = context.i18n.__("Not indicated the house number");
          } else if (e.code === 7) {
            message.message = context.i18n.__("The city is not indicated");
          } else if (e.code === 8) {
            message.message = context.i18n.__("The payment system is not available");
          } else if (e.code === 11) {
            message.message = context.i18n.__(order.delivery.message);
          } else if (e.code === 10) {
            message.message = context.i18n.__("The date of execution of the order is not true");
          } else if (e.code === 15) {
            message.message = context.i18n.__("Ordering for a date in the past is not possible");
          } else {
            message.message = e.error
              ? e.error
              : context.i18n.__(`Problem when checking the order: %s`, e);
          }

          order = await Order.findOne(data.orderId);
          sails.log.error(e)
          eventHelper.sendMessage(message);
          return {
            order: order,
            message: message
          };
        }
      },
    },
    sendOrder: {
      def: "sendOrder(orderId: String!): CheckResponse",
      fn: async function (parent, args, context) {
        checkDeviceId(context);
        let data = args;

        var order = await Order.findOne({ id: data.orderId });
        if (!order) {
          const errorMessage = context.i18n.__(`Order with id %s not found`, data.orderId);
          eventHelper.sendMessage({
            deviceId: context.connectionParams.deviceId,
            type: "error",
            title: context.i18n.__("Order not found"),
            message: errorMessage,
          });
          sails.log.error(`${errorMessage}`);
          throw new Error(errorMessage);
        }
        if (!order.isPaymentPromise) {
          try {
            let paymentResponse = await Order.payment({ id: order.id });
            const action = {
              deviceId: context.connectionParams.deviceId,
              type: "Redirect",
              data: {
                link: paymentResponse.redirectLink,
              },
            };
            eventHelper.sendAction(action);
            order = await Order.populate({ id: order.id });
            return { order: order, action: action };
          }
          catch (e) {
            eventHelper.sendMessage({
              deviceId: context.connectionParams.deviceId,
              type: "error",
              title: context.i18n.__("Error"),
              message: context.i18n.__("The payment of the payment has ended unsuccessfully"),
            });
            const error = `External payment: ${e}`
            sails.log.error(error);
            throw new Error(error);
          }
        }

        try {
          await Order.order({ id: order.id });
          order = await Order.findOne({ id: data.orderId });
          const message = {
            type: "info",
            title: context.i18n.__("Successfully"),
            message: context.i18n.__("Your order is accepted for processing"),
          };
          // eventHelper.sendMessage(message);
          return { order: order, message: message };
        }
        catch (e) {
          const error = `Order finalize error:, ${e}`
          sails.log.error(error);
          throw new Error(error);
        }
      },
    },
  },
}