import { orderLookUp, cancelOrder, returnOrder } from '../../endpoints/oms'
import {
  orderLookUpParams,
  toOrderListParams,
  //
  detailedOrdersParams,
  toCancelOrderParams,
  returnOrderParams,
  getOrderLookupPostData,
} from '../../endpoints/oms'
import {
  orderList,
  orderListData,
  cancelOrderData,
  tranformedOrderHistory,
} from '../../endpoints/oms'
import { transformOrders } from '../../endpoints/oms/stream/transformHistory'
import { transformDetailOrders } from '../../endpoints/oms/stream/transformOrder'
import { transformOrderLookUp } from '../../endpoints/oms/stream/transformOrderLookUp'
import { ResolverExport } from '../../typings'

export default {
  Query: {
    orderList: async(obj, args, context, info) => {
      const { customerid } = args
      const params = toOrderListParams(args)

      const response = await context.oms.getOrders
        .body(params)
        .doRequest()

      const transformedOrder = transformOrders(response.data || response.body)
      console.log('order params', JSON.stringify(transformedOrder))

      const getDetailedOrders = () =>
        transformedOrder.orders.map(async order => {
          const detailedOrdersParams = {
            customerid,
            channel: 'user',
            orderdetails: {
              id: order.orderid,
            },
          }

          // const detailOrderResponse = await context.oms.detailedOrders(
          //   detailedOrdersParams,
          //   undefined
          // )
          const detailOrderResponse = await context.oms.detailedOrders
            .body(detailedOrdersParams)
            .doRequest()

          const transformedDetailOrder = transformDetailOrders(
            detailOrderResponse
          )
          return transformedDetailOrder
        })

      const packages = await getDetailedOrders()

      const detailedOrderList = {
        orders: packages,
        state: {
          statuscode: transformedOrder.state.statuscode,
          status: transformedOrder.state.status,
          offset: transformedOrder.state.offset,
          /* There is no state.count in detailed order call... we are computing this based on the amount of packages */
          count: transformedOrder.state.count || packages.length,
        },
      }
      return detailedOrderList
    },
    // @todo !!!
    orderDetail: async(obj, args, context, info) => {
      const orderId = 151843825280557491
      const params = {
        orderdetails: {
          id: orderId,
        },
      }

      // @deepak @raja @todo
      // const updatedParams = { ...getOrdersParams, ...params, customerid }
      // const response = await getOrdersRequest(updatedParams, undefined)
      // const hasNoOrders = isErrorLikeResponse(response)
      // const isErrorOrHasNoOrders = hasNoOrders || (isArray(response.orders) && response.orders.length === 0)
      // const orderResponse = isErrorOrHasNoOrders ? transformOrders(orderList) : transformOrders(response)
      // return orderResponse
    },
    orderLookupList: async(obj, args, context, info) => {
      const { lastname, orderNumber, zipcode } = args
      const params = { lastname, orderNumber, zipcode }
      const postParmams = getOrderLookupPostData(params)

      // const response = await context.oms.orderLookUp(postParmams, undefined)
      const response = await context.oms.orderLookUp
        .body(postParmams)
        .doRequest()

      const data = transformOrderLookUp(response.data || response.body)
      console.log(JSON.stringify(data))
      return data

      // const { lastname, orderNumber, zipcode } = args
      // const params = { lastname, orderNumber, zipcode }
      // const postParmams = getOrderLookupPostData(params)
      // const response = await context.oms.orderLookUp(postParmams, undefined)
      // // @todo @deepak @raja, missing...
      // return transformOrders(orderDetailsData)
    },
  },
  Mutation: {
    cancelOrder: async(obj, args, context, info) => {
      const { orderId, items } = args
      const params = toCancelOrderParams(orderId, items)

      const response = await context.oms.cancelOrder.body(params).doRequest()

      return response.data || response.body
    },
    returnOrder: async(obj, args, context, info) => {
      const { orderId, skuId, itemId, qty } = args
      const reasonMessage =
        args.reasonMessage || 'I have received a different product.'

      // @todo toParams
      const messageCampaignId = '370'
      const returnOrderPostParams = {
        orderinfo: {
          id: orderId,
          items: [
            {
              // '1',
              itemid: itemId,
              // '1',
              // @too @invalid @name
              quantity: qty,
              // 'SSHT2',
              skuId,
            },
          ],
        },
        customparams: {
          associateId: '0',
          messageCampaignId,
          customerreason: reasonMessage,
          customerreasoncode: ['001'],
        },
      }

      const response = await context.oms.returnOrder
        .body(returnOrderPostParams)
        .doRequest()

      return response.data || response.body
    },
    orderAgain: async(obj, args, context, info) => {
      try {
        const { lastname, orderid, zipcode } = args
        const params = { lastname, orderNumber: orderid, zipcode }
        const postParams = getOrderLookupPostData(params)
        const response = await context.oms.orderLookUp(postParams, undefined)
        const orderLookupData = transformOrderLookUp(response)
        const transformedDetailOrder = orderLookupData.orders[0]
        // @todo @fixme use forEach and check for variable scopes
        for (
          let index = 0;
          index < transformedDetailOrder.packages[0].products.length;
          index++
        ) {
          const itemInput = transformedDetailOrder.packages[0].products[index]
          const input = {
            itemid: itemInput.identifier,
            skuId: itemInput.skuid,
            itemType: 'sku',
            title: itemInput.name,
            quantity: itemInput.quantity,
          }
          const dynamicParams = {
            item: input,
          }

          const test = await context.cartAndCheckout.getAddToBag
            .body(dynamicParams)
            .doRequest()

          console.log(JSON.stringify(test))
        }
        console.log('Reorder_success')
        // @todo @fixme add more appropriate status messages
        return {
          state: {
            status: 'Success',
          },
        }
      } catch {
        console.log('Reorder_failure')
        return {
          state: {
            status: 'Failure-Something went wrong',
          },
        }
      }
    },
  },
} as ResolverExport