import { describe, expect, it } from '@jest/globals';
import { L, _, ___, undef } from '../src/core';
import { NOrd, toNOrd } from '../src/ord';
import { toBoolean as $b } from '../src/bool';
import { toNumber as $n, Zero, gt as ngt } from '../src/num';
import { toChar as $c, fromChar as _c } from '../src/char';
import { toString as $s, Cons, Empty, String, fromString as _s, append, cmp, empty, eq, ge, gt, le, len, lt, show, wrap } from '../src/string';

describe('String', () => {
  const infinite: String = Cons(_c('a'))(___(() => infinite.run()));

  describe('toString', () => {
    it('converts ""', () => {
      expect($s(Empty)).toBe('');
    });

    it('converts "a"', () => {
      expect($s(Cons(_c('a'))(Empty))).toBe('a');
    });

    it('converts "abc"', () => {
      expect($s(Cons(_c('a'))(Cons(_c('b'))(Cons(_c('c'))(Empty))))).toBe('abc');
    });
  });

  describe('fromString', () => {
    it('converts ""', () => {
      expect($s(_s(''))).toBe('');
    });

    it('converts "a"', () => {
      expect($s(_s('a'))).toBe('a');
    });

    it('converts "2"', () => {
      expect($s(_s('abc'))).toBe('abc');
    });
  });

 // describe('repeat', () => {
  //   it('repeat "a" is "aaa..."', () => {
  //     expect($na(
  //       repeat(_s('a'))<String>(_((x0: Char) => _((x1s: String) =>
  //         x1s<String>(_((x1: Char) => _((x2s: String) =>
  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('aaa');
  //   });
  // });

  // describe('iterate', () => {
  //   it('iterate succ "a" is "abc..."', () => {
  //     expect($na(
  //       iterate(_s('a'))<String>(_((x0: Char) => _((x1s: String) =>
  //         x1s<String>(_((x1: Char) => _((x2s: String) =>
  //           x2s<String>(_((x2: Char) => _((_xrs: String): String => cons(x0)(cons(x1)(cons(x2)(Nil)))))))))))))).toEqual('abc');
  //   });
  // });


  describe('empty', () => {
    it('empty "" is True', () => {
      expect($b(empty(_s('')))).toEqual(true);
    });

    it('empty "a" is False', () => {
      expect($b(empty(_s('a')))).toEqual(false);
    });

    it('empty "ab" is False', () => {
      expect($b(empty(_s('ab')))).toEqual(false);
    });

    it('handles infinite lists', () => {
      expect($b(empty(infinite))).toEqual(false);
    });
  });

  describe('len', () => {
    it('len "" is 0', () => {
      expect($n(len(_s('')))).toEqual(0);
    });

    it('len "a" is 1', () => {
      expect($n(len(_s('a')))).toEqual(1);
    });

    it('len "ab" is 2', () => {
      expect($n(len(_s('ab')))).toEqual(2);
    });

    it('handles infinite lists', () => {
      expect($b(ngt(len(infinite))(Zero))).toEqual(true);
    });
  });

  describe('append', () => {
    it('"" append "" is ""', () => {
      expect($s(append(Empty)(Empty))).toBe('');
    });

    it('"a" append "b" is "ab"', () => {
      expect($s(append(_s('a'))(_s('b')))).toBe('ab');
    });

    it('"abc" append "def" is "abcdef"', () => {
      expect($s(append(_s('abc'))(_s('def')))).toBe('abcdef');
    });

    it('handles infinite strings', () => {
      expect($c(append(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a');
    });
  });

  describe('wrap', () => {
    it('"" wrap "" is ""', () => {
      expect($s(wrap(Empty)(Empty))).toBe('');
    });

    it('"a" wrap "b" is "aba"', () => {
      expect($s(wrap(_s('a'))(_s('b')))).toBe('aba');
    });

    it('handles infinite strings', () => {
      expect($c(wrap(infinite)(infinite)(undef)(_(x => _(_xs => x))))).toBe('a');
    });
  });

  describe('cmp', () => {
    it('"" cmp "" is EQ', () => {
      expect(toNOrd(cmp(_s(''))(_s('')))).toEqual(NOrd.EQ);
    });

    it('"" cmp "abc" is LT', () => {
      expect(toNOrd(cmp(_s(''))(_s('abc')))).toEqual(NOrd.LT);
    });

    it('"abc" cmp "" is GT', () => {
      expect(toNOrd(cmp(_s('abc'))(_s('')))).toEqual(NOrd.GT);
    });

    it('"a" cmp "abc" is LT', () => {
      expect(toNOrd(cmp(_s('a'))(_s('abc')))).toEqual(NOrd.LT);
    });

    it('"abc" cmp "a" is GT', () => {
      expect(toNOrd(cmp(_s('abc'))(_s('a')))).toEqual(NOrd.GT);
    });

    it('"bca" cmp "abc" is GT', () => {
      expect(toNOrd(cmp(_s('bca'))(_s('abc')))).toEqual(NOrd.GT);
    });

    it('"abc" cmp "bca" is LT', () => {
      expect(toNOrd(cmp(_s('abc'))(_s('bca')))).toEqual(NOrd.LT);
    });

    it('"abc" cmp "abc" is EQ', () => {
      expect(toNOrd(cmp(_s('abc'))(_s('abc')))).toEqual(NOrd.EQ);
    });

    it('handles infinite strings', () => {
      expect(toNOrd(cmp(_s('abc'))(infinite))).toEqual(NOrd.GT);
      expect(toNOrd(cmp(infinite)(_s('abc')))).toEqual(NOrd.LT);
    });
  });

  describe('lt', () => {
    it('"" lt "" is False', () => {
      expect($b(lt(_s(''))(_s('')))).toEqual(false);
    });

    it('"" lt "abc" is True', () => {
      expect($b(lt(_s(''))(_s('abc')))).toEqual(true);
    });

    it('"abc" lt "" is False', () => {
      expect($b(lt(_s('abc'))(_s('')))).toEqual(false);
    });

    it('"a" lt "abc" is True', () => {
      expect($b(lt(_s('a'))(_s('abc')))).toEqual(true);
    });

    it('"abc" lt "a" is False', () => {
      expect($b(lt(_s('abc'))(_s('a')))).toEqual(false);
    });

    it('"bca" lt "abc" is False', () => {
      expect($b(lt(_s('bca'))(_s('abc')))).toEqual(false);
    });

    it('"abc" lt "bca" is True', () => {
      expect($b(lt(_s('abc'))(_s('bca')))).toEqual(true);
    });

    it('"abc" lt "abc" is False', () => {
      expect($b(lt(_s('abc'))(_s('abc')))).toEqual(false);
    });

    it('handles infinite strings', () => {
      expect($b(lt(_s('abc'))(infinite))).toEqual(false);
      expect($b(lt(infinite)(_s('abc')))).toEqual(true);
    });
  });

  describe('le', () => {
    it('"" le "" is True', () => {
      expect($b(le(_s(''))(_s('')))).toEqual(true);
    });

    it('"" le "abc" is True', () => {
      expect($b(le(_s(''))(_s('abc')))).toEqual(true);
    });

    it('"abc" le "" is False', () => {
      expect($b(le(_s('abc'))(_s('')))).toEqual(false);
    });

    it('"a" le "abc" is True', () => {
      expect($b(le(_s('a'))(_s('abc')))).toEqual(true);
    });

    it('"abc" le "a" is False', () => {
      expect($b(le(_s('abc'))(_s('a')))).toEqual(false);
    });

    it('"bca" le "abc" is False', () => {
      expect($b(le(_s('bca'))(_s('abc')))).toEqual(false);
    });

    it('"abc" le "bca" is True', () => {
      expect($b(le(_s('abc'))(_s('bca')))).toEqual(true);
    });

    it('"abc" le "abc" is True', () => {
      expect($b(le(_s('abc'))(_s('abc')))).toEqual(true);
    });

    it('handles infinite strings', () => {
      expect($b(le(_s('abc'))(infinite))).toEqual(false);
      expect($b(le(infinite)(_s('abc')))).toEqual(true);
    });
  });

  describe('eq', () => {
    it('"" eq "" is True', () => {
      expect($b(eq(_s(''))(_s('')))).toEqual(true);
    });

    it('"" eq "abc" is False', () => {
      expect($b(eq(_s(''))(_s('abc')))).toEqual(false);
    });

    it('"abc" eq "" is False', () => {
      expect($b(eq(_s('abc'))(_s('')))).toEqual(false);
    });

    it('"a" eq "abc" is False', () => {
      expect($b(eq(_s('a'))(_s('abc')))).toEqual(false);
    });

    it('"abc" eq "a" is False', () => {
      expect($b(eq(_s('abc'))(_s('a')))).toEqual(false);
    });

    it('"bca" eq "abc" is False', () => {
      expect($b(eq(_s('bca'))(_s('abc')))).toEqual(false);
    });

    it('"abc" eq "bca" is False', () => {
      expect($b(eq(_s('abc'))(_s('bca')))).toEqual(false);
    });

    it('"abc" eq "abc" is True', () => {
      expect($b(eq(_s('abc'))(_s('abc')))).toEqual(true);
    });

    it('handles infinite strings', () => {
      expect($b(eq(_s('abc'))(infinite))).toEqual(false);
      expect($b(eq(infinite)(_s('abc')))).toEqual(false);
    });
  });

  describe('ge', () => {
    it('"" ge "" is True', () => {
      expect($b(ge(_s(''))(_s('')))).toEqual(true);
    });

    it('"" ge "abc" is False', () => {
      expect($b(ge(_s(''))(_s('abc')))).toEqual(false);
    });

    it('"abc" ge "" is True', () => {
      expect($b(ge(_s('abc'))(_s('')))).toEqual(true);
    });

    it('"a" ge "abc" is False', () => {
      expect($b(ge(_s('a'))(_s('abc')))).toEqual(false);
    });

    it('"abc" ge "a" is True', () => {
      expect($b(ge(_s('abc'))(_s('a')))).toEqual(true);
    });

    it('"bca" ge "abc" is True', () => {
      expect($b(ge(_s('bca'))(_s('abc')))).toEqual(true);
    });

    it('"abc" ge "bca" is False', () => {
      expect($b(ge(_s('abc'))(_s('bca')))).toEqual(false);
    });

    it('"abc" ge "abc" is True', () => {
      expect($b(ge(_s('abc'))(_s('abc')))).toEqual(true);
    });

    it('handles infinite strings', () => {
      expect($b(ge(_s('abc'))(infinite))).toEqual(true);
      expect($b(ge(infinite)(_s('abc')))).toEqual(false);
    });
  });

  describe('gt', () => {
    it('"" gt "" is False', () => {
      expect($b(gt(_s(''))(_s('')))).toEqual(false);
    });

    it('"" gt "abc" is False', () => {
      expect($b(gt(_s(''))(_s('abc')))).toEqual(false);
    });

    it('"abc" gt "" is True', () => {
      expect($b(gt(_s('abc'))(_s('')))).toEqual(true);
    });

    it('"a" gt "abc" is False', () => {
      expect($b(gt(_s('a'))(_s('abc')))).toEqual(false);
    });

    it('"abc" gt "a" is True', () => {
      expect($b(gt(_s('abc'))(_s('a')))).toEqual(true);
    });

    it('"bca" gt "abc" is True', () => {
      expect($b(gt(_s('bca'))(_s('abc')))).toEqual(true);
    });

    it('"abc" gt "bca" is False', () => {
      expect($b(gt(_s('abc'))(_s('bca')))).toEqual(false);
    });

    it('"abc" gt "abc" is False', () => {
      expect($b(gt(_s('abc'))(_s('abc')))).toEqual(false);
    });

    it('handles infinite strings', () => {
      expect($b(gt(_s('abc'))(infinite))).toEqual(true);
      expect($b(gt(infinite)(_s('abc')))).toEqual(false);
    });
  });

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

    it('show "a" is ""a""', () => {
      expect($s(show(_s('a')))).toBe('"a"');
    });

    it('show "abc" is ""abc""', () => {
      expect($s(show(_s('abc')))).toBe('"abc"');
    });
  });
});