import { CompiledExpression, Expression, isExpression, ExpressionTag } from '../dist/index.js';

describe('Expression', () => {
    it('create', () => {
        const exp1 = Expression('a + b', 'number');
        expect(exp1[ExpressionTag]).toBe('number');
        expect(exp1.source).toBe('a + b');

        const exp2 = Expression<number>('x * 2');
        expect(exp2[ExpressionTag]).toBe('');
        expect(exp2.source).toBe('x * 2');
    });
    it('create bad', () => {
        expect(() => Expression(null as never)).toThrow();
        expect(() => Expression({} as never)).toThrow();
        expect(() => Expression('a + b')).not.toThrow();
    });
    it('create from expression', () => {
        const exp1 = Expression('a + b', 'number');
        const exp2 = Expression(exp1, 'number');
        expect(exp2[ExpressionTag]).toBe('number');
        expect(exp2.source).toBe('a + b');
        expect(exp1).not.toBe(exp2);
    });
    it('create from compiled expression', () => {
        const fn = () => 1;
        const compExp1 = CompiledExpression(fn, 'a + b', 'number');
        const exp2 = Expression(compExp1, 'number');
        expect(exp2[ExpressionTag]).toBe('number');
        expect(exp2.source).toBe('a + b');
        expect(compExp1).not.toBe(exp2);
        expect(exp2).not.toBeInstanceOf(Function);
    });
    it('isExpression', () => {
        const exp1 = Expression('a + b', 'number');
        expect(isExpression(exp1)).toBe(true);
        expect(isExpression('a + b')).toBe(false);
        expect(isExpression({ source: 'a + b' })).toBe(false);

        const compiled = CompiledExpression(() => 1, 'a + b', 'number');
        expect(isExpression(compiled)).toBe(true);
        expect(isExpression(() => 1)).toBe(false);
    });
    it('create compiled', () => {
        const fn = () => 1;
        const compExp = CompiledExpression(fn, 'a + b', 'number');
        expect(compExp()).toBe(1);
        expect(compExp.source).toBe('a + b');
        expect(compExp[ExpressionTag]).toBe('number');
        expect(fn).toBe(compExp);
    });
    it('create compiled bad', () => {
        expect(() => CompiledExpression(null as never, 'a + b')).toThrow();
        expect(() => CompiledExpression({} as never, 'a + b')).toThrow();
    });
    it('create compiled from compiled', () => {
        const fn = () => 1;
        const compExp1 = CompiledExpression(fn, 'a + b', 'number');
        const compExp2 = CompiledExpression(compExp1, 'a + b + c', 'number');
        expect(compExp1).toBe(fn);
        expect(compExp2()).toBe(1);
        expect(compExp2.source).toBe('a + b + c');
        expect(compExp2[ExpressionTag]).toBe('number');
        expect(compExp2).not.toBe(fn);
    });
});