/* eslint-disable max-nested-callbacks */
'use strict';
const assert = require('assert-diff');
const _ = require('lodash');
const jayson = require('jayson');

const createHTTPServer = require('../../src/index').createHTTPServer;

const apiFixtures = require('../fixtures');
const apiRequests = apiFixtures.requests;
const apiResponses = apiFixtures.responses;

const fixtures = require('./fixtures');

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

const apiOptions = {
  server: 'wss://s1.ripple.com'
};

const httpPort = 3000;

function createClient() {
  return jayson.client.http({port: httpPort, hostname: 'localhost'});
}

const address = 'r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59';

function makePositionalParams(params) {
  return params.map(value => value[_.keys(value)[0]]);
}

function makeNamedParams(params) {
  return _.reduce(params, _.assign, {});
}

function random() {
  return _.fill(Array(16), 0);
}

describe('http server integration tests', function() {
  this.timeout(TIMEOUT);

  let server = null;
  let client = null;

  function createTestInternal(testName, methodName, params, testFunc, id) {
    it(testName, function() {
      return new Promise((resolve, reject) => {
        client.request(methodName, params, id,
          (err, result) => err ? reject(err) : resolve(testFunc(result)));
      });
    });
  }

  function createTest(name, params, testFunc, id) {
    createTestInternal(name + ' - positional params', name,
      makePositionalParams(params), testFunc, id);
    createTestInternal(name + ' - named params', name,
      makeNamedParams(params), testFunc, id);
  }

  beforeEach(function() {
    server = createHTTPServer(apiOptions, httpPort);
    return server.start().then(() => {
      this.client = createClient();
      client = this.client;
    });
  });

  afterEach(function() {
    return server.stop();
  });


  createTest(
    'getLedgerVersion',
    [],
    result => assert(_.isNumber(result.result))
  );

  createTest(
    'getServerInfo',
    [],
    result => assert(_.isNumber(result.result.validatedLedger.ledgerVersion))
  );

  createTest(
    'getTransaction',
    [{id: '4EB6B76237DEEE99F1EA16FAACED2D1E69C5F9CB54F727A4ECA51A08AD3AF466'}],
    result => assert.deepEqual(result, fixtures.getTransaction),
    '2'
  );

  createTest(
    'getTransactions',
    [{address: 'rpP2JgiMyTF5jR5hLG3xHCPi1knBb1v9cM'}, {
      options: {
        binary: true,
        limit: 1,
        start:
          'FBAAC31D6BAEEFA9E501266FD62DA7A7982662BC19BC42F49BB41405C2F820DB'
      }
    }],
    result => assert.deepEqual(result, fixtures.getTransactions),
    '3'
  );

  createTest(
    'prepareSettings',
    [
      {address},
      {settings: apiRequests.prepareSettings},
      {instructions: {
        maxFee: '0.000012',
        sequence: 23,
        maxLedgerVersion: 8820051
      }}
    ],
    result => {
      const got = JSON.parse(result.result.txJSON);
      const expected = JSON.parse(apiResponses.prepareSettings.flags.txJSON);
      assert.deepEqual(got, expected);
    }
  );

  createTest(
    'sign',
    [{txJSON: apiRequests.sign.normal.txJSON},
    {secret: 'shsWGZcmZz6YsWWmcnpfr6fLTdtFV'}],
    result => assert.deepEqual(result.result, apiResponses.sign.normal)
  );

  createTest(
    'generateAddress',
    [{options: {entropy: random()}}],
    result => assert.deepEqual(result.result, apiResponses.generateAddress)
  );

  createTest(
    'computeLedgerHash',
    [{ledger: _.assign({}, apiResponses.getLedger.full,
      {parentCloseTime: apiResponses.getLedger.full.closeTime})
    }],
    result => {
      assert.strictEqual(result.result,
        'E6DB7365949BF9814D76BCC730B01818EB9136A89DB224F3F9F5AAE4569D758E');
    }
  );

  createTest(
    'isConnected',
    [],
    result => assert(result.result)
  );

});