import { describe, expect, it } from '@jest/globals';
import { Term, _, g, n, undef } from '../src/core';
import { toNOrd as $o, NOrd } from '../src/ord';
import { toBoolean as $b, fromBoolean as _b } from '../src/bool';
import { toNumber as $n, Succ, Zero, fromNumber as _n, cmp, div, eq, ge, gt, ifz, le, lt, mod, mul, pred, sub, succ, sum } from '../src/num';
import { toString as $s } from '../src/string';
import { show } from '../src/num.show';

n('num.spec');

describe('Num', () => {
  const infinity: Term = g('infinity', _(() => Succ._(infinity)));

  describe('toNumber', () => {
    it('converts 0', () => {
      expect($n(Zero)).toBe(0);
    });

    it('converts 1', () => {
      expect($n(Succ._(Zero))).toBe(1);
    });

    it('converts 2', () => {
      expect($n(Succ._(Succ._(Zero)))).toBe(2);
    });
  });

  describe('fromNumber', () => {
    it('converts 0', () => {
      expect($n(_n(0))).toBe(0);
    });

    it('converts 1', () => {
      expect($n(_n(1))).toBe(1);
    });

    it('converts 2', () => {
      expect($n(_n(2))).toBe(2);
    });
  });

  describe('ifz', () => {
    it('returns zero branch', () => {
      expect($b(ifz._(_n(0))._(_b(true))._(_b(false)))).toBe(true);
    });

    it('returns non-zero branch', () => {
      expect($b(ifz._(_n(1))._(_b(true))._(_b(false)))).toBe(false);
    });

    it('returns non-zero branch', () => {
      expect($b(ifz._(_n(10))._(_b(true))._(_b(false)))).toBe(false);
    });

    it('handles infinity', () => {
      expect($b(ifz._(infinity)._(_b(true))._(_b(false)))).toBe(false);
    });
  });

  describe('succ', () => {
    it('succ 0 is 1', () => {
      expect($n(succ._(_n(0)))).toBe(1);
    });

    it('succ 1 is 2', () => {
      expect($n(succ._(_n(1)))).toBe(2);
    });

    it('succ 10 is 11', () => {
      expect($n(succ._(_n(10)))).toBe(11);
    });
  });

  describe('pred', () => {
    it('pred 0 is 0', () => {
      expect($n(pred._(_n(0)))).toBe(0);
    });

    it('pred 1 is 0', () => {
      expect($n(pred._(_n(1)))).toBe(0);
    });

    it('pred 10 is 9', () => {
      expect($n(pred._(_n(10)))).toBe(9);
    });
  });

  describe('cmp', () => {
    it('0 cmp 0 is EQ', () => {
      expect($o(cmp._(_n(0))._(_n(0)))).toBe(NOrd.EQ);
    });

    it('0 cmp 1 is LT', () => {
      expect($o(cmp._(_n(0))._(_n(1)))).toBe(NOrd.LT);
    });

    it('1 cmp 0 is GT', () => {
      expect($o(cmp._(_n(1))._(_n(0)))).toBe(NOrd.GT);
    });

    it('3 cmp 3 is EQ', () => {
      expect($o(cmp._(_n(3))._(_n(3)))).toBe(NOrd.EQ);
    });

    it('3 cmp 7 is LT', () => {
      expect($o(cmp._(_n(3))._(_n(7)))).toBe(NOrd.LT);
    });

    it('7 cmp 3 is GT', () => {
      expect($o(cmp._(_n(7))._(_n(3)))).toBe(NOrd.GT);
    });

    it('handles infinity', () => {
      expect($o(cmp._(_n(7))._(infinity))).toBe(NOrd.LT);
      expect($o(cmp._(infinity)._(_n(7)))).toBe(NOrd.GT);
    });
  });

  describe('lt', () => {
    it('0 lt 0 is False', () => {
      expect($b(lt._(_n(0))._(_n(0)))).toBe(false);
    });

    it('0 lt 1 is True', () => {
      expect($b(lt._(_n(0))._(_n(1)))).toBe(true);
    });

    it('1 lt 0 is False', () => {
      expect($b(lt._(_n(1))._(_n(0)))).toBe(false);
    });

    it('3 lt 3 is False', () => {
      expect($b(lt._(_n(3))._(_n(3)))).toBe(false);
    });

    it('3 lt 7 is True', () => {
      expect($b(lt._(_n(3))._(_n(7)))).toBe(true);
    });

    it('7 lt 3 is False', () => {
      expect($b(lt._(_n(7))._(_n(3)))).toBe(false);
    });

    it('handles infinity', () => {
      expect($b(lt._(_n(7))._(infinity))).toBe(true);
      expect($b(lt._(infinity)._(_n(7)))).toBe(false);
    });
  });

  describe('le', () => {
    it('0 le 0 is True', () => {
      expect($b(le._(_n(0))._(_n(0)))).toBe(true);
    });

    it('0 le 1 is True', () => {
      expect($b(le._(_n(0))._(_n(1)))).toBe(true);
    });

    it('1 le 0 is False', () => {
      expect($b(le._(_n(1))._(_n(0)))).toBe(false);
    });

    it('3 le 3 is True', () => {
      expect($b(le._(_n(3))._(_n(3)))).toBe(true);
    });

    it('3 le 7 is True', () => {
      expect($b(le._(_n(3))._(_n(7)))).toBe(true);
    });

    it('7 le 3 is False', () => {
      expect($b(le._(_n(7))._(_n(3)))).toBe(false);
    });

    it('handles infinity', () => {
      expect($b(le._(_n(7))._(infinity))).toBe(true);
      expect($b(le._(infinity)._(_n(7)))).toBe(false);
    });
  });

  describe('eq', () => {
    it('0 eq 0 is True', () => {
      expect($b(eq._(_n(0))._(_n(0)))).toBe(true);
    });

    it('0 eq 1 is False', () => {
      expect($b(eq._(_n(0))._(_n(1)))).toBe(false);
    });

    it('1 eq 0 is False', () => {
      expect($b(eq._(_n(1))._(_n(0)))).toBe(false);
    });

    it('3 eq 3 is True', () => {
      expect($b(eq._(_n(3))._(_n(3)))).toBe(true);
    });

    it('3 eq 7 is False', () => {
      expect($b(eq._(_n(3))._(_n(7)))).toBe(false);
    });

    it('7 eq 3 is False', () => {
      expect($b(eq._(_n(7))._(_n(3)))).toBe(false);
    });

    it('handles infinity', () => {
      expect($b(eq._(_n(7))._(infinity))).toBe(false);
      expect($b(eq._(infinity)._(_n(7)))).toBe(false);
    });
  });

  describe('ge', () => {
    it('0 ge 0 is True', () => {
      expect($b(ge._(_n(0))._(_n(0)))).toBe(true);
    });

    it('0 ge 1 is False', () => {
      expect($b(ge._(_n(0))._(_n(1)))).toBe(false);
    });

    it('1 ge 0 is True', () => {
      expect($b(ge._(_n(1))._(_n(0)))).toBe(true);
    });

    it('3 ge 3 is True', () => {
      expect($b(ge._(_n(3))._(_n(3)))).toBe(true);
    });

    it('3 ge 7 is False', () => {
      expect($b(ge._(_n(3))._(_n(7)))).toBe(false);
    });

    it('7 ge 3 is True', () => {
      expect($b(ge._(_n(7))._(_n(3)))).toBe(true);
    });

    it('handles infinity', () => {
      expect($b(ge._(_n(7))._(infinity))).toBe(false);
      expect($b(ge._(infinity)._(_n(7)))).toBe(true);
    });
  });

  describe('gt', () => {
    it('0 gt 0 is False', () => {
      expect($b(gt._(_n(0))._(_n(0)))).toBe(false);
    });

    it('0 gt 1 is False', () => {
      expect($b(gt._(_n(0))._(_n(1)))).toBe(false);
    });

    it('1 gt 0 is True', () => {
      expect($b(gt._(_n(1))._(_n(0)))).toBe(true);
    });

    it('3 gt 3 is False', () => {
      expect($b(gt._(_n(3))._(_n(3)))).toBe(false);
    });

    it('3 gt 7 is False', () => {
      expect($b(gt._(_n(3))._(_n(7)))).toBe(false);
    });

    it('7 gt 3 is True', () => {
      expect($b(gt._(_n(7))._(_n(3)))).toBe(true);
    });

    it('handles infinity', () => {
      expect($b(gt._(_n(7))._(infinity))).toBe(false);
      expect($b(gt._(infinity)._(_n(7)))).toBe(true);
    });
  });

  describe('sum', () => {
    it('0 sum 0 is 0', () => {
      expect($n(sum._(_n(0))._(_n(0)))).toBe(0);
    });

    it('0 sum 1 is 1', () => {
      expect($n(sum._(_n(0))._(_n(1)))).toBe(1);
    });

    it('1 sum 0 is 1', () => {
      expect($n(sum._(_n(1))._(_n(0)))).toBe(1);
    });

    it('3 sum 4 is 7', () => {
      expect($n(sum._(_n(3))._(_n(4)))).toBe(7);
    });
  });

  describe('sub', () => {
    it('0 sub 0 is 0', () => {
      expect($n(sub._(_n(0))._(_n(0)))).toBe(0);
    });

    it('0 sub 1 is 0', () => {
      expect($n(sub._(_n(0))._(_n(1)))).toBe(0);
    });

    it('1 sub 0 is 1', () => {
      expect($n(sub._(_n(1))._(_n(0)))).toBe(1);
    });

    it('7 sub 4 is 3', () => {
      expect($n(sub._(_n(7))._(_n(4)))).toBe(3);
    });
  });

  describe('mul', () => {
    it('0 mul 0 is 0', () => {
      expect($n(mul._(_n(0))._(_n(0)))).toBe(0);
    });

    it('0 mul 10 is 0', () => {
      expect($n(mul._(_n(0))._(_n(10)))).toBe(0);
    });

    it('10 mul 0 is 0', () => {
      expect($n(mul._(_n(1))._(_n(0)))).toBe(0);
    });

    it('1 mul 10 is 10', () => {
      expect($n(mul._(_n(1))._(_n(10)))).toBe(10);
    });

    it('10 mul 1 is 10', () => {
      expect($n(mul._(_n(10))._(_n(1)))).toBe(10);
    });

    it('3 mul 4 is 12', () => {
      expect($n(mul._(_n(3))._(_n(4)))).toBe(12);
    });

    it('0 mul ignores second argument', () => {
      expect($n(mul._(_n(0))._(undef))).toBe(0);
    });
  });

  describe('div', () => {
    it('0 div 10 is 0', () => {
      expect($n(div._(_n(0))._(_n(10)))).toBe(0);
    });

    it('1 div 10 is 0', () => {
      expect($n(div._(_n(1))._(_n(10)))).toBe(0);
    });

    it('10 div 1 is 10', () => {
      expect($n(div._(_n(10))._(_n(1)))).toBe(10);
    });

    it('10 div 5 is 2', () => {
      expect($n(div._(_n(10))._(_n(5)))).toBe(2);
    });

    it('10 div 3 is 3', () => {
      expect($n(div._(_n(10))._(_n(3)))).toBe(3);
    });

    it.failing('0 div ignores second argument', () => {
      expect($n(div._(_n(0))._(undef))).toBe(0);
    });
  });

  describe('mod', () => {
    it('0 mod 10 is 0', () => {
      expect($n(mod._(_n(0))._(_n(10)))).toBe(0);
    });

    it('1 mod 10 is 1', () => {
      expect($n(mod._(_n(1))._(_n(10)))).toBe(1);
    });

    it('10 mod 1 is 0', () => {
      expect($n(mod._(_n(10))._(_n(1)))).toBe(0);
    });

    it('10 mod 5 is 0', () => {
      expect($n(mod._(_n(10))._(_n(5)))).toBe(0);
    });

    it('10 mod 3 is 1', () => {
      expect($n(mod._(_n(10))._(_n(3)))).toBe(1);
    });

    it.failing('0 mod ignores second argument', () => {
      expect($n(mod._(_n(0))._(undef))).toBe(0);
    });
  });

  describe('show', () => {
    it('show 0 is "0"', () => {
      expect($s(show._(_n(0)))).toBe('0');
    });

    it('show 1 is "1"', () => {
      expect($s(show._(_n(1)))).toBe('1');
    });

    it('show 255 is "255"', () => {
      expect($s(show._(_n(255)))).toBe('255');
    });

    it('show 1000 is "1000"', () => {
      expect($s(show._(_n(1000)))).toBe('1000');
    });
  });
});