import { find } from '../Array';
import {
  isSome,
  isNone,
  fromUndefinedable,
  fromNullable,
  some,
  none,
  fromNillable,
  toNullable,
  toUndefinedable,
  map,
  flatMap,
  getOrElse,
} from '../Option';

describe('isSome', () => {
  it('returns true when value is something', () => {
    expect(isSome(find((num: number) => num % 2 === 0)([0]))).toBe(true);
  });

  it('returns false when value is none', () => {
    expect(isSome(find((num: number) => num % 2 === 1)([0]))).toBe(false);
  });
});

describe('isNone', () => {
  it('returns false when value is something', () => {
    expect(isNone(find((num: number) => num % 2 === 0)([0]))).toBe(false);
  });

  it('returns true when value is none', () => {
    expect(isNone(find((num: number) => num % 2 === 1)([0]))).toBe(true);
  });
});

describe('fromUndefinedable', () => {
  it('returns some when value is not undefined', () => {
    expect(fromUndefinedable(1)).toEqual(some(1));
    expect(fromUndefinedable(null)).toEqual(some(null));
  });

  it('returns none when value is undefined', () => {
    expect(fromUndefinedable(undefined)).toEqual(none);
  });
});

describe('fromNullable', () => {
  it('returns some when value is not null', () => {
    expect(fromNullable(1)).toEqual(some(1));
    expect(fromNullable(undefined)).toEqual(some(undefined));
  });

  it('returns none when value is null', () => {
    expect(fromNullable(null)).toEqual(none);
  });
});

describe('fromNillable', () => {
  it('returns some when value is not null nor nill', () => {
    expect(fromNillable(1)).toEqual(some(1));
    expect(fromNillable(true)).toEqual(some(true));
  });

  it('returns none when value is either null or undefined', () => {
    expect(fromNillable(null)).toEqual(none);
    expect(fromNillable(undefined)).toEqual(none);
  });
});

describe('toNullable', () => {
  it('returns value when value is something', () => {
    expect(toNullable(some(1))).toBe(1);
  });

  it('returns null when value is none', () => {
    expect(toNullable(none)).toBe(null);
  });
});

describe('toUndefinedable', () => {
  it('returns value when value is something', () => {
    expect(toUndefinedable(some(1))).toBe(1);
  });

  it('returns null when value is none', () => {
    expect(toUndefinedable(none)).toBe(undefined);
  });
});

describe('map', () => {
  it('performs function when value is not none', () => {
    expect(map((a: number) => a + 1)(some(1))).toEqual(some(2));
  });

  it('returns none when value is none', () => {
    expect(map((a: number) => a + 1)(none)).toEqual(none);
  });
});

describe('flatMap', () => {
  it('flattens result when function return optional value', () => {
    expect(flatMap((a: number) => some(a + 1))(some(1))).toEqual(some(2));
  });

  it('returns none when function passed return none', () => {
    expect(flatMap((_a: number) => none)(some(1))).toEqual(none);
  });

  it('returns none when input of flatmap is none', () => {
    expect(flatMap((a: number) => some(a + 1))(none)).toEqual(none);
  });
});

describe('getOrElse', () => {
  it('return inner value when it is something', () => {
    expect(getOrElse(() => 0)(some(1))).toBe(1);
  });

  it('return default value when it is none', () => {
    expect(getOrElse(() => 0)(none)).toBe(0);
  });
});