import AuthorizePayment from '../../../__fixtures__/payments/authorize'
import AuthorizedPayment from '../../../__fixtures__/payments/authorized'
import CreatePayment from '../../../__fixtures__/payments/create'
import JohnDoe from '../../../__fixtures__/user'
import Merchant from '../../../src/models/merchant'
import MockCatalogAPI from '../../../__mocks__/apis/catalog'
import MockOrderAPI from '../../../__mocks__/apis/order'
import MockPaymentAPI from '../../../__mocks__/apis/payment'
import MockUserAPI from '../../../__mocks__/apis/user'
import Order from '../../../__fixtures__/orders/created'
import Product from '../../../__fixtures__/catalog/product'
import Server from '../../helpers/server'
import UUID from 'uuid/v1'
import { merge } from 'ramda'
import { orderSession } from '../../../src/sessions'

const options = {
  method: 'POST',
  url: '/orders'
}

const userID = UUID()
const sessionID = UUID()

describe('`POST` /orders', () => {
  it('should return a successfull order', async () => {
    try {
      const id = UUID()
      const merchant = await Merchant.create({ id })
      await merchant.sign({ id })
      const headers = {
        'oyst-authorization': `Oyst ${new Buffer(JSON.stringify({
          m: merchant.id,
          t: merchant.$url.token
        })).toString('base64')}`,
        'oyst-session': sessionID,
        'oyst-user': userID
      }
      await orderSession.setData(id, {
        product_reference: 'fake',
        variation_reference: 'fake',
        version: 1
      })
      await new MockCatalogAPI().success().fixture({
        product: Product
      }).findByReferences({
        merchant_id: merchant.id,
        product_reference: 'fake',
        variation_reference: 'fake'
      })
      await new MockUserAPI().success().fixture({ user: JohnDoe }).find(userID)
      await new MockPaymentAPI().success().fixture({ token: UUID() }).create(merchant.id, CreatePayment)
      await new MockPaymentAPI().success().fixture(AuthorizedPayment).authorize(merchant.id, AuthorizePayment)
      await new MockUserAPI().success().fixture({ user: JohnDoe }).find(AuthorizedPayment.user.id)
      await new MockOrderAPI().success().fixture(Order).create(null, 1)

      const res = await Server.inject(merge(options, { headers }))
      expect(res.statusCode).toBe(200)
      expect(res.result).toEqual({
        id: Order.order.id,
        order: Order.order,
        product: Product,
        user: JohnDoe
      })
    } catch (err) {
      console.error({ err })
      expect(err).toBeNull()
    }
  })
  it('Fails because oyst-user header is missing', async () => {
    try {
      const id = UUID()
      const merchant = await Merchant.create({ id })
      await merchant.sign({ id })
      const headers = {
        'oyst-authorization': `Oyst ${new Buffer(JSON.stringify({
          m: merchant.id,
          t: merchant.$url.token
        })).toString('base64')}`,
        'oyst-session': sessionID
      }
      await orderSession.setData(id, {
        product_reference: 'fake',
        variation_reference: 'fake',
        version: 1
      })
      await Server.inject(merge(options, { headers }))
    } catch (err) {
      expect(err.statusCode).toBe(400)
      expect(err).not.toBeNull()
    }
  })
  it('Fails because product was not found', async () => {
    try {
      const id = UUID()
      const merchant = await Merchant.create({ id })
      await merchant.sign({ id })
      const headers = {
        'oyst-authorization': `Oyst ${new Buffer(JSON.stringify({
          m: merchant.id,
          t: merchant.$url.token
        })).toString('base64')}`,
        'oyst-session': sessionID,
        'oyst-user': userID
      }
      await orderSession.setData(id, {
        product_reference: 'fake',
        variation_reference: 'fake'
      })
      await new MockCatalogAPI().fail(404).fixture({
        error: {
          code: 'CAT-404',
          message: 'product-not-found'
        }
      }).findByReferences({
        merchant_id: merchant.id,
        product_reference: 'fake',
        variation_reference: 'fake'
      })

      await Server.inject(merge(options, { headers }))
    } catch (err) {
      expect(err.statusCode).toBe(404)
      const error = JSON.parse(err.payload)
      expect(error).toEqual({
        error: {
          code: 'CAT-404',
          message: 'product-not-found'
        }
      })
    }
  })
  it('fails because payment was not created', async () => {
    try {
      const id = UUID()
      const merchant = await Merchant.create({ id })
      await merchant.sign({ id })
      const headers = {
        'oyst-authorization': `Oyst ${new Buffer(JSON.stringify({
          m: merchant.id,
          t: merchant.$url.token
        })).toString('base64')}`,
        'oyst-session': sessionID,
        'oyst-user': userID
      }
      await orderSession.setData(id, {
        product_reference: 'fake',
        variation_reference: 'fake'
      })
      await new MockCatalogAPI().success().fixture({
        product: Product
      }).findByReferences({
        merchant_id: merchant.id,
        product_reference: 'fake',
        variation_reference: 'fake'
      })
      await new MockUserAPI().success().fixture({ user: JohnDoe }).find(userID)
      await new MockPaymentAPI().fail(500).fixture({}).create(merchant.id, CreatePayment)
      await new MockPaymentAPI().success().fixture(AuthorizedPayment).authorize(merchant.id, AuthorizePayment)
      await new MockUserAPI().success().fixture({ user: JohnDoe }).find(AuthorizedPayment.user.id)
      await new MockOrderAPI().success().fixture(Order).create()

      await Server.inject(merge(options, { headers }))
    } catch (err) {
      expect(err.statusCode).toBe(500)
      const error = JSON.parse(err.payload)
      expect(error).toEqual({
        error: {
          code: 'PAY-500',
          message: 'api-error'
        }
      })
    }
  })
  it('Fails because auth is invalid', async () => {
    try {
      const id = UUID()
      const merchant = await Merchant.create({ id })
      await merchant.sign({ id })
      const headers = {
        'oyst-authorization': `Oyst ${new Buffer(JSON.stringify({
          m: UUID(),
          t: merchant.$url.token
        })).toString('base64')}`,
        'oyst-session': sessionID,
        'oyst-user': userID
      }
      await Server.inject(merge(options, { headers }))
      expect(false).toBeTruthy()
    } catch (err) {
      expect(err.statusCode).toBe(401)
      const error = JSON.parse(err.payload)
      expect(error).toEqual({
        error: {
          code: 'CLICK-401',
          message: 'unauthorized'
        }
      })
    }
  })
})