/* eslint-disable class-methods-use-this */
import { WyreClient } from '@beamnetwork/wyre-node-api'
import { WyreAPIInterface } from './WyreAPIInterface'
import { CreateSubscriptionRequest } from './CreateSubscriptionRequest'
import { APIResponse } from './APIResponse'
import { Subscription } from './Subscription'
import { SubscriptionsList } from './SubscriptionsList'
import { GetSubscriptionsRequest } from './GetSubscriptionsRequest'
import { Transfer } from './Transfer'
import { getErrorResponse } from './api-response-utils'
import { TransferRequest } from './TransferRequest'
import { WyreAccount } from './WyreAccount'
import { CreateAccountRequest } from './CreateAccountRequest'
import { WyreAPIOptions } from './WyreAPIOptions'
import { UploadDocumentParams } from './UploadDocumentParams'
import { CreateWyreWalletParams } from './CreateWyreWalletParams'
import { WyreWallet } from './WyreWallet'
import { CreateMultipleWalletsParams } from './CreateMultipleWalletsParams'
import { EditWalletParams } from './EditWalletParams'
import { PaymentMethodParams } from './PaymentMethodParams'
import { PaymentMethod } from './PaymentMethod'
import { UploadPaymentMethodDocumentParams } from './UploadPaymentMethodDocumentParams'
import { UpdateAccountRequest } from './UpdateAccountRequest'
import { CreateUserRequest } from './CreateUserRequest'
import { WyreUser } from './WyreUser'
import { WyreUserKYCData } from './WyreUserKYCData'
import { MigrateAccountResponse } from './MigrateAccountResponse'

export class SecretKeyWyreAPI implements WyreAPIInterface {
  private wyre: WyreClient

  constructor(
    private options: WyreAPIOptions,
    wyreClient?: WyreClient,
  ) {
    this.wyre = wyreClient || new WyreClient(options)
  }

  // tslint:disable-next-line: no-empty
  async initialize() {
  }

  async createUser(params: CreateUserRequest): Promise<APIResponse<WyreUser>> {
    const req = this.wyre.post('/v3/users', params)
    return await this.executeRequest<WyreUser>(req)
  }

  async getUser(
    userID: string,
    scopes: string = 'TRANSFER',
  ): Promise<APIResponse<WyreUser>> {
    const req = this.wyre.get(`/v3/users/${userID}?scopes=${scopes}`)
    return await this.executeRequest<WyreUser>(req)
  }

  async uploadUserKYCData(
    userID: string,
    kycData: WyreUserKYCData,
  ): Promise<APIResponse<WyreUser>> {
    const req = this.wyre.post(`/v3/users/${userID}`, kycData)
    return await this.executeRequest<WyreUser>(req)
  }

  async createAccount(params: CreateAccountRequest): Promise<APIResponse<WyreAccount>> {
    const req = this.wyre.post('/v3/accounts', params)
    return await this.executeRequest<WyreAccount>(req)
  }

  async updateAccount(
    accountID: string,
    updates: UpdateAccountRequest,
  ): Promise<APIResponse<WyreAccount>> {
    const req = this.wyre.post(`/v3/accounts/${accountID}`, updates)
    return await this.executeRequest<WyreAccount>(req)
  }

  async migrateAccount(
    accountID: string,
  ): Promise<APIResponse<MigrateAccountResponse>> {
    const params = {
      accountId: accountID,
    }

    const req = this.wyre.post(`/v3/users/migrateAccount`, params)
    return await this.executeRequest<MigrateAccountResponse>(req)
  }

  async uploadDocument(
    params: UploadDocumentParams,
    buff: Buffer,
  ): Promise<APIResponse<WyreAccount>> {
    const { accountId, fieldId, contentType, documentType, documentSubType } = params

    const headers = {
      'Content-Type': contentType,
      'Content-Length': buff.length,
    }

    let reqUri = `/v3/accounts/${accountId}/${fieldId}`

    if (documentType) {
      reqUri = `${reqUri}?documentType=${documentType}&documentSubType=${documentSubType}`
    }

    const req = this.wyre.post(
      reqUri,
      buff,
      { headers }
    )

    return await this.executeRequest<WyreAccount>(req)
  }

