import * as uut from './genfuns.js';

describe('matchesSpecializer', () => {
    function AThing() {};
    const an_instance = new AThing();
    
    test('works in expected cases', () => {
        expect(uut.matchesSpecializer(an_instance, AThing)).toBeTruthy();
        expect(uut.matchesSpecializer(an_instance, String)).toBeFalsy();
        expect(uut.matchesSpecializer(an_instance, Object)).toBeTruthy();

        expect(uut.matchesSpecializer(new String("foobar"), String)).toBeTruthy();
        expect(uut.matchesSpecializer(new String("foobar"), Object)).toBeTruthy();

        expect(uut.matchesSpecializer(new Number(1), Number)).toBeTruthy();
        expect(uut.matchesSpecializer(new Number(1), Object)).toBeTruthy();
        expect(uut.matchesSpecializer(new Number(1), String)).toBeFalsy();

        expect(uut.matchesSpecializer([], Array)).toBeTruthy();
        expect(uut.matchesSpecializer([], Object)).toBeTruthy();
        expect(uut.matchesSpecializer([], Number)).toBeFalsy();

        function Foo() {}
        Foo.prototype = Object.create(null);
        const inst = new Foo();
        expect(uut.matchesSpecializer(inst, Foo)).toBeTruthy();
        expect(uut.matchesSpecializer(inst, Object)).toBeFalsy();
    });

    test('works in for primitives', () => {
        expect(uut.matchesSpecializer(1, Number)).toBeTruthy();
        expect(uut.matchesSpecializer(1, Object)).toBeTruthy();
        expect(uut.matchesSpecializer(1, String)).toBeFalsy();

        expect(uut.matchesSpecializer("1", String)).toBeTruthy();
        expect(uut.matchesSpecializer("1", Object)).toBeTruthy();
        expect(uut.matchesSpecializer("1", Number)).toBeFalsy();

        expect(uut.matchesSpecializer(null, Number)).toBeFalsy();
        expect(uut.matchesSpecializer(null, String)).toBeFalsy();
        expect(uut.matchesSpecializer(null, Object)).toBeFalsy();

        expect(uut.matchesSpecializer(undefined, Number)).toBeFalsy();
        expect(uut.matchesSpecializer(undefined, String)).toBeFalsy();
        expect(uut.matchesSpecializer(undefined, Object)).toBeFalsy();
    });
});

describe('defgeneric', () => {
    test('methods get called appropriately', () => {
        expect(
            uut.defgeneric("testing1", "a", "b")
                .primary([Object, Object], (_, __) => 1)
                .fn(1,2)
        ).toEqual(1);

        expect(
            uut.defgeneric("testing1", "a", "b")
                .primary([Number, Number], (_, __) => 1)
                .fn(1,2)
        ).toEqual(1);

        expect(
            uut.defgeneric("testing1", "a", "b")
                .primary([Number, Number], (_, __) => 2)
                .primary([String, String], (_, __) => 1)
                .fn("1","2")
        ).toEqual(1);

        let firstCounts = 0;
        expect(
            uut.defgeneric("testing1", "a", "b")
                .primary([Number, Number], (_, __) => firstCounts += 1)
                .primary([String, String], (_, __) => firstCounts += 1)
                .fn("1","2")
        ).toEqual(1);
        expect(firstCounts).toEqual(1);

        let secondCounts = 0;
        expect(
            uut.defgeneric("testing1", "a", "b")
                .primary([Object, Object], (_, __) => secondCounts += 1)
                .primary([String, String], (_, __) => secondCounts += 1)
                .fn("1","2")
        ).toEqual(1);
        expect(secondCounts).toEqual(1);

        let thirdCounts = 0;
        expect(
            uut.defgeneric("testing1", "a", "b")
                .before([Object, Object], (_, __) => thirdCounts += 1)
                .primary([String, String], (_, __) => 'hi')
                .after([Object, String], (_, __) => thirdCounts += 1)
                .fn("1","2")
        ).toEqual('hi');
        expect(thirdCounts).toEqual(2);


    });
});