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

   describe("primitives", () => {
     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)).toBeTruthy();

     });

     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)).toBeTruthy();

     });

     test.each([true, false])("booleans -> %s", bool => {
       expect(bool).not.toBe(Object(bool));
       expect(uut.matches_specializer(new Boolean(bool), Boolean)).toBeTruthy();
       expect(uut.matches_specializer(bool, Boolean)).toBeTruthy();
       expect(uut.matches_specializer(bool, Object)).toBeTruthy();
     });

     test("works for numbers", () => {
       expect(1).not.toBe(Object(1));
       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("asdf").not.toBe(Object("asdf"));
 
       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();
     });

     test("handles symbols", () => {
       const symbolPrim = Symbol("primitive");
       const boxedSymbol = Object(symbolPrim);
       expect(symbolPrim).not.toBe(boxedSymbol);

       expect(uut.matches_specializer(boxedSymbol, Symbol)).toBeTruthy();
       expect(uut.matches_specializer(boxedSymbol, Object)).toBeTruthy();
 
       expect(uut.matches_specializer(symbolPrim, Symbol)).toBeTruthy();
       expect(uut.matches_specializer(symbolPrim, Object)).toBeTruthy();
     });
 
     test("handles BigInt", () => {

       expect(BigInt(4)).not.toBe(Object(BigInt(4)));

       expect(uut.matches_specializer(Object(BigInt(4)), BigInt)).toBeTruthy();
       expect(uut.matches_specializer(Object(BigInt(4)), Object)).toBeTruthy();

       expect(uut.matches_specializer(BigInt(4), BigInt)).toBeTruthy();
       expect(uut.matches_specializer(BigInt(4), Object)).toBeTruthy();

     });
   });
 
   test("works with custom specializers", () => {
     const AEql = makeCustomSpecializer();
     expect(uut.matches_specializer("foo", new AEql("foo"))).toBeTruthy();

   });

 });
 

 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("foobar", "a")
         .primary([String], function (a) {})
         .fn({});

     }).toThrow(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("works with custom specializers", () => {
     const AEql = makeCustomSpecializer();
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([new AEql("foo")], function (a) {
           return 3;
         })
         .fn("foo")
     ).toEqual(3);
 
     expect(new AEql("foo").super_of(String)).toBeFalsy();
     expect(new AEql("foo").super_of(Object)).toBeFalsy();
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           return 1;
         })
         .primary([String], function (a) {
           return 2;
         })
         .primary([new AEql("foo")], function (a) {
           return 3;
         })
         .fn("foobar")
     ).toEqual(2);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           return 1;
         })
         .primary([String], function (a) {
           return 2;
         })
         .primary([new AEql("foo")], function (a) {
           return 3;
         })
         .fn("foo")
     ).toEqual(3);
   });
 

   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", () => {

     expect(() => {

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

     }).toThrow(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);
     }
   });

 
   test("bugfix: behavior of null in method", () => {
     const expectedResult = Symbol(4);
     expect(() => {
       uut
         .defgeneric("foobar", "a", "b")
         .primary([Object, Object], () => expectedResult)
         .fn(null, null);
     }).not.toThrow();
     expect(
       uut
         .defgeneric("foobar", "a", "b")
         .primary([Object, Object], () => expectedResult)
         .fn(null, null)
     ).toBe(expectedResult);
   });

 });
 

 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("Eql", () => {
   test("basic stuff works", () => {
     expect(uut.matches_specializer("foo", uut.Eql("foo"))).toBeTruthy();
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([new uut.Eql("foo")], function (a) {
           return 3;
         })
         .fn("foo")
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([new uut.Eql(5)], function (a) {
           return 3;
         })
         .fn(5)
     ).toEqual(3);
   });
   test("inheritance works", () => {
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Symbol], function () {
           return 2;
         })
         .primary([uut.Eql(Symbol.iterator)], function () {
           return 3;
         })
         .fn(Symbol.iterator)
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Boolean], function (a) {
           return 2;
         })
         .primary([new uut.Eql(false)], function (a) {
           return 3;
         })
         .fn(false)
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Boolean], function (a) {
           return 2;
         })
         .primary([new uut.Eql(true)], function (a) {
           return 3;
         })
         .fn(true)
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([String], function (a) {
           return 2;
         })
         .primary([new uut.Eql("5")], function (a) {
           return 3;
         })
         .fn("5")
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Number], function (a) {
           return 2;
         })
         .primary([new uut.Eql(5)], function (a) {
           return 3;
         })
         .fn(5)
     ).toEqual(3);
   });
 });
 

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

 });

 
 function makeCustomSpecializer() {
   function AEql(val) {
     this.val = val;
   }
   AEql.prototype = Object.assign(new uut.Specializer(), {
     toString() {
       return `AEql(${this.val})`;
     },
     matches(other) {
       return this.val === other;
     },
     super_of(other) {
       return other === String ? false : other !== Object;
     },
   });
   return AEql;
 }