import { defaultOptions, Memo, Options } from '../util/types'
import { Client, DisconnectedError, Payment, TxResponse, Wallet,  } from 'xrpl'

import * as zlib from 'zlib'
import * as util from 'util'
import { NON_ZERO_TX_HASH } from '../util/protocol.constants'
import { BadTxHashError, CannotVerifyOwnerError } from '../util/errors'

const compressB64 = async (data: string) => (await util.promisify(zlib.deflate)(Buffer.from(data, 'utf-8'))).toString('base64')
const decompressB64 = async (data: string) => (await util.promisify(zlib.inflate)(Buffer.from(data, 'base64'))).toString('utf-8')
const hexDecode = (str: string) => Buffer.from(str, 'hex').toString('utf8')
const hexEncode = (str: string) => Buffer.from(str, 'utf8').toString('hex').toUpperCase()
const chunkString = (str: string, length: number) => str.match(new RegExp('.{1,' + length + '}', 'gs'));
const genRandHex = size => [...Array(size)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
const PAYLOAD_SIZE = 925
const XRP_PER_DROP = 0.000001
const DROP_PER_XRP = 1000000

export class xrpIO {
  private api: Client

  constructor(
    private server: string,
    private options: Options = defaultOptions
  ) {

    this.options.debug = options.debug ? Boolean(options.debug) : defaultOptions.debug
    this.options.connectionTimeout = options.connectionTimeout ? Number(options.connectionTimeout) : defaultOptions.connectionTimeout
    this.options.readMaxRetry = options.readMaxRetry ? Number(options.readMaxRetry) : defaultOptions.readMaxRetry
    this.options.readRetryTimeout = options.readRetryTimeout ? Number(options.readRetryTimeout) : defaultOptions.readRetryTimeout
    this.options.readFreshApi = options.readFreshApi ? Boolean(options.readFreshApi) : defaultOptions.readFreshApi
    this.options.writeMaxRetry = options.writeMaxRetry ? Number(options.readFreshApi) : defaultOptions.writeMaxRetry
    this.options.writeRetryTimeout = options.writeRetryTimeout ? Number(options.writeRetryTimeout) : defaultOptions.writeRetryTimeout

    this.api = new Client(server, {
      connectionTimeout: this.options.connectionTimeout
    })
  }

  public async connect(): Promise<void> {
    if (!this.api.isConnected())
      await this.api.connect()
  }

  public async disconnect(): Promise<void> {
    try {
      await this.api.disconnect()
    } catch (e) {
      console.log("DISCONNECT ERROR", e)
    }
  }

  private async cloneApi(): Promise<Client> {
    let _api = new Client(this.server, {
      connectionTimeout: this.options.connectionTimeout
    })

    while (!_api.isConnected()) {
      try {
        await _api.connect()
        return _api
      } catch (e) {
        this.dbg('CLONEAPI ERR', 'Connection failed', String(e['message']))
        await _api.disconnect()
        _api = new Client(this.server, {
          connectionTimeout: this.options.connectionTimeout
        })
      }
    }
  }

  public async sendPayment(data: Memo, to: string, secret: string, sequence?: number, amount: string = "1", retry = 0): Promise<TxResponse> {
    const wallet = Wallet.fromSecret(secret)
    this.dbg("Sending payment", wallet.address, '->', to)

    const _api = await this.cloneApi()
    
    const payment: Payment = await _api.autofill({
      TransactionType: 'Payment',
      Account: wallet.address,
      Destination: to,
      Sequence: sequence,
      Amount: amount,
      Memos: [{
        Memo: {
          MemoData: hexEncode(data.data || ""),
          MemoFormat: hexEncode(data.format || ""),
          MemoType: hexEncode(data.type || "")
        }
      }]
    })

    let response: TxResponse;
    try {
      response = await _api.submitAndWait(payment, { wallet })
    } catch (error: any) {
      this.dbg("SENDPAYMENT ERROR", error)

      if(error instanceof DisconnectedError){
        //Usually caused by hitting rate limits. Recoverable.
        if(this.options.writeMaxRetry != -1 && retry >= this.options.writeMaxRetry){
          //exceeded retry quota
          throw error
        }
        await new Promise(res => setTimeout(res, this.options.writeRetryTimeout))
        return await this.sendPayment(data, to, secret, sequence, amount, retry+1)
      }

      throw error
    }finally{
      await _api.disconnect()
    }

    //We cannot afford this payment. Irrecoverable error
    if(response.result.meta && response.result.meta['TransactionResult'] && response.result.meta['TransactionResult'] === 'tecUNFUNDED_PAYMENT'){
      throw new Error(`Insufficient funds to send transaction. See tx ${response.result.hash}`)
    }
    
    
    this.dbg("Tx finalized", response.result.hash, response.result.tx_json.Sequence)
    return response

  }

  public async writeRaw(data: Memo, to: string, secret: string, sequence?: number, amount: string = "1"): Promise<string> {
    this.dbg("Writing data", data)
    const tx = await this.sendPayment(data, to, secret, sequence, amount)
    return tx.result.hash
  }

  public async getTransaction(hash: string, retry = 0): Promise<TxResponse> {
    if (!NON_ZERO_TX_HASH.test(hash)) {
      throw new BadTxHashError(hash)
    }

    this.dbg("Getting Tx", hash)
    
    const _api = this.options.readFreshApi ? await this.cloneApi() : this.api

    try {
      return await _api.request({
        command: 'tx',
        transaction: hash,
      })
    } catch (e: any) {
      this.dbg("getTransaction err", e)
      
      if(e.data){ //RippledError 
        switch(e.data.error){
          //irrecoverable errors
          case 'amendmentBlocked': //server is amendment blocked and needs to be updated to the latest version to stay synced with the XRP Ledger network.
          case 'invalid_API_version': //The server does not support the API version number from the request.
          case 'jsonInvalid': //(WebSocket only) The request is not a proper JSON object.
          case 'missingCommand': //(WebSocket only) The request did not specify a command field
          case 'noClosed': //The server does not have a closed ledger, typically because it has not finished starting up.
          case 'txnNotFound': //Either the transaction does not exist, or it was part of an ledger version that rippled does not have available
          case 'unknownCmd': //The request does not contain a command that the rippled server recognizes
          case 'wsTextRequired': //(WebSocket only) The request's opcode  is not text.
          case 'invalidParams': //One or more fields are specified incorrectly, or one or more required fields are missing.
          case 'excessiveLgrRange': //The min_ledger and max_ledger fields of the request are more than 1000 apart
          case 'invalidLgrRange': //The specified min_ledger is larger than the max_ledger, or one of those parameters is not a valid ledger index
            throw e

          //potentially recoverable errors
          case 'failedToForward': //(Reporting Mode servers only) The server tried to forward this request to a P2P Mode server, but the connection failed
          case 'noCurrent': //The server does not know what the current ledger is, due to high load, network problems, validator failures, incorrect configuration, or some other problem.
          case 'noNetwork': //The server is having trouble connecting to the rest of the XRP Ledger peer-to-peer network (and is not running in stand-alone mode).
          case 'tooBusy': //The server is under too much load to do this command right now. Generally not returned if you are connected as an admin
          default: //some undocumented error, might as well give it a re-try
            //fall through
        }
      }
      //some other error, potentially recoverable
      if (this.options.readMaxRetry != -1 && retry >= this.options.readMaxRetry) { //not doing infinite retries and exhausted retry quota
        throw e
      }else{
        await new Promise(res => setTimeout(res, this.options.readRetryTimeout))
        return await this.getTransaction(hash, retry + 1)
      }
    }finally{
      if(this.options.readFreshApi) await _api.disconnect()
    }
  }

  public async readRaw(hash: string, verifyOwner?: string): Promise<Memo> {
    if (!NON_ZERO_TX_HASH.test(hash)) {
      throw new BadTxHashError(hash)
    }
    const tx = await this.getTransaction(hash)

    if(verifyOwner && tx.result.tx_json.Account != verifyOwner){
      throw new CannotVerifyOwnerError(hash, tx.result.tx_json.Account, verifyOwner)
    }

    const memo = tx.result.tx_json.Memos[0].Memo
    const memoParsed = {
      data: hexDecode(memo.MemoData),
      format: hexDecode(memo.MemoFormat),
      type: hexDecode(memo.MemoType)
    }
    this.dbg(hash, "data", memoParsed)
    return memoParsed
  }

  public async treeWrite(data: string, to: string, secret: string, format: string = "0", progressCallback: Function = (done:number,max:number)=>{}): Promise<string> {
    const wallet = Wallet.fromSecret(secret)
    data = await compressB64(data)
    const chunks = chunkString(data, PAYLOAD_SIZE)
    const latestSequence = await this.getAccountSequence(wallet.address)

    let count = 0
    const hashes = await Promise.all(Object.entries(chunks).map(([i, chunk]) => {
      const res = this.writeRaw({ data: chunk, format: format }, to, secret, latestSequence + Number(i))
      count += 1
      progressCallback(count, chunks.length)
      return res
    }))

    if (hashes.length === 1) {
      return hashes[0]
    }

    return await this.treeWrite(JSON.stringify(hashes), to, secret, `${hashes.length}`)
  }

  public async treeRead(hashes: string[], verifyOwner?:string, progressCallback: Function = (done:number,max:number)=>{}): Promise<string> {
    const bad_hash = hashes.find(hash => !NON_ZERO_TX_HASH.test(hash))
    if (bad_hash)
      throw new BadTxHashError(bad_hash)

    let count = 0;
    const memos = await Promise.all(hashes.map(async hash => {
      const res = this.readRaw(hash, verifyOwner)
      count += 1
      progressCallback(count, hashes.length)
      return res
    }))
    const payload: string = await decompressB64(memos.map(memo => memo.data).join(''))

    if (memos.some(memo => memo.format !== '0')) {
      return await this.treeRead(JSON.parse(payload), verifyOwner)
    }

    return payload
  }

  public async getAccountSequence(address: string): Promise<number> {
    this.dbg("Getting acc info for", address)
    const accountInfo = await this.api.request({
      command: 'account_info',
      account: address,
      strict: true,
    })
    this.dbg("Got account_info", accountInfo)
    return Number(accountInfo.result.account_data.Sequence)
  }

  public async estimateFee(data: string, denomination: 'XRP' | 'DROPS' = 'DROPS', cost = 0): Promise<number> {
    data = await compressB64(data)
    const chunks = chunkString(data, PAYLOAD_SIZE)

    if (chunks.length === 1) {
      return (denomination === "DROPS" ? (cost + 1) : this.dropsToXrp(cost + 1))
    }

    return this.estimateFee(JSON.stringify(chunks.map(_ => genRandHex(64))), denomination, cost + chunks.length)
  }

  public xrpToDrops(xrp: number): number {
    return xrp * DROP_PER_XRP
  }

  public dropsToXrp(drops: number): number {
    return drops * XRP_PER_DROP
  }

  private dbg(...args: any[]) {
    if (this.options.debug) {
      console.log.apply(console, args)
    }
  }
}