Refine IVs with appraisals on pokeassistant.com

// credit to reddit user /u/dm_2112 - adapted by /u/rayanbfvr
// original comment https://www.reddit.com/r/pokemongodev/comments/4zbc3b/new_update_allows_much_more_accurate_iv/d6uhvtr
// pastebin to use on https://pokemon.gameinfo.io/tools/iv-calculator: http://pastebin.com/vzc4cmP2

var ivs = [];

function refineIVs() {
    var translate = {
        0: 'level',
        1: 'attack',
        2: 'defense',
        3: 'hp',
        4: 'perc'
    };

    $('#possiblecombis').children('tbody').children().each(function() {
        if ($(this).index() != 0) {
            var that = $(this);
            var thisIVs = that.children();
            var objEl = {
                hidden: false
            };
            objEl['element'] = that;
            for (i = 0; i < thisIVs.length; i++) {
                objEl[translate[i]] = thisIVs[i].textContent;
            }
            ivs.push(objEl);
        }
    });
    derivatePhrase();
}

function derivatePhrase() {

    var promptText = "0: ...It can accomplish anything!\n" +
        "1: ...You should be proud!\n" +
        "2: ...is a decent Pokemon\n" +
        "3: ...but I still like it!";
    var promptStat = "0: ...WOW!\n" +
        "1: ...How exciting!\n" +
        "2: ...it'll get the job done.\n" +
        "3: ...don't point to greatness in battle.\n\n" +
        "Leave empty if not provided";
    var overall = parseInt(prompt(promptText, ""));
    hideOptions("overall", overall);
    var attack = parseInt(prompt("Attack\n\n" + promptStat, ""));
    if (!isNaN(attack)) hideOptions("attack", attack);
    var defense = parseInt(prompt("Defense\n\n" + promptStat, ""));
    if (!isNaN(defense)) hideOptions("defense", defense);
    var hp = parseInt(prompt("HP\n\n" + promptStat, ""));
    if (!isNaN(hp)) hideOptions("hp", hp);

    var knownStat;
    var maxKnownStat;

    if (!isNaN(attack)) sortIVs("attack", knownStat, maxKnownStat);
    if (!isNaN(defense)) sortIVs("defense", knownStat, maxKnownStat);
    if (!isNaN(hp)) sortIVs("hp", knownStat, maxKnownStat);

    if (isNaN(attack)) hideNegativeOptions("attack", knownStat, maxKnownStat);
    if (isNaN(defense)) hideNegativeOptions("defense", knownStat, maxKnownStat);
    if (isNaN(hp)) hideNegativeOptions("hp", knownStat, maxKnownStat);

    if (!isNaN(attack) && !isNaN(defense) && !isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.attack !== el.defense || el.defense !== el.hp || el.attack !== el.hp) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (!isNaN(attack) && !isNaN(defense) && isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.attack !== el.defense || el.defense === el.hp || el.attack === el.hp) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (!isNaN(attack) && isNaN(defense) && isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.attack === el.defense || el.attack === el.hp) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (isNaN(attack) && !isNaN(defense) && !isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.hp !== el.defense || el.defense === el.attack || el.hp === el.attack) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (isNaN(attack) && !isNaN(defense) && isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.defense === el.attack || el.defense === el.hp) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (!isNaN(attack) && isNaN(defense) && !isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.hp !== el.attack || el.defense === el.attack || el.defense === el.hp) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

    if (isNaN(attack) && isNaN(defense) && !isNaN(hp)) {
        ivs.forEach(function(el) {
            if (el.hp === el.attack || el.hp === el.defense) {
                el.hidden = true;
                el.element.hide();
            }
        });
    }

}

function sortIVs(type, knownStat, knownStat) {
    var arr = [];
    ivs.forEach(function(el) {
        if (!el.hidden) {
            switch (type) {
                case "attack":
                    arr.push(parseInt(el.attack));
                    break;
                case "defense":
                    arr.push(parseInt(el.defense));
                    break;
                case "hp":
                    arr.push(parseInt(el.hp));
                    break;
            }
        }
    });
    var isEqual = (arr.length && arr.reduce(function(a, b) {
        return (a === b) ? a : false;
    }) === arr[0]);
    if (isEqual) knownStat = parseInt(arr[0]);
    maxKnownStat = arr.sort(function(a, b) {
        return a - b;
    })[arr.length - 1];
}

function hideNegativeOptions(type, value, maxValue) {

    var valExact = value;
    var maxValExact = maxValue;

    if (type === "attack" || type === "defense" || type === "hp") {

        if (valExact) {
            ivs.forEach(function(el) {
                var stat = parseFloat(el[type]);
                if (stat === valExact || stat > valExact) {
                    el.hidden = true;
                    el.element.hide();
                }
            });
        } else {
            ivs.forEach(function(el) {
                var stat = parseFloat(el[type]);
                if (stat > maxValExact) {
                    el.hidden = true;
                    el.element.hide();
                }
            });
        }
    }
}

function hideOptions(type, value) {
    if (typeof(value) !== "number") return "Error: wrong type";
    var valMin, valMax;

    if (type === "overall") {
        switch (value) {
            case 0:
                valMin = 80;
                valMax = 100;
                break;
            case 1:
                valMin = 65;
                valMax = 80;
                break;
            case 2:
                valMin = 50;
                valMax = 65;
                break;
            case 3:
                valMin = 0;
                valMax = 50;
                break;
        }
        filterIVDivs("perc", valMin, valMax);
    }

    if (type === "attack" || type === "defense" || type === "hp") {
        switch (value) {
            case 0:
                valMin = 15;
                valMax = 15;
                break;
            case 1:
                valMin = 13;
                valMax = 14;
                break;
            case 2:
                valMin = 8;
                valMax = 12;
                break;
            case 3:
                valMin = 0;
                valMax = 7;
                break;
        }
        filterIVDivs(type, valMin, valMax);
    }
}

function filterIVDivs(statType, valMin, valMax) {
    ivs.forEach(function(el) {
        var elStatType;
        var elStat;
        if (statType == "perc") elStat = parseFloat(el.perc.replace('%', ''));
        else elStat = el[statType];

        if (elStat < valMin || elStat > valMax) {
            el.hidden = true;
            el.element.hide();
        }
    });
}

refineIVs();