import moment from 'moment'
import { logger } from '../../utils/logger'
import Stripe from '../../utils/stripe'
import * as Twilio from '../../utils/twilio'
import GeneralUtils from '../../utils/general'
import OrderHelper from './helpers'
import { prismaClient as prisma } from '../../prismaClient'

const createOrder = async ({ data }) => {
  const createdOrder = await OrderHelper.createOrder({ data })
  await OrderHelper.sendOrderToCustomer({ order: createdOrder })
  return Promise.resolve(createdOrder)
}

const forwardOrderToSomeone = async ({ orderId, email, phoneNumber }) => {
  try {
    const order = await prisma.order.findOne({
      where: { id: orderId },
      select: {
        id: true,
        number: true,
        totalTax: true,
        totalPrice: true,
        subtotalPrice: true,
        totalDiscounts: true,
        serviceProject: {
          select: {
            service: {
              select: {
                type: true,
              },
            },
          },
        },
        lineItems: {
          select: {
            id: true,
            quantity: true,
            option: {
              select: {
                title: true,
                description: true,
                price: true,
                image: {
                  select: {
                    url: true,
                  },
                },
              },
            },
          },
        },
        booking: {
          select: {
            address: {
              select: {
                address1: true,
                apartmentNumber: true,
                city: true,
                state: true,
                country: true,
                zip: true,
              },
            },
            date: true,
          },
        },
        customer: {
          select: {
            firstName: true,
            lastName: true,
            phone: {
              select: {
                number: true,
              },
            },
          },
        },
      },
    })

    const message = `Here's some information for your next customer:\n\n\n${OrderHelper.getOrderSMSInformation(
      order
    )}`

    // \n\n\nIf you haven't downloaded Condoservice-Tracker, go download it now and use it to let your client know when you're arriving at the destination. You will only need the order number at which is at the beginning of the message. https://itunes.apple.com/us/app/condoserviceprovider/id1427064989
    if (phoneNumber) {
      await Twilio.sendSMS({
        to: phoneNumber,
        body: message,
      })
    }
    if (email) {
      await OrderHelper.sendOrderConfirmationTemplate({
        orderId: order.id,
        to: [{ email }],
        subject: `FW: Order #${order.number} from Walter`,
      })
    }

    return Promise.resolve(true)
  } catch (e) {
    return Promise.reject(e)
  }
}

const charge = async (orderId) => {
  // TODO: put all that in queue to make sure it's done one time
  const order = await prisma.order.findOne({
    where: { id: orderId },
    select: {
      id: true,
      isCharged: true,
      subtotalPrice: true,
      totalTax: true,
      totalPrice: true,
      number: true,
      customer: {
        select: {
          firstName: true,
          lastName: true,
          email: true,
          stripeCustomerId: true,
        },
      },
      serviceProject: {
        select: {
          id: true,
          service: {
            select: {
              chargeTaxes: true,
              businessName: true,
              stripeAccountId: true,
              walterPourcentage: true,
            },
          },
        },
      },
    },
  })

  if (!order.isCharged) {
    // Fees on the FULL amount with taxes
    const applicationFeeAmount =
      (order.serviceProject.service.walterPourcentage || 0.1) *
      (order.subtotalPrice + order.subtotalPrice * 0.14975)

    // Some business don't charge taxes
    let amount = order.subtotalPrice
    if (order.serviceProject.service.chargeTaxes) {
      amount += order.subtotalPrice * 0.14975
    }

    await Stripe.chargeCustomer({
      customerId: order.customer.stripeCustomerId,
      customerEmail: order.customer.email,
      amount: amount * 100,
      applicationFeeAmount: applicationFeeAmount * 100,
      destinationAccountId: order.serviceProject.service.stripeAccountId,
      description: `Order #${order.number} - ${
        order.serviceProject.service.businessName
      } - ${GeneralUtils.getUserName(order.customer)}`,
    })

    // We need to know that the order has been charged to not charge it again!
    await prisma.order
      .update({
        where: { id: order.id },
        data: { isCharged: true, paidAt: moment().format() },
      })
      // Needed because we don't put in queue yet. In case of a crash, just log
      .catch(logger.error)
  }

  return Promise.resolve()
}

export default {
  createOrder,
  forwardOrderToSomeone,
  charge,
}