import assert from 'assert-diff'
import _ from 'lodash'
import {RippleAPI} from 'ripple-api'
import {RecursiveData} from 'ripple-api/ledger/utils'
import {assertRejects, assertResultMatch} from './utils'
import addresses from './fixtures/addresses.json'
import responses from './fixtures/responses'
import ledgerClosed from './fixtures/rippled/ledger-close-newer.json'
import setupAPI from './setup-api'

const {validate, schemaValidator, ledgerUtils} = RippleAPI._PRIVATE
const address = addresses.ACCOUNT
assert.options.strict = true

// how long before each test case times out
const TIMEOUT = 20000

describe('RippleAPI', function() {
  this.timeout(TIMEOUT)
  beforeEach(setupAPI.setup)
  afterEach(setupAPI.teardown)

  it('RippleAPI - implicit server port', function() {
    new RippleAPI({server: 'wss://s1.ripple.com'})
  })

  it('RippleAPI invalid options', function() {
    // @ts-ignore - This is intentionally invalid
    assert.throws(() => new RippleAPI({invalid: true}))
  })

  it('RippleAPI valid options', function() {
    const api = new RippleAPI({server: 'wss://s:1'})
    const privateConnectionUrl = (api.connection as any)._url
    assert.deepEqual(privateConnectionUrl, 'wss://s:1')
  })

  it('RippleAPI invalid server uri', function() {
    assert.throws(() => new RippleAPI({server: 'wss//s:1'}))
  })

  xit('RippleAPI connect() times out after 2 seconds', function() {
    // TODO: Use a timer mock like https://jestjs.io/docs/en/timer-mocks
    //       to test that connect() times out after 2 seconds.
  })

  it('ledger closed event', function(done) {
    this.api.on('ledger', message => {
      assertResultMatch(message, responses.ledgerEvent, 'ledgerEvent')
      done()
    })
    this.api.connection._ws.emit('message', JSON.stringify(ledgerClosed))
  })

  describe('[private] schema-validator', function() {
    it('valid', function() {
      assert.doesNotThrow(function() {
        schemaValidator.schemaValidate(
          'hash256',
          '0F7ED9F40742D8A513AE86029462B7A6768325583DF8EE21B7EC663019DD6A0F'
        )
      })
    })

    it('invalid', function() {
      assert.throws(function() {
        schemaValidator.schemaValidate('hash256', 'invalid')
      }, this.api.errors.ValidationError)
    })

    it('invalid - empty value', function() {
      assert.throws(function() {
        schemaValidator.schemaValidate('hash256', '')
      }, this.api.errors.ValidationError)
    })

    it('schema not found error', function() {
      assert.throws(function() {
        schemaValidator.schemaValidate('unexisting', 'anything')
      }, /no schema/)
    })
  })

  describe('[private] validator', function() {
    it('validateLedgerRange', function() {
      const options = {
        minLedgerVersion: 20000,
        maxLedgerVersion: 10000
      }
      const thunk = _.partial(validate.getTransactions, {address, options})
      assert.throws(thunk, this.api.errors.ValidationError)
      assert.throws(
        thunk,
        /minLedgerVersion must not be greater than maxLedgerVersion/
      )
    })

    it('secret', function() {
      function validateSecret(secret) {
        validate.sign({txJSON: '', secret})
      }
      assert.doesNotThrow(
        _.partial(validateSecret, 'shzjfakiK79YQdMjy4h8cGGfQSV6u')
      )
      assert.throws(
        _.partial(validateSecret, 'shzjfakiK79YQdMjy4h8cGGfQSV6v'),
        this.api.errors.ValidationError
      )
      assert.throws(
        _.partial(validateSecret, 1),
        this.api.errors.ValidationError
      )
      assert.throws(
        _.partial(validateSecret, ''),
        this.api.errors.ValidationError
      )
      assert.throws(
        _.partial(validateSecret, 's!!!'),
        this.api.errors.ValidationError
      )
      assert.throws(
        _.partial(validateSecret, 'passphrase'),
        this.api.errors.ValidationError
      )
      // 32 0s is a valid hex repr of seed bytes
      const hex = new Array(33).join('0')
      assert.throws(
        _.partial(validateSecret, hex),
        this.api.errors.ValidationError
      )
    })
  })

  it('common utils - toRippledAmount', async () => {
    const amount = {issuer: 'is', currency: 'c', value: 'v'}
    assert.deepEqual(ledgerUtils.common.toRippledAmount(amount), {
      issuer: 'is',
      currency: 'c',
      value: 'v'
    })
  })

  it('ledger utils - renameCounterpartyToIssuerInOrder', async () => {
    const order = {
      taker_gets: {counterparty: '1', currency: 'XRP'},
      taker_pays: {counterparty: '1', currency: 'XRP'}
    }
    const expected = {
      taker_gets: {issuer: '1', currency: 'XRP'},
      taker_pays: {issuer: '1', currency: 'XRP'}
    }
    assert.deepEqual(
      ledgerUtils.renameCounterpartyToIssuerInOrder(order),
      expected
    )
  })

  it('ledger utils - compareTransactions', async () => {
    // @ts-ignore
    assert.strictEqual(ledgerUtils.compareTransactions({}, {}), 0)
    let first: any = {outcome: {ledgerVersion: 1, indexInLedger: 100}}
    let second: any = {outcome: {ledgerVersion: 1, indexInLedger: 200}}
    assert.strictEqual(ledgerUtils.compareTransactions(first, second), -1)
    first = {outcome: {ledgerVersion: 1, indexInLedger: 100}}
    second = {outcome: {ledgerVersion: 1, indexInLedger: 100}}
    assert.strictEqual(ledgerUtils.compareTransactions(first, second), 0)
    first = {outcome: {ledgerVersion: 1, indexInLedger: 200}}
    second = {outcome: {ledgerVersion: 1, indexInLedger: 100}}
    assert.strictEqual(ledgerUtils.compareTransactions(first, second), 1)
  })

  it('ledger utils - getRecursive', async () => {
    function getter(marker) {
      return new Promise<RecursiveData>((resolve, reject) => {
        if (marker !== undefined) {
          reject(new Error())
          return
        }
        resolve({marker: 'A', results: [1]})
      })
    }
    await assertRejects(ledgerUtils.getRecursive(getter, 10), Error)
  })
})