import { Expression } from '../dist/expression.js';
import { Evaluator } from '../dist/main.js';

describe('Evaluator', () => {
    it('should have logger', () => {
        expect(new Evaluator().logger).toBeTruthy();
        expect(new Evaluator(null).logger).toBeTruthy();
        expect(new Evaluator({}).logger).toBeTruthy();
    });

    describe('can evaluate choices', () => {
        const e = new Evaluator();

        it('on logical type', () => {
            const c0 = e.evaluateChoices({ type: 'logical', value: null as never }, null);
            expect(c0.length).toBe(2);
            expect(c0[0].key).toBe(false);
            expect(c0[1].key).toBe(true);

            const c1 = e.evaluateChoices(
                {
                    type: 'logical',
                    // @ts-expect-error Incomplete choice definition
                    choices: [{}, { key: true, name: 'Yes', condition: false }],
                    value: null as never,
                },
                null,
            );
            expect(c1.length).toBe(2);
            expect(c1[0].key).toBe(false);
            expect(c1[1].key).toBe(true);
            expect(c1[0].name).toBe('');
            expect(c1[1].name).toBe('Yes');
            expect(c1[1].condition).toBe(false);

            const c2 = e.evaluateChoices(
                {
                    type: 'logical',
                    // @ts-expect-error Incomplete choice definition
                    choices: [{ key: 0, condition: true }, { key: '1', condition: null }, { key: 2 }],
                    value: null as never,
                },
                null,
            );
            expect(c2.length).toBe(2);
            expect(c2[0].key).toBe(0);
            expect(c2[1].key).toBe(1);
            expect(c2[0].condition).toBe(true);
            expect(c2[1].condition).toBe(undefined);

            const c3 = e.evaluateChoices({ type: 'logical', choices: [], value: 0 }, null);
            expect(c3.length).toBe(2);
            expect(c3[0].key).toBe(0);
            expect(c3[1].key).toBe(1);

            const c4 = e.evaluateChoices({ type: 'logical', value: 'x' }, null);
            expect(c4.length).toBe(2);
            expect(c4[0].key).toBe('0');
            expect(c4[1].key).toBe('1');

            const c5 = e.evaluateChoices({ type: 'logical', choices: null as never, value: null as never }, null);
            expect(c5.length).toBe(2);
            expect(c5[0].key).toBe(false);
            expect(c5[1].key).toBe(true);

            const c6 = e.evaluateChoices(
                {
                    type: 'logical',
                    // @ts-expect-error Incomplete choice definition
                    choices: () => [{ key: 0 }, { key: '1' }, { key: 2 }] as const,
                    value: null as never,
                },
                null,
            );
            expect(c6.length).toBe(2);
            expect(c6[0].key).toBe(0);
            expect(c6[1].key).toBe('1');
        });

        it('on multiSelect type', () => {
            const c1 = e.evaluateChoices(
                {
                    type: 'multiSelect',
                    // @ts-expect-error Incomplete choice definition
                    choices: [{}, { key: 2, name: 'Two' }, { key: 3 }],
                    value: [2],
                },
                null,
            );
            expect(c1.length).toBe(3);
            expect(c1[0].key).toBe(0);
            expect(c1[0].name).toBe('0');
            expect(c1[1].key).toBe(2);
            expect(c1[1].name).toBe('Two');
            expect(c1[2].key).toBe(3);
            expect(c1[2].name).toBe('3');

            const c2 = e.evaluateChoices(
                {
                    type: 'multiSelect',
                    // @ts-expect-error Incomplete choice definition
                    choices: [{ condition: '' }, { key: 2, name: 'Two', condition: 'true' }, { key: 3 }],
                    value: ['2'],
                },
                null,
            );
            expect(c2.length).toBe(3);
            expect(c2[0].key).toBe(0);
            expect(c2[0].name).toBe('0');
            expect(c2[0].condition).toBe(undefined);
            expect(c2[1].key).toBe(2);
            expect(c2[1].name).toBe('Two');
            expect(c2[1].condition).toBe('true');
            expect(c2[2].key).toBe(3);
            expect(c2[2].name).toBe('3');
            expect(c2[2].condition).toBe(undefined);

            const c3 = e.evaluateChoices(
                {
                    type: 'multiSelect',
                    // @ts-expect-error Incomplete choice definition
                    choices: () => [{}, { key: '2', name: 'Two' }, { key: 3 }],
                    value: [],
                },
                null,
            );
            expect(c3.length).toBe(3);
            expect(c3[0].key).toBe(0);
            expect(c3[0].name).toBe('0');
            expect(c3[1].key).toBe('2');
            expect(c3[1].name).toBe('Two');
            expect(c3[2].key).toBe(3);
            expect(c3[2].name).toBe('3');

            const c4 = e.evaluateChoices(
                {
                    type: 'multiSelect',
                    // @ts-expect-error Incomplete choice definition
                    choices: () => [{}, { key: '2', name: 'Two' }, { key: 3 }],
                    value: [1],
                },
                null,
            );
            expect(c4.length).toBe(3);
            expect(c4[0].key).toBe(0);
            expect(c4[0].name).toBe('0');
            expect(c4[1].key).toBe(2);
            expect(c4[1].name).toBe('Two');
            expect(c4[2].key).toBe(3);
            expect(c4[2].name).toBe('3');
        });

        it('with only keys', () => {
            const c1 = e.evaluateChoices(
                {
                    type: 'choice',
                    // @ts-expect-error Incomplete choice definition
                    choices: [1, 2, '3'],
                    value: 'b',
                },
                null,
            );
            expect(c1.length).toBe(3);
            expect(c1[0].key).toBe(1);
            expect(c1[1].key).toBe(2);
            expect(c1[2].key).toBe(3);
            expect(c1[0].name).toBe('1');
            expect(c1[1].name).toBe('2');
            expect(c1[2].name).toBe('3');

            const c2 = e.evaluateChoices(
                {
                    type: 'choice',
                    // @ts-expect-error Incomplete choice definition
                    choices: () => [1, 2, '3'],
                    value: 'b',
                },
                null,
            );
            expect(c2.length).toBe(3);
            expect(c2[0].key).toBe('1');
            expect(c2[1].key).toBe('2');
            expect(c2[2].key).toBe('3');
            expect(c2[0].name).toBe('1');
            expect(c2[1].name).toBe('2');
            expect(c2[2].name).toBe('3');

            const c3 = e.evaluateChoices(
                {
                    type: 'choice',
                    // @ts-expect-error Incomplete choice definition
                    choices: Expression('[1, 2, "3"]'),
                    value: 'b',
                },
                null,
            );
            expect(c3.length).toBe(3);
            expect(c3[0].key).toBe('1');
            expect(c3[1].key).toBe('2');
            expect(c3[2].key).toBe('3');
            expect(c3[0].name).toBe('1');
            expect(c3[1].name).toBe('2');
            expect(c3[2].name).toBe('3');
        });
    });
});