  async uploadPaymentMethodDocument(
    params: UploadPaymentMethodDocumentParams,
    buff: Buffer,
  ): Promise<APIResponse<PaymentMethod>> {
    const { paymentMethodId, contentType } = params

    const headers = {
      'Content-Type': contentType,
      'Content-Length': buff.length,
    }

    const req = this.wyre.post(
      `/v2/paymentMethod/${paymentMethodId}/followup`,
      buff,
      { headers }
    )

    return await this.executeRequest<PaymentMethod>(req)
  }

  async addPaymentMethod(
    params: PaymentMethodParams,
  ): Promise<APIResponse<PaymentMethod>> {
      const req = this.wyre.post('/v2/paymentMethods', params)
    return await this.executeRequest<PaymentMethod>(req)
  }

  async getPaymentMethod(
    paymentMethodID: string,
  ): Promise<APIResponse<PaymentMethod>> {
    const req = this.wyre.get(`/v2/paymentMethod/${paymentMethodID}`)
    return await this.executeRequest<PaymentMethod>(req)
  }

  async listPaymentMethods(): Promise<APIResponse<PaymentMethod[]>> {
    const req = this.wyre.get(`/v2/paymentMethods`)
    return await this.executeRequest<PaymentMethod[]>(req)
  }

  async deletePaymentMethod(
    paymentMethodID: string,
  ): Promise<APIResponse<any>> {
    const req = this.wyre.delete(`/v2/paymentMethod/${paymentMethodID}`)
    return await this.executeRequest<any>(req)
  }

  async attachBlockchainToPaymentMethod(paymentMethodId, params) {
    const req = this.wyre.post(`/v2/paymentMethod/${paymentMethodId}/attach`, params)
    return await this.executeRequest(req)
  }

  async createTransfer(transferRequest: TransferRequest): Promise<APIResponse<Transfer>> {
    const req = this.wyre.post('/v3/transfers', transferRequest)
    return await this.executeRequest<Transfer>(req)
  }

  async confirmTransfer(transferID): Promise<APIResponse<Transfer>> {
    const req = this.wyre.post(`/v3/transfers/${transferID}/confirm`, {})
    return await this.executeRequest<Transfer>(req)
  }

  async getAccountInfoV2(): Promise<APIResponse<WyreAccount>> {
    const req = this.wyre.get('/v2/account')
    return await this.executeRequest(req)
  }

  async getAccountInfoV3(accountID): Promise<APIResponse<WyreAccount>> {
    const req = this.wyre.get(`/v3/accounts/${accountID}`)
    return await this.executeRequest<WyreAccount>(req)
  }

  async getTransfers(transferID): Promise<APIResponse<Transfer>> {
    let url = '/v3/transfers'
    if (transferID) {
      url += `/${transferID}`
    }

    const req = this.wyre.get(url)
    return await this.executeRequest<Transfer>(req)
  }

  async createSubscription(
    subscribeRequest: CreateSubscriptionRequest
  ): Promise<APIResponse<Subscription>> {
    const req = this.wyre.post('/v3/subscriptions', subscribeRequest)
    const {
      response: subscription,
      error,
    } = await this.executeRequest<Subscription>(req)

    if (error) {
      return { error }
    }

    if (Object.keys(subscription).length === 0) {
      return { error: 'subscribeWebhook failed' }
    }
    return { response: subscription }
  }

  async deleteSubscription(subscriptionID): Promise<APIResponse<any>> {
    const req = this.wyre.delete(`/v3/subscriptions/${subscriptionID}`)
    return await this.executeRequest<any>(req)
  }

