import { Case, Grammeme, NounGrams, Plurality, VerbGrams } from './language';
import {
  getCompatibleGrams,
  grammemeCompare,
  parseEntityReference,
  parseGrammemes,
  parseSyntacticReference,
  wordFormEquals
} from './languageAPI';

describe('Testing wordform equality', () => {
  test('empty input', () => {
    expect(wordFormEquals({ text: '', grams: [] }, { text: '', grams: [] })).toEqual(true);
    expect(wordFormEquals({ text: '', grams: [] }, { text: '11', grams: [] })).toEqual(true);
    expect(wordFormEquals({ text: '11', grams: [] }, { text: '', grams: [] })).toEqual(true);
    expect(wordFormEquals({ text: '11', grams: [] }, { text: '42', grams: [] })).toEqual(true);
    expect(wordFormEquals({ text: '', grams: ['nomn'] }, { text: '', grams: [] })).toEqual(false);
    expect(wordFormEquals({ text: '11', grams: ['nomn'] }, { text: '11', grams: [] })).toEqual(false);
    expect(wordFormEquals({ text: '', grams: [] }, { text: '', grams: ['nomn'] })).toEqual(false);
    expect(wordFormEquals({ text: '11', grams: [] }, { text: '11', grams: ['nomn'] })).toEqual(false);
  });

  test('regular grammemes', () => {
    expect(wordFormEquals({ text: '', grams: ['nomn'] }, { text: '', grams: ['nomn'] })).toEqual(true);
    expect(wordFormEquals({ text: '', grams: ['nomn'] }, { text: '', grams: ['sing'] })).toEqual(false);
    expect(wordFormEquals({ text: '', grams: ['nomn', 'sing'] }, { text: '', grams: ['nomn', 'sing'] })).toEqual(true);
    expect(wordFormEquals({ text: '', grams: ['nomn', 'sing'] }, { text: '11', grams: ['nomn', 'sing'] })).toEqual(
      true
    );
    expect(wordFormEquals({ text: '11', grams: ['nomn', 'sing'] }, { text: '', grams: ['nomn', 'sing'] })).toEqual(
      true
    );
    expect(wordFormEquals({ text: '11', grams: ['nomn', 'sing'] }, { text: '11', grams: ['nomn', 'sing'] })).toEqual(
      true
    );
    expect(wordFormEquals({ text: '42', grams: ['nomn', 'sing'] }, { text: '11', grams: ['nomn', 'sing'] })).toEqual(
      true
    );
    expect(wordFormEquals({ text: '', grams: ['nomn', 'sing'] }, { text: '', grams: ['sing', 'nomn'] })).toEqual(false);
    expect(wordFormEquals({ text: '', grams: ['nomn', 'sing'] }, { text: '', grams: ['nomn'] })).toEqual(false);
    expect(wordFormEquals({ text: '', grams: ['nomn', 'nomn'] }, { text: '', grams: ['nomn'] })).toEqual(false);
  });

  test('custom grammemes', () => {
    expect(wordFormEquals({ text: '', grams: ['с1'] }, { text: '', grams: ['с1'] })).toEqual(true);
    expect(wordFormEquals({ text: '', grams: ['с1'] }, { text: '', grams: ['с2'] })).toEqual(false);
    expect(wordFormEquals({ text: '', grams: ['sing'] }, { text: '', grams: ['с1'] })).toEqual(false);
  });
});

