import Conversion, { ResultData } from './conversion'
import parseISO from 'date-fns/parseISO'
import Parameters, { StorageOptions } from './parameters'
import fetch, { Response } from 'node-fetch'
import BufferResult from './buffer-result'
import AuthenticationError from './errors/authentication-error'
import InvalidRequestError from './errors/invalid-request-error'
import QuotaError from './errors/quota-error'
import ConversionError from './errors/conversion-error'
import ForbiddenActionError from './errors/forbidden-action-error'
import RequestError from './errors/request-error'

const BASE_URL = 'https://api.pdfire.io/v1'

export default class Client {
  public baseUrl = BASE_URL

  constructor(public apiKey: string) {}

  /**
   * Create a PDF from the given parameters.
   */
  async convert(params: Parameters) {
    const response = await fetch(this.baseUrl + '/conversions', {
      method: 'POST',
      body: JSON.stringify(params.all()),
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
    })

    if (response.status === 400) {
      throw new InvalidRequestError((await response.json()).errors || [])
    }

    if (response.status === 401) {
      throw new AuthenticationError((await response.json()).errors || [])
    }

    if (response.status === 402) {
      throw new QuotaError((await response.json()).errors || [])
    }

    if (response.status === 403) {
      throw new ForbiddenActionError((await response.json()).errors || [])
    }

    if (response.status === 500) {
      throw new ConversionError((await response.json()).errors || [])
    }

    if (response.status !== 201) {
      throw new RequestError((await response.json()).errors || [])
    }

    return await this.makeResult(response)
  }

  /**
   * Create a PDF from the given parameters and return the buffer result.
   */
  async convertToBufferResult(params: Parameters) {
    return (await this.convert(params.cdn(false))) as BufferResult
  }

  /**
   * Create a PDF from the given parameters and return it as a buffer.
   */
  async convertToBuffer(params: Parameters) {
    return await (await this.convertToBufferResult(params)).buffer()
  }

  /**
   * Create a PDF from the given parameters, upload it to the CDN and return the conversion.
   */
  async convertUsingCDN(params: Parameters) {
    return (await this.convert(params.cdn(true))) as Conversion
  }

  async convertUsingStorage(params: Parameters, options?: StorageOptions) {
    return (await this.convert(params.storage(options))) as Conversion
  }

  private makeResult(response: Response) {
    const contentType = response.headers.get('Content-Type') || ''

    if (/application\/json/.test(contentType)) {
      return this.makeCDNResult(response)
    }

    return this.makeBufferResult(response)
  }

  private async makeCDNResult(response: Response) {
    const body = await response.json()

    const resultData: ResultData = body.result ? {
      ...body.result,
      expiresAt: body.result.expiresAt ? parseISO(body.result.expiresAt) : null,
    } : null

    return new Conversion(
      parseISO(body.initializedAt),
      parseISO(body.finishedAt),
      body.status,
      body.error,
      resultData
    )
  }

  private async makeBufferResult(response: Response) {
    return new BufferResult(await response.buffer())
  }
}