  async getSubscriptions(
    subscriptionsReq: GetSubscriptionsRequest
  ): Promise<APIResponse<SubscriptionsList>> {
    const { offset, length } = subscriptionsReq
    const req = this.wyre.get(
      `/v3/subscriptions?offset=${offset}&length=${length}`,
    )

    const {
      response,
      error,
    } = await this.executeRequest<SubscriptionsList>(req)

    if (error) {
      return { error }
    }

    return { response }
  }

  async getRates(as, pair) {
    const req = this.wyre.get(`/v3/rates?as=${as}`)

    const { response: rates, error } = await this.executeRequest(req)
    if (error) {
      return { error }
    }

    if (pair) {
      return { rates: rates[pair] }
    }

    return { response: rates }
  }

  // Wallet Endpoints

  async createWallet(walletParams: CreateWyreWalletParams): Promise<APIResponse<WyreWallet>> {
    const req = this.wyre.post('/v2/wallets', walletParams)
    return this.executeRequest<WyreWallet>(req)
  }

  async createMultipleWallets(params: CreateMultipleWalletsParams): Promise<APIResponse<WyreWallet[]>> {
    const req = this.wyre.post('/v2/wallets/batch', params)
    return this.executeRequest<WyreWallet[]>(req)
  }

  async lookupWallet(walletID: string): Promise<APIResponse<WyreWallet>> {
    const req = this.wyre.get(`/v2/wallet/${walletID}`)
    return this.executeRequest<WyreWallet>(req)
  }

  async editWallet(walletID: string, params: EditWalletParams): Promise<APIResponse<any>> {
    const req = this.wyre.post(`/v2/wallet/${walletID}/update`, params)
    return await this.executeRequest<any>(req)
  }

  async deleteWallet(walletID: string): Promise<APIResponse<any>> {
    const req = this.wyre.delete(`/v2/wallet/${walletID}`)
    return await this.executeRequest<any>(req)
  }

  async listWallets(limit: number, offset: number): Promise<APIResponse<WyreWallet[]>> {
    const req = this.wyre.get(`/v2/wallets?limit=${limit}&offset=${offset}`)
    return this.executeRequest<WyreWallet[]>(req)
  }

  getMasqueraded(entityID: string): WyreAPIInterface {
    if (this.options.isCreatedUsingBearerToken) {
      return this
    }

    return new SecretKeyWyreAPI(this.options, this.wyre.masqueraded(this.getMasqueradeTarget(entityID)))
  }

  private getMasqueradeTarget(
    entityID: string,
  ): string {
    // Check to see what kind of token was passed in.
    if (this.isUserID(entityID)) {
      return `user:${entityID}`
    }

    return entityID
  }

  private isAccountID(
    token: string
  ): boolean {
    return token.startsWith('AC_')
  }

  private isUserID(
    token: string
  ): boolean {
    return token.startsWith('US_')
  }

  // async executeRequest(req): Promise<any>  {
  //   try {
  //     const response = await req
  //     return { response }
  //   } catch (ex) {
  //     return { error: getErrorResponse(ex) }
  //   }
  // }

  async executeRequest<T>(req: any): Promise<APIResponse<T>> {
    try {
      const response = await req
      return { response }
    } catch (ex) {
      return { error: getErrorResponse(ex) }
    }
    // try {
    //   const response = await req
    //   const { data } = response
    //   return { response: data }
    // } catch (ex) {
    //   return { error: this.getError(ex) }
    // }
  }

  // private getError(ex: any): any {
  //   const { response } = ex
  //   if (response) {
  //     const { data } = response
  //     if (data) {

  //       const error1 = {
  //         message: data,
  //       }

  //       return getErrorResponse(error1)
  //     }
  //   }

  //   const error = {
  //     message: ex.error || ex,
  //   }

  //   return getErrorResponse(error)
  // }
}