describe('Testing grammeme ordering', () => {
  test('empty input', () => {
    expect(grammemeCompare('', '')).toEqual(0);
    expect(grammemeCompare(' ', ' ')).toEqual(0);
    expect(grammemeCompare('', '123')).toBeLessThan(0);
    expect(grammemeCompare('123', '')).toBeGreaterThan(0);
  });

  test('regular grammemes', () => {
    expect(grammemeCompare('NOUN', 'NOUN')).toEqual(0);
    expect(grammemeCompare('NOUN', Grammeme.NOUN)).toEqual(0);

    expect(grammemeCompare(Grammeme.sing, Grammeme.plur)).toBeLessThan(0);
    expect(grammemeCompare('sing', 'plur')).toBeLessThan(0);
    expect(grammemeCompare('plur', 'sing')).toBeGreaterThan(0);

    expect(grammemeCompare('NOUN', 'ADJF')).toBeLessThan(0);
    expect(grammemeCompare('ADJF', 'NOUN')).toBeGreaterThan(0);
    expect(grammemeCompare('ADJS', 'NOUN')).toBeGreaterThan(0);
    expect(grammemeCompare('ADJS', 'ADJF')).toBeGreaterThan(0);

    expect(grammemeCompare('loct', 'ablt')).toBeGreaterThan(0);
    expect(grammemeCompare('ablt', 'accs')).toBeGreaterThan(0);
    expect(grammemeCompare('accs', 'datv')).toBeGreaterThan(0);
    expect(grammemeCompare('datv', 'gent')).toBeGreaterThan(0);
    expect(grammemeCompare('gent', 'nomn')).toBeGreaterThan(0);
  });

  test('custom grammemes', () => {
    expect(grammemeCompare('noun', 'noun')).toEqual(0);
    expect(grammemeCompare('NOUN', 'noun')).toBeLessThan(0);
    expect(grammemeCompare('PRTF', 'noun')).toBeLessThan(0);
    expect(grammemeCompare('noun', 'NOUN')).toBeGreaterThan(0);
    expect(grammemeCompare('aab', 'aaa')).toBeGreaterThan(0);
    expect(grammemeCompare('aaa', 'aab')).toBeLessThan(0);
    expect(grammemeCompare('test', 'abcd')).toBeGreaterThan(0);
  });
});

describe('Testing grammeme parsing', () => {
  test('empty input', () => {
    expect(parseGrammemes('')).toStrictEqual([]);
    expect(parseGrammemes(' ')).toStrictEqual([]);
    expect(parseGrammemes(' , ')).toStrictEqual([]);
  });

  test('regular grammemes', () => {
    expect(parseGrammemes('NOUN')).toStrictEqual([Grammeme.NOUN]);
    expect(parseGrammemes('sing,nomn')).toStrictEqual([Grammeme.sing, Grammeme.nomn]);
    expect(parseGrammemes('nomn,sing')).toStrictEqual([Grammeme.sing, Grammeme.nomn]);
  });

  test('custom grammemes', () => {
    expect(parseGrammemes('nomn,invalid,sing')).toStrictEqual([Grammeme.sing, Grammeme.nomn, 'invalid']);
    expect(parseGrammemes('invalid,test')).toStrictEqual(['invalid', 'test']);
  });
});

describe('Testing grammeme compatibility', () => {
  test('empty input', () => {
    expect(getCompatibleGrams([])).toStrictEqual([...VerbGrams, ...NounGrams]);
  });

  test('regular grammemes', () => {
    expect(getCompatibleGrams([Grammeme.NOUN])).toStrictEqual([...Case, ...Plurality]);
  });
});

describe('Testing reference parsing', () => {
  test('entity reference', () => {
    expect(parseEntityReference('@{ X1 | NOUN,sing }')).toStrictEqual({ entity: 'X1', form: 'NOUN,sing' });
    expect(parseEntityReference('@{X1|NOUN,sing}')).toStrictEqual({ entity: 'X1', form: 'NOUN,sing' });
    expect(parseEntityReference('@{X111|NOUN,sing}')).toStrictEqual({ entity: 'X111', form: 'NOUN,sing' });
  });

  test('syntactic reference', () => {
    expect(parseSyntacticReference('@{1|test test}')).toStrictEqual({ offset: 1, nominal: 'test test' });
    expect(parseSyntacticReference('@{101|test test}')).toStrictEqual({ offset: 101, nominal: 'test test' });
    expect(parseSyntacticReference('@{-1|test test}')).toStrictEqual({ offset: -1, nominal: 'test test' });
    expect(parseSyntacticReference('@{-99|test test}')).toStrictEqual({ offset: -99, nominal: 'test test' });
  });
});