Untitled

function grid(w, h) {
    const arr = new Array(w);
    for(let i = 0; i < w; i++) {
        arr[i] = new Array(h);
    }
    return arr;
}

function canCoerce(param: string, arg: string) {
    return param === arg;
}

function checkParameters(
    params: string[],
    args: string[]
) {
    const compatibility: boolean[][] = grid(args.length, params.length);
    let allCompatible: boolean = params.length === args.length; // Make sure our happy path is fast
    for(let i = 0; i < Math.min(params.length, args.length); i++) {
        let paramCompatible = canCoerce(params[i], args[i]);
        allCompatible = allCompatible && paramCompatible;
        compatibility[i][i] = paramCompatible;
    }
    if(allCompatible) {
        console.log("Function call allowed!");
        return;
    }
    // We had some kind of incompatibility.  Either some params didn't match, or the lengths didn't match
    // To provide good heuristics, probe to see if adjacent arguments can line up
    // Start by filling in a compatibility grid
    for(let i = 0; i < args.length; i++) {
        for(let j = 0; j < params.length; j++) {
            if(i === j) continue; // We've already computed these
            compatibility[i][j] = canCoerce(args[i], params[j]);
        }
    }
    
    function directly_invalid(i) {
        if(i >= args.length || i >= params.length) {
            return false;
        }
        // Check if the input is completely unsatisfied
        for(let j = 0; j < args.length; j++) {
            if(compatibility[j][i]) {
                return false;
            }
        }
        // Check if the parameter is useless
        for(let j = 0; j < params.length; j++) {
            if(compatibility[i][j]) {
                return false;
            }
        }
        return true;
    }
    function argument_extra(i) {
        if(i >= compatibility.length) {
            return false;
        }
        if(compatibility[i].length == 0) {
            return true;
        }
        if(!compatibility[i].some(x => x)) {
            return true;
        }
        return false;
    }
    function param_missing(i) {
        if(i >= params.length) {
            return false;
        }
        if(!compatibility.some(r => r[i])) {
            return true;
        }
        return false;
    }
    function permuted() {
        // Find the rows that might be part of a permutation
        let possible_rows = [];
        for(let i = 0; i < args.length; i++) {
            if(compatibility[i].filter(j => j).length === 1) {
                possible_rows.push(i);
            }
        }
        let possible_cols = possible_rows.filter(i => {
            let j = compatibility[i].indexOf(true);
            let mr = possible_rows.filter(r => compatibility[r][j]);
            return mr.length === 1;
        });
        let permuted_cols = possible_cols.filter(c => !compatibility[c][c]);
        return permuted_cols;
    }
    function swapped(i) {
        if(i >= args.length || i >= params.length) {
            return false;
        }
        if(compatibility[i][i]) {
            return false;
        }
        for(let j = 0; j < Math.min(args.length, params.length); j++) {
            if(i == j) continue;
            if(compatibility[j][j]) {
                continue;
            }
            if(compatibility[i][j] && compatibility[j][i]) {
                return j;
            }
        }
        return false;
    }
    
    function removeArg(i) {
        args.splice(i, 1);
        compatibility.splice(i, 1);
    }
    function removeParam(i) {
        params.splice(i, 1);
        compatibility.forEach(r => r.splice(i, 1));
    }

    let limit = 10;
    while((params.length || args.length) && limit > 0) {

        let issueFound = false;
        for(let i = 0; i < Math.max(args.length, params.length); i++) {
            if (directly_invalid(i)) {
                console.log(`Expected ${params[i]}, got ${args[i]}`);
                removeArg(i);
                removeParam(i);
                issueFound = true;
                break;
            }
            if (argument_extra(i)) {
                console.log(`${args[i]} is extra!`);
                removeArg(i);
                issueFound = true;
                break;
            }
            if (param_missing(i)) {
                console.log(`${params[i]} is missing!`);
                removeParam(i);
                issueFound = true;
                break;
            }
        }
        let permutable = permuted();
        if(permutable.length > 1) {
            if(permutable.length == 2) {
                console.log(`${args[permutable[0]]} and ${args[permutable[1]]} are swapped!`);
            } else {
                console.log(`The following arguments are in the wrong order: ${permutable.map(p => args[p]).join(', ')}`);
            }
            permutable.sort().reverse().forEach(p => {
                removeArg(p);
                removeParam(p);
            });
            issueFound = true;
            continue;
        }
        if(!issueFound) {
            // Now that there are no obvious issues, eliminate one correctly mapped parameter
            for(let i = 0; i < Math.min(args.length, params.length); i++) {
                if(compatibility[i][i]) {
                    removeArg(i);
                    removeParam(i);
                    break;
                }
            }
        }
        limit--;
    }
    if(limit <= 0) {
        console.log("Diverged!!");
    }
}

type TestCase = [string, string[], string[]]

const testCases: TestCase[] = [
    /**/
    ['Valid', [], []],
    ['Valid', ['A'], ['A']],
    ['Valid', ['A','B'], ['A','B']],
    ['Valid', ['A', 'A'], ['A', 'A']],
    ['Invalid', ['A'], ['B']],
    ['Invalid', ['A', 'B'], ['A', 'C']],
    ['Invalid', ['A', 'B', 'C'], ['A', 'D', 'C']],
    ['Invalid', ['A', 'A', 'B'], ['A', 'A', 'C']],
    ['Invalid', ['A', 'A'], ['B', 'B']],
    ['Extra', [], ['A']],
    ['Extra', ['A'], ['A', 'B']],
    ['Extra', ['A'], ['A', 'B', 'C']],
    ['Extra', ['A', 'C'], ['A', 'B', 'C']],
    ['Extra', ['A', 'C'], ['B', 'A', 'C']],
    /**/
    ['Extra', ['A'], ['A', 'A']],
    /**/
    ['Extra', ['A', 'A'], ['A','A','A']],
    ['Extra', ['A', 'B'], ['A', 'A', 'B']],
    ['Extra', ['A', 'B'], ['A', 'B', 'B']],
    ['Extra', ['A', 'B'], ['A', 'A', 'B', 'B']],
    ['Extra and Invalid', ['A', 'B'], ['A', 'C', 'D']],
    ['Extra and Invalid', ['A', 'B', 'C'], ['A', 'C', 'F', 'C']],
    ['Missing', ['A'], []],
    ['Missing', ['A', 'B'], ['A']],
    ['Missing', ['A', 'B'], ['B']],
    ['Missing', ['A', 'A'], ['A']],
    ['Missing', ['A', 'A', 'A'], ['A']],
    ['Missing', ['A', 'B', 'C'], ['A', 'C']],
    ['Missing', ['A', 'B', 'C'], ['A', 'C']],
    ['Missing', ['A', 'B', 'B', 'C'], ['A', 'C']],
    ['Missing', ['A', 'B', 'A', 'B', 'C'], ['A', 'C']],
    ['Missing and Invalid', ['A', 'B', 'C'], ['A', 'D']],
    ['Missing and Extra', ['A', 'B', 'C'], ['A', 'C', 'F']],
    ['Swapped', ['A', 'B'], ['B', 'A']],
    ['Swapped', ['A', 'B', 'C'], ['B', 'A', 'C']],
    ['Swapped', ['A', 'B', 'C'], ['A', 'C', 'B']],
    ['Swapped', ['A', 'B', 'C'], ['C', 'B', 'A']],
    ['Permuted', ['A', 'B', 'C', 'D', 'E'], ['D', 'E', 'C', 'A', 'B']],
    ['Permuted', ['A', 'B', 'C'], ['B', 'C', 'A']],
    ['Swapped and Invalid', ['A', 'B', 'C'], ['C', 'F', 'A']],
    ['Swapped and Missing', ['A', 'B', 'C'], ['C', 'A']],/**/
    ['Missing, Extra, Invalid, Swapped', ["A", "B", "C", "D", "E", "F"], ["A", "C", "X", "G", "F", "E"]],
];

for(const c of testCases) {
    console.log(`fn MyFunc(${c[1].join(', ')}) { ... }`);
    console.log(`   MyFunc(${c[2].join(', ')});`);
    checkParameters(c[1], c[2]);
    console.log('----------------------');
}