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


let genfun_prototype = {
    name: "(placeholder)",
    lambda_list: [],
    methods: [],
    method(qualifiers, specializers, body) {
        ensure_method(this, this.lambda_list, qualifiers, specializers, body)
        return this;
    },
    primary(specializers, body) {
        return this.method([], specializers, body);
    },
    before(specializers, body) {
        return this.method([before_qualifier], specializers, body);
    },
    after(specializers, body) {
        return this.method([after_qualifier], specializers, body);
    },
    around(specializers, body) {
        return this.method([around_qualifier], specializers, body);
    },
    get fn() {
        const gf = this;
        const lambda = (function() {
            return apply_generic_function(gf, [].slice.call(arguments));
        }).bind(gf);
        return Object.defineProperties(lambda, {
            'name': {value: gf.name},
            'lambda_list': {value: gf.lambda_list},
            'gf': {value: gf},
        });
    }
};

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

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

GenericFunction.prototype = Object.create(genfun_prototype);

export function defgeneric(name, ...argument_names) {
    return GenericFunction(name, argument_names);
}

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

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

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

function ensure_method(gf, lambda_list, qualifiers, specializers, body) {
    let new_method = StandardMethod(...[].slice.call(arguments, 1));
    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 ${JSON.stringify(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 (let [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 };

export function matchesSpecializer(obj, specializer) {
    let result = obj === specializer.prototype;
    let objType = typeof obj;

    if (!result && objType === 'object') {
        result = Object.isPrototypeOf.call(specializer.prototype, obj);
    } else if (objType === 'number') {
        result = matchesSpecializer(Number.prototype, specializer) || matchesSpecializer(specializer.prototype, Number);
    } else if (objType === 'string') {
        result = matchesSpecializer(String.prototype, specializer) || matchesSpecializer(specializer.prototype, String);
    }

    return result;
}


function compute_applicable_methods_using_classes(gf, required_classes) {
    const applicable_methods = gf.methods.filter(
        method => method.specializers.every((specializer, idx) => matchesSpecializer(required_classes[idx], specializer))
    );

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


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 instanceof WrappedMethod || method.qualifiers.length === 0;
const before_method_p =
      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [before_qualifier]);
const after_method_p =
      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [after_qualifier]);
const around_method_p =
      method => !(method instanceof WrappedMethod) && arr_eq(method.qualifiers, [around_qualifier]);

function WrappedMethod(continuation) {
    this.continuation = continuation;
}

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

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

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

            try {
                return apply_method(primaries[0], args, primaries.slice(1));
            } finally {
                for (let after of afters) {
                    apply_method(after, args, []);
                }
            }
        },
        'name', {value: `main_call_${gf.name}`}, 
    );

    if (arounds.length === 0) {
        return main_call();
    } else {
        const wrapped_main_call = new WrappedMethod(main_call);
        const next_methods = arounds.slice(1).concat([wrapped_main_call]);
        return apply_method(arounds[0], args, next_methods);
    }
}

function apply_method(method, args, next_methods) {
    const method_context = {
        call_next_method(...cnm_args) {
            if (next_methods.length === 0) {
                throw new Error(`no next method for genfun ${method.generic_function.name}`);
            }

            return method instanceof WrappedMethod
                ? method.continuation()
                : apply_methods(method.generic_function, cnm_args.length > 0 ? cnm_args : args, next_methods);
        },
        get next_method_p() {
            return next_methods.length === 0
        }
    };

    return method.body ? method.body.bind(method_context)(...args) : method.continuation();
}