let genfun_prototype = {
    name: "(placeholder)",
    lambda_list: [],
    methods: [],
};

function GenericFunction(name, lambda_list, methods) {
    if (! (this instanceof GenericFunction) ) {
        return new GenericFunction(name, lambda_list, methods);
    }

    this.name = name;
    this.lambda_list = lambda_list;
    this.methods = methods;
}

GenericFunction.prototype = Object.assign(
    Object.create(genfun_prototype), {
    }
);

let method_prototype = {
    lambda_list: [],
    qualifiers: [],
    specializrs: [],
    body() { throw new Error('Unimplemented'); },
    environment: {},
    generic_function: {},
};

function StandardMethod(
    lambda_list, qualifiers, specializers, body, environment, generic_function
) {
    if (! (this instanceof StandardMethod) ) {
        return new StandardMethod(...arguments);
    }

    this.lambda_list = lambda_list;
    this.qualifiers = qualifiers;
    this.specializers = specializers;
    this.body = body;
    this.environment = environment;
    this.generic_function = generic_function;
}

function ensure_method(gf, ...rest) {
    let new_method = StandardMethod(...rest);
    add_method(gf, new_method);
    return new_method;
}

function add_method(gf, method) {
    method.generic_function = gf;
    gf.methods.push(method);
    return method;
}

function classes_of(args) {
    return args.map(Object.getPrototypeOf);
}

const required_portion = x => x;

function apply_generic_function(gf, args) {
    let applicable_methods =
        compute_applicable_methods_using_classes(gf, required_portion(args));
    if (applicable_methods.length === 0) {
        throw new Error(`no applicable methods for gf ${gf.name} with args ${args}`);
    } else {
        return apply_methods(gf, args, applicable_methods);
    }
}

function method_more_specific_p(m1, m2, required_classes) {
    const m1specializers = m1.specializers;
    const m2specializers = m2.specializers;

    for ([spec1, spec2] of m1specializers.map((el, idx) => [el, m2specializers[idx]])) {
        if (spec1 !== spec2) {
            return sub_specializer_p(spec1, spec2);
        }
    }
}

function sub_specializer_p(c1, c2) {
    return c1.isPrototypeOf(c2);
}

const idS = Symbol.for('id');
Object.prototype[idS] = function () { return this };

function compute_applicable_methods_using_classes(gf, required_classes) {
    const applicable_methods = gf.methods.filter(
        method =>
            method.specializers.every((specializer,idx) => (console.info(specializer),
                                                            specializer.prototype.isPrototypeOf(required_classes[idx])
                                                            || specializer.prototype.isPrototypeOf(required_classes[idx][idS]())))
    );

    applicable_methods.sort((a,b) => {
        if (method_more_specific_p(a,b)) {
            return -1;
        }
        if (method_more_specific_p(b,a)) {
            return 1;
        }
        return 0;
    })

    return applicable_methods;
}

const before_qualifier = Symbol.for('before');
const after_qualifier = Symbol.for('after');

function arr_eq(a1, a2) {
    if (a1.length !== a2.length) {
        return false;
    } else {
        for (let x = 0; x < a1.length; x++) {
            if (a1[x] instanceof Array && a2[x] instanceof Array) {
                if (!arr_eq(a1[x], a2[x])) {
                    return false;
                }
            } else if (a1[x] !== a2[x]) {
                return false;
            }
        }
        return true;
    }
}

const primary_method_p = method => method.qualifiers.length === 0;
const before_method_p = method => arr_eq(method.qualifiers, [before_qualifier]);
const after_method_p = method => arr_eq(method.qualifiers, [after_qualifier]);

function apply_methods(gf, args, applicable_methods) {
    const primaries = applicable_methods.filter(primary_method_p);
    const befores = applicable_methods.filter(before_method_p);
    const afters = applicable_methods.filter(after_method_p);
    afters.reverse();

    if (primaries.length === 0) {
        throw new Error(`No primary method for ${gf.name}`);
    }

    for (let before of befores) {
        apply_method(before, args, []);
    }

    const result = apply_method(primaries[0], args, primaries.slice(1));

    for (let after of afters) {
        apply_method(after, args, []);
    }

    return result;
}

function apply_method(method, args, next_methods) {
    return Function('call_next_method', 'next_method_p', `return ${method.body.toString()}`)(
        (...cnm_args) => {
            if (next_methods.length === 0) {
                throw new Error(`no next method for genfun ${method.generic_function.name}`);
            }

            return apply_methods(method.generic_function, cnm_args.length > 0 ? cnm_args : args, next_methods);
        },
        () => next_methods.length === 0
    )(...args);
}

const gf = GenericFunction("foobar", ["a", "b"], []);
ensure_method(
    gf,
    [], [], [Object, Array], (thing, arr) => [thing, ...arr], null
);
ensure_method(
    gf,
    [], [], [Object, Object], (thing, single) => [thing, single], null
);

console.info(apply_generic_function(gf, [["asdf"],2]));