import {Duration, PlainTime} from '@/';
import {describe, it, assert} from 'vitest';

let one = new PlainTime(15, 23, 30, 123);
let two = new PlainTime(14, 23, 30, 123);
let three = new PlainTime(13, 30, 30, 123);

let expected = [
  // Basic
  [one, two, 'PT1H'],
  [two, one, '-PT1H'],
  [one, three, 'PT1H53M'],
  [three, one, '-PT1H53M'],
] as [PlainTime, PlainTime, string][];

let fourFortyEight = new PlainTime(4, 48, 55);
let elevenFiftyNine = new PlainTime(11, 59, 58);

type PlainTypeDeltaParameters = Parameters<typeof PlainTime.prototype.since>[1];

let largestUnit = [
  [elevenFiftyNine, fourFortyEight, undefined, new Duration(0, 0, 0, 0, 7, 11, 3, 0)],
  [elevenFiftyNine, fourFortyEight, {largestUnit: 'auto'}, new Duration(0, 0, 0, 0, 7, 11, 3, 0)],
  [elevenFiftyNine, fourFortyEight, {largestUnit: 'hour'}, new Duration(0, 0, 0, 0, 7, 11, 3, 0)],
  [elevenFiftyNine, fourFortyEight, {largestUnit: 'minute'}, new Duration(0, 0, 0, 0, 0, 431, 3, 0)],
  [elevenFiftyNine, fourFortyEight, {largestUnit: 'second'}, new Duration(0, 0, 0, 0, 0, 0, 25863, 0)],
] as [PlainTime, PlainTime, PlainTypeDeltaParameters, Duration][];

let roundingIncrements: [PlainTypeDeltaParameters, Duration][] = [
  [{smallestUnit: 'minute', roundingIncrement: 1}, new Duration(0, 0, 0, 0, 10, 35, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 2}, new Duration(0, 0, 0, 0, 10, 34, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 3}, new Duration(0, 0, 0, 0, 10, 33, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 4}, new Duration(0, 0, 0, 0, 10, 32, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 5}, new Duration(0, 0, 0, 0, 10, 35, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 6}, new Duration(0, 0, 0, 0, 10, 30, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 10}, new Duration(0, 0, 0, 0, 10, 30, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 12}, new Duration(0, 0, 0, 0, 10, 24, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 15}, new Duration(0, 0, 0, 0, 10, 30, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 20}, new Duration(0, 0, 0, 0, 10, 20, 0, 0)],
  [{smallestUnit: 'minute', roundingIncrement: 30}, new Duration(0, 0, 0, 0, 10, 30, 0, 0)],
];

let roundingMode: [smallestUnit: 'minute' | 'hour' | 'second' | 'millisecond', 'floor', Duration, Duration][] = [
  ['hour', 'floor', new Duration(0, 0, 0, 0, 4), new Duration(0, 0, 0, 0, -5)],
  ['minute', 'floor', new Duration(0, 0, 0, 0, 4, 17), new Duration(0, 0, 0, 0, -4, -18)],
  ['second', 'floor', new Duration(0, 0, 0, 0, 4, 17, 4), new Duration(0, 0, 0, 0, -4, -17, -5)],
  ['millisecond', 'floor', new Duration(0, 0, 0, 0, 4, 17, 4, 864), new Duration(0, 0, 0, 0, -4, -17, -4, -864)],
];

describe('PlainTime', () => {
  describe('PlainTime#since', () => {
    it.each(expected)('diffs($0, $1) -> $2', (one, two, expected) => {
      let value = one.since(two);
      assert.deepEqual(value.toJSON(), expected);
    });

    describe('largestUnit', () => {
      it.each(largestUnit)('largestUnit($0, $1) -> $2', (one, two, options, expected) => {
        let value = one.since(two, options);
        assert.equal(value.toJSON(), expected.toJSON());
      });
    });

    describe('rounding increment', () => {
      it.each(roundingIncrements)('ronding increment', (options, expected) => {
        let earlier = new PlainTime(3, 12, 34, 123);
        let later = new PlainTime(13, 47, 57, 988);
        let duration = later.since(earlier, options);
        assert.equal(duration.toJSON(), expected.toJSON());
      });
    });

    describe('rounding mode', () => {
      it.each(roundingMode)('rounding mode: %j %j', (smallestUnit, roundingMode, expected, inverse) => {
        let earlier = new PlainTime(8, 22, 36, 123);
        let later = new PlainTime(12, 39, 40, 987);
        let duration = later.since(earlier, {smallestUnit, roundingMode});
        assert.equal(duration.toJSON(), expected.toJSON());

        let inverseDuration = earlier.since(later, {smallestUnit, roundingMode});
        assert.equal(inverseDuration.toJSON(), inverse.toJSON());
      });
    });

    it('round-cross-unit-boundary', () => {
      let earlier = new PlainTime();
      let later = new PlainTime(1, 59, 59);
      let duration = earlier.since(later, {largestUnit: 'hour', smallestUnit: 'minute', roundingMode: 'expand'});
      assert.equal(duration.toJSON(), new Duration(0, 0, 0, 0, -2, 0, 0, 0).toJSON());
    });
  });
});