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

let plainTime = new PlainTime(15, 23, 30, 123);

type PlainTypeDateComponents = Parameters<typeof PlainTime.prototype.with>[0];
type PlainTypeDateOptions = Parameters<typeof PlainTime.prototype.with>[1];

let expected = [
  [plainTime, {hour: 3}, undefined, new PlainTime(3, 23, 30, 123)],
  [plainTime, {minute: 3}, undefined, new PlainTime(15, 3, 30, 123)],
  [plainTime, {second: 3}, undefined, new PlainTime(15, 23, 3, 123)],
  [plainTime, {millisecond: 3}, undefined, new PlainTime(15, 23, 30, 3)],

  [plainTime, {millisecond: 1000}, undefined, new PlainTime(15, 23, 30, 999)],
  [plainTime, {millisecond: -1}, undefined, new PlainTime(15, 23, 30, 0)],

  [plainTime, {second: 60}, undefined, new PlainTime(15, 23, 59, 123)],
  [plainTime, {second: -1}, undefined, new PlainTime(15, 23, 0, 123)],

  [plainTime, {minute: 60}, undefined, new PlainTime(15, 59, 30, 123)],
  [plainTime, {minute: -1}, undefined, new PlainTime(15, 0, 30, 123)],

  [plainTime, {hour: 24}, undefined, new PlainTime(23, 23, 30, 123)],
  [plainTime, {hour: -1}, undefined, new PlainTime(0, 23, 30, 123)],
] as [PlainTime, PlainTypeDateComponents, PlainTypeDateOptions, PlainTime][];

let invalidCases = [
  [plainTime, {millisecond: 1000}, {overflow: 'reject'}],
  [plainTime, {millisecond: -1}, {overflow: 'reject'}],

  [plainTime, {second: 60}, {overflow: 'reject'}],
  [plainTime, {second: -1}, {overflow: 'reject'}],

  [plainTime, {minute: 60}, {overflow: 'reject'}],
  [plainTime, {minute: -1}, {overflow: 'reject'}],

  [plainTime, {hour: 24}, {overflow: 'reject'}],
  [plainTime, {hour: -1}, {overflow: 'reject'}],
] as [PlainTime, PlainTypeDateComponents, PlainTypeDateOptions][];

describe('PlainTime', () => {
  describe('PlainTime#with', () => {
    it.each(expected)('%j.with(%j, %j) -> %j', (plainTime, components, options, expects) => {
      let time = plainTime.with(components, options);
      assert.ok(time.equals(expects));
    });

    it.each(invalidCases)('%j.with(%j, %j) throws', (plainTime, components, options) => {
      assert.throws(() => {
        plainTime.with(components, options);
      });
    });
  });
});