import logger from 'logger/logger'
import BaseController from 'common/base.controller'
import { ZError } from 'common/ZError'
import { router } from 'decorators/router'
import { createPageSign, queryFiat, queryPrice, refreshToken } from 'service/alchemy.svr'
import { generateKVStr } from 'utils/net.util'
import { PayRecord, PayStatus } from 'modules/PayRecord'
import { PriceSvr } from 'service/price.svr'

const CALL_BACK_URL = `${process.env.ALCHEMY_PAY_CB_URL}/pay/out/alchemy/buycb`
class AlchemyController extends BaseController {
  @router('post /pay/alchemy/buy')
  async beginPay(req, res) {
    const user = req.user
    const { network, crypto, address, fiat, fiatAmount, country } = req.params
    if (fiat || fiatAmount || country) {
      if (!fiat || !fiatAmount || !country) {
        throw new ZError(11, 'fiat, fiatAmount and country must be provided')
      }
    }
    if (network || crypto) {
      if (!network || !crypto) {
        throw new ZError(12, 'network and crypto must be provided')
      }
    }
    const tokenResult = await refreshToken(user.emailReal || user.email)
    console.log(tokenResult)
    if (!tokenResult.success || tokenResult.returnCode !== '0000') {
      logger.info(`fetch pay token error::code:  ${tokenResult.returnCode} msg: ${tokenResult.returnMsg}`)
      throw new ZError(10, 'fetch pay token error')
    }
    const { id, email, accessToken } = tokenResult.data
    let record = new PayRecord({ account: user.id, address, network, crypto })
    if (fiat) record.fiat = fiat
    if (fiatAmount) record.fiatAmount = fiatAmount
    if (country) record.country = country
    await record.save()
    const merchantOrderNo = record.id
    let dataOrign: any = {
      token: accessToken,
      email,
      id,
      showTable: 'buy',
      merchantOrderNo,
    }
    if (network) dataOrign.network = network
    if (crypto) dataOrign.crypto = crypto
    if (fiat) dataOrign.fiat = fiat
    if (fiatAmount) dataOrign.fiatAmount = fiatAmount
    if (country) dataOrign.country = country
    let dataSign: any = {
      appId: process.env.ALCHEMY_APPID,
      address,
      callbackUrl: CALL_BACK_URL,
    }
    let signStr = generateKVStr({ data: dataSign, sort: true })
    let sign = createPageSign(signStr)
    dataOrign.sign = sign
    Object.assign(dataOrign, dataSign)
    const urlBase = process.env.ALCHEMY_PAGE_BASE
    let url = `${urlBase}/`
    url = generateKVStr({ data: dataOrign, encode: true, uri: url })
    return { url }
  }

  @router('post /pay/alchemy/crypto_price')
  async queryCryptoPrice(req, res) {
    let { token, chain, currency, env } = req.params
    if (!token || !chain) {
      throw new ZError(11, 'token or network not found')
    }
    if (env.toLowerCase() === 'dev' && (token.toLowerCase() === 'ceg' || token.toLowerCase() === 'cec')) {
      return { price: 1 }
    }
    if (token.toLowerCase() === 'ceg') {
      return { price: 1 }
    }
    let data = {
      crypto: token,
      network: chain,
      fiat: currency || 'USD',
    }
    let result = await new PriceSvr().fetchPrice(data)
    return { price: result }
  }

  @router('get /pay/alchemy/fait_list')
  async cryptoList(req, res) {
    let result = await queryFiat()
    if (!result.success) {
      throw new ZError(10, result.returnMsg || 'fetch fiat list error')
    }
    return result.data
  }
}