// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import { assert } from 'chai';
import * as human from './human';

describe('The human functions', () => {
  function testPad() {
    const testCases: [number, number, string][] = [
      [0, 0, '0'],
      [1, 1, '1'],
      [10, 1, '10'],
      [10, 2, '10'],
      [10, 3, '010'],
      [31558150, 8, '31558150'],
      [31558150, 9, '031558150'],
    ];
    for (const testCase of testCases) {
      assert.equal(human.pad(testCase[0], testCase[1]), testCase[2]);
    }
  }

  it('should return padded integers from pad', testPad);

  function testStrDuration() {
    const testCases: [number, string][] = [
      [0, '  0s'],
      [1, '  1s'],
      [-1, '  1s'],
      [2, '  2s'],
      [10, ' 10s'],
      [-30, ' 30s'],
      [59, ' 59s'],
      [60, '  1m'],
      [-61, '  1m  1s'],
      [123, '  2m  3s'],
      [3599, ' 59m 59s'],
      [3600, '  1h'],
      [3601, '  1h  1s'],
      [3659, '  1h 59s'],
      [3660, '  1h  1m'],
      [3661, '  1h  1m  1s'],
      [86399, ' 23h 59m 59s'],
      [86400, '  1d'],
      [86401, '  1d  1s'],
      [604799, '  6d 23h 59m 59s'],
      [604800, '  1w'],
      [31558150, ' 52w  1d  6h  9m 10s'],
    ];
    for (const testCase of testCases) {
      assert.equal(human.strDuration(testCase[0]), testCase[1]);
    }
  }

  it('should return human-readable duration from strDuration', testStrDuration);

  function testDiffDate() {
    const now = 1584972056 * 1000; // 03/23/2020 @ 2:00pm (UTC)
    const testCases: [number, string][] = [
      [0, '0s'], //            0s
      [1, '0s'], //            0.001s
      [499, '0s'], //          0.499s
      [500, '1s'], //          0.5s
      [-1000, '1s'], //        1s
      [1000, '1s'], //         1s
      [2000, '2s'], //         2s
      [9800, '10s'], //        9.8s
      [-10000, '10s'], //      10s
      [-30000, '30s'], //      30s
      [59000, '59s'], //       59s
      [59499, '59s'], //       59.499s
      [59500, '1m'], //        59.5s
      [60000, '1m'], //        1m 00s
      [-61000, '1m'], //       1m 01s
      [123000, '2m'], //       2m 03s
      [3569000, '59m'], //     59m 29s
      [3570000, '1h'], //      59m 30s
      [3600000, '1h'], //      1h 00m 00s
      [-3601000, '1h'], //     1h 00m 01s
      [3659000, '1h'], //      1h 00m 59s
      [-3660000, '1h'], //     1h 01m 00s
      [5398000, '1h'], //      1h 29m 58s
      [5400000, '2h'], //      1h 30m 00s
      [-84599000, '23h'], //   23h 29m 59s
      [-84600000, '1d'], //    23h 30m 00s
      [-86399000, '1d'], //    23h 59m 59s
      [86400000, '1d'], //     1d 00h 00m 00s
      [-561599000, '6d'], //   6d 11h 59m 59s
      [-561600000, '1w'], //   6d 12h 00m 00s
      [604800000, '1w'], //    1w 0d 00h 00m 00s
      [31558150000, '52w'], // 52w 1d 06h 09m 10s
    ];
    for (const testCase of testCases) {
      const diffMs = testCase[0];
      const expected = testCase[1];
      const ms = now + diffMs;
      // Test the form of diffDate that takes a number.
      assert.equal(
        human.diffDate(ms, now),
        expected,
        `Input is ${ms}, now is ${now}`
      );
      // Test the form of diffDate that takes a date string.
      assert.equal(
        human.diffDate(new Date(ms).toISOString(), now),
        expected,
        `Input is ${new Date(ms).toISOString()}, now is ${new Date(
          now
        ).toISOString()}`
      );
    }
  }

  it('should return human-readable duration from diffDate', testDiffDate);

  function testBytes() {
    const testBytesTestCases: [number, string][] = [
      [0, '0 B'], //              0 B
      [1, '1 B'], //              1 B
      [499, '499 B'], //          499 B
      [500, '500 B'], //          500 B
      [1000, '1000 B'], //        1000 B
      [1234, '1 KB'], //          1 KB 210 B
      [2000, '2 KB'], //          1 KB 976 B
      [9727, '9 KB'], //          9 KB 511 B
      [9728, '10 KB'], //         9 KB 512 B
      [30000, '29 KB'], //        29 KB 304 B
      [1024000, '1000 KB'], //    1000 KB 000 B
      [1048500, '1 MB'], //       1023 KB 948 B
      [1048576, '1 MB'], //       1 MB 000 KB 000 B
      [1048577, '1 MB'], //       1 MB 000 KB 001 B
      [300000000, '286 MB'], //   286 MB 104 KB 768 B
      [1072693248, '1023 MB'], // 1023 MB 000 KB 000 B
      [1073741300, '1 GB'], //    1023 MB1023 KB 999 B
      [1073741824, '1 GB'], //    1 GB 000 MB 000 KB 000 B
      [1073741825, '1 GB'], //    1 GB 000 MB 000 KB 001 B
    ];
    for (const tb of testBytesTestCases) {
      const b = tb[0];
      const expected = tb[1];
      assert.equal(human.bytes(b), expected, `Input is ${b}, Unit is bytes`);
    }
    const testMB: [number, string][] = [
      [0, '0 B'], //              0 MB
      [1, '1 MB'], //             1 MB
      [499, '499 MB'], //         499 MB
      [500, '500 MB'], //         500 MB
      [1000, '1000 MB'], //       1000 MB
      [1234, '1 GB'], //          1 GB 210 MB
      [2000, '2 GB'], //          1 GB 976 MB
      [9727, '9 GB'], //          9 GB 511 MB
      [9728, '10 GB'], //         9 GB 512 MB
      [30000, '29 GB'], //        29 GB 304 MB
      [1024000, '1000 GB'], //    1000 GB 000 MB
      [1048500, '1 TB'], //       1023 GB 948 MB
      [1048576, '1 TB'], //       1 TB 000 GB 000 MB
      [1048577, '1 TB'], //       1 TB 000 GB 001 MB
      [300000000, '286 TB'], //   286 TB 104 GB 768 MB
      [1072693248, '1023 TB'], // 1023 TB 000 GB 000 MB
      [1073741300, '1 PB'], //    1023 TB1023 GB 999 MB
      [1073741824, '1 PB'], //    1 PB 000 TB 000 GB 000 MB
      [1073741825, '1 PB'], //    1 PB 000 TB 000 GB 001 MB
    ];
    for (const tm of testMB) {
      const b = tm[0];
      const expected = tm[1];
      assert.equal(
        human.bytes(b, human.MB),
        expected,
        `Input is ${b}, Unit is Megabytes`
      );
    }
  }

  it('should return human-readable bytes from bytes', testBytes);
});