'use strict';

/* eslint-disable max-len */
const _ = require('lodash');
const assert = require('assert-diff');
const lodash = require('lodash');
const ripple = require('ripple-lib');
const fixtures = require('./fixtures/uint');

function resultError(test, result) {
  function type(e) {
    return Object.prototype.toString.call(e);
  }
  return `Expected ${type(test.input)}: ${test.input} to yield ${type(test.expected)}: ${test.expected === 'null' ? NaN : test.expected}. Actual: ${type(result)}: ${result}`;
}

function makeTests(uIntType) {
  describe(uIntType, function() {
    const rippleType = ripple[uIntType];
    const tests = fixtures[uIntType];

    it('from_json().to_json()', function() {
      tests['from_json().to_json()'].forEach(function(test) {
        let result = rippleType.from_json(test.input);
        assert.strictEqual(result.is_valid(), String(test.expected) !== 'null', `Validity check failed: ${test.input}`);
        result = result.to_json();

        if (test.expected === 'null') {
          // XXX
          // UInt160.to_json() returns NaN rather than null if input is invalid
          assert.strictEqual(lodash.isNaN(result), true, resultError(test, result));
        } else {
          assert.strictEqual(result, test.expected, resultError(test, result));
        }
      });
    });
    it('from_json().to_bytes()', function() {
      tests['from_json().to_bytes()'].forEach(function(test) {
        const result = rippleType.from_json(test.input);
        assert.strictEqual(result.is_valid(), String(test.expected) !== 'null', `Validity check failed: ${test.input}`);
        assert.deepEqual(result.to_bytes(), test.expected, resultError(test, result));
      });
    });
    it('from_number().to_json()', function() {
      tests['from_number().to_json()'].forEach(function(test) {
        let result = rippleType.from_number(test.input);
        assert.strictEqual(result.is_valid(), String(test.expected) !== 'null', `Validity check failed: ${test.input}`);
        result = result.to_json();

        if (test.expected === 'null') {
          // XXX
          // UInt160.to_json() returns NaN rather than null if input is invalid
          assert.strictEqual(lodash.isNaN(result), true, resultError(test, result));
        } else {
          assert.strictEqual(result, test.expected, resultError(test, result));
        }
      });
    });
    it('from_number().to_hex()', function() {
      tests['from_number().to_hex()'].forEach(function(test) {
        const result = rippleType.from_number(test.input);
        assert.strictEqual(result.is_valid(), String(test.expected) !== 'null', `Validity check failed: ${test.input}`);
        assert.strictEqual(result.to_hex(), test.expected, resultError(test, result));
      });
    });
    it('from_generic().to_*()', function() {
      tests['from_generic().to_*()'].forEach(function(test) {
        let result = rippleType.from_generic(test.input);

        switch (test.input) {
          // XXX
          // from_generic() accepts these as "zero"
          case 0:
          case '0':
          case undefined:
            switch (test.outputMethod) {
              case 'to_bytes':
                test.expected = _.fill(Array(rippleType.width), 0);
                break;
              case 'to_json':
              case 'to_hex':
                test.expected = _.fill(Array(rippleType.width * 2), 0).join('');
                break;
            }
        }

        assert.strictEqual(result.is_valid(), String(test.expected) !== 'null',
                           `Validity check failed: ${test.input} > ${test.expected}`);

        result = result[test.outputMethod]();

        if (test.expected === 'null') {
          // XXX
          // UInt160.to_json() returns NaN rather than null if input is invalid
          assert.strictEqual(lodash.isNaN(result), true, resultError(test, result));
        } else {
          assert.deepEqual(result, test.expected, resultError(test, result));
        }
      });
    });
  });
}

['UInt128', 'UInt160', 'UInt256'].forEach(makeTests);