import * as uut from './genfuns';
import { fail } from 'assert';

describe('matches_specializer', () => {
    test('works in expected cases', () => {
        function AThing() { }
        const an_instance = new AThing();

        expect(uut.matches_specializer(an_instance, AThing)).toBeTruthy();
        expect(uut.matches_specializer(an_instance, String)).toBeFalsy();
        expect(uut.matches_specializer(an_instance, Object)).toBeTruthy();

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

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

        expect(uut.matches_specializer({ a: 1 }, uut.Shape('a'))).toBeTruthy();
        expect(uut.matches_specializer({ a: 1, b: 2 }, uut.Shape('a'))).toBeTruthy();
        expect(uut.matches_specializer({ b: 2 }, uut.Shape('a'))).toBeFalsy();

        expect(uut.matches_specializer({ a: 1, b: 2, c: 3 }, uut.Shape('a', 'b', 'c'))).toBeTruthy();
        expect(uut.matches_specializer({ a: 1, b: 2, c: 3, d: 4 }, uut.Shape('a', 'b', 'c'))).toBeTruthy();
        expect(uut.matches_specializer({ a: 1, c: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();
        expect(uut.matches_specializer({ c: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();
        expect(uut.matches_specializer({ d: 3 }, uut.Shape('a', 'b', 'c'))).toBeFalsy();
    });

    test('null behavior', () => {
        expect(uut.matches_specializer(null, null)).toBeTruthy();
        expect(uut.matches_specializer(null, Number)).toBeFalsy();
        expect(uut.matches_specializer(null, String)).toBeFalsy();
        expect(uut.matches_specializer(null, Object)).toBeFalsy();
    });

    test('undefined (the value) behavior', () => {
        expect(uut.matches_specializer(undefined, undefined)).toBeTruthy();
        expect(uut.matches_specializer(undefined, Number)).toBeFalsy();
        expect(uut.matches_specializer(undefined, String)).toBeFalsy();
        expect(uut.matches_specializer(undefined, Object)).toBeFalsy();
    });

    test('works for numbers', () => {
        expect(uut.matches_specializer(new Number(1), Number)).toBeTruthy();
        expect(uut.matches_specializer(new Number(1), Object)).toBeTruthy();
        expect(uut.matches_specializer(new Number(1), String)).toBeFalsy();

        expect(uut.matches_specializer(1, Number)).toBeTruthy();
        expect(uut.matches_specializer(1, Object)).toBeTruthy();
        expect(uut.matches_specializer(1, String)).toBeFalsy();
    });

    test('handles strings', () => {
        expect(uut.matches_specializer(new String("foobar"), String)).toBeTruthy();
        expect(uut.matches_specializer(new String("foobar"), Object)).toBeTruthy();

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

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

        try {
            uut.defgeneric("foobar", "a")
                .primary([String], function (a) { })
                .fn({});
            fail();
        } catch (err) {
            expect(err).toBeInstanceOf(uut.NoApplicableMethodError);
        }

        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);

        expect(
            uut.defgeneric("foobar", "a")
                .primary([Object], function (a) {
                    return 1
                })
                .primary([String], function (a) {
                    return 2
                })
                .fn("foobar"))
            .toEqual(2);
    });

    test('next-method-p works', () => {
        expect.assertions(3);

        uut.defgeneric("foobar", "a")
            .primary([Object], function (a) {
                expect(this.next_method_p).toBe(false);
            })
            .fn({});

        uut.defgeneric("foobar", "a")
            .primary([Object], function (a) {
                expect(this.next_method_p).toBe(false);
            })
            .primary([String], function (a) {
                expect(this.next_method_p).toBe(true);
            })
            .fn("foobar");

        uut.defgeneric("foobar", "a")
            .primary([Object], function (a) {
                expect(this.next_method_p).toBe(false);
            })
            .primary([String], function (a) {
                expect(this.next_method_p).toBe(true);
            })
            .fn(1);

    });

    test('call-next-method works', () => {
        try {
            uut.defgeneric("foobar", "a")
                .primary([Object], function (a) {
                    this.call_next_method();
                })
                .primary([String], function (a) {
                    return 1;
                })
                .fn({})
            fail();
        } catch (err) {
            expect(err).toBeInstanceOf(uut.NoNextMethodError);
        }

        expect(
            uut.defgeneric("foobar", "a")
                .primary([Object], function (a) {
                    return 1;
                })
                .primary([String], function (a) {
                    return this.call_next_method();
                })
                .fn("foobar")
        ).toEqual(1);

        expect(
            uut.defgeneric("foobar", "a", "b")
                .primary([String, String], function (a, b) {
                    return `1${this.call_next_method()}`;
                })
                .primary([Object, String], function (a, b) {
                    return `3${this.call_next_method()}`;
                })
                .primary([String, Object], function (a, b) {
                    return `2${this.call_next_method()}`;
                })
                .primary([Object, Object], function (a, b) {
                    return `4`;
                }).fn("a", "b")
        ).toEqual("1234");

        try {
            uut.defgeneric("foobar", "a")
                .primary([Object], function (a) {
                    this.call_next_method();
                })
                .fn({});
            fail();
        } catch (err) {
            expect(err).toBeInstanceOf(uut.NoNextMethodError);
        }

    });
});

describe('custom specializers', () => {
    test('Shape works', () => {
        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)
            .primary([Object], _ => null)
            .fn({ a: 1, b: 2 }))
            .toEqual(3);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)
            .primary([Object], _ => null)
            .fn({ a: 1, b: 2, c: 3 }))
            .toEqual(3);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)
            .primary([Object], _ => null)
            .fn({ a: 1 }))
            .toEqual(null);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape(['a', 1], 'b')], ({ a, b }) => a + b)
            .primary([Object], _ => null)
            .fn({ a: 1, b: 3 }))
            .toEqual(4);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape(['a', null], 'b')], ({ a, b }) => b)
            .primary([Object], _ => null)
            .fn({ a: null, b: 3 }))
            .toEqual(3);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape(['a', undefined], 'b')], ({ a, b }) => b)
            .primary([Object], _ => null)
            .fn({ b: 5 }))
            .toEqual(null); //undefined is not a permissible default: treated as if the key is missing

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape(['a', 1], 'b')], ({ a, b }) => a + b)
            .primary([Object], _ => null)
            .fn({ a: 2, b: 3 }))
            .toEqual(null);
    });

    test('Shape, prototype precedence', () => {
        expect(uut.defgeneric("foobar4", "a")
            .primary([uut.Shape('a')], ({ a }) => a)
            .primary([uut.Shape('a', 'b')], ({ a, b }) => { return a + b })
            .primary([Object], _ => null).fn({ a: 1, b: 3 }))
            .toEqual(4);

        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape('a', 'b')], ({ a, b }) => a + b)
            .primary([uut.Shape('b')], ({ b }) => b)
            .primary([Object], _ => null)
            .fn({ a: 1, b: 2 }))
            .toEqual(3);

        const Foo = function () { }
        Foo.prototype = { a: true, b: null };
        expect(uut.defgeneric("foobar", "a")
            .primary([uut.Shape('a')], function ({ a }) { return `a${this.call_next_method()}`; })
            .primary([uut.Shape('a', 'b', 'c')], function ({ a, b, c }) { return `c${this.call_next_method()}`; })
            .primary([uut.Shape('a', 'b')], function ({ a, b }) { return `b${this.call_next_method()}`; })
            .primary([Object], _ => 'd')
            .fn(Object.assign(new Foo(), { c: 3 })))
            .toEqual('cbad');
    });
});

describe("Shape", () => {
    test('super_of', () => {
        expect(uut.Shape().super_of(uut.Shape("a", "b", "c"))).toBeTruthy();
        expect(uut.Shape('a').super_of(uut.Shape('a', 'b'))).toBeTruthy();
        expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b", "c"))).toBeTruthy();
        expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b", 3))).toBeTruthy();
        expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b"))).toBeFalsy();
        expect(uut.Shape("a", "b").super_of(uut.Shape("a"))).toBeFalsy();
    });
});