// derived from https://git.dervland.net/biglyderv/new-bigly-chat/src/branch/master/docs/stats.php
function rankCalc(result, iterations = 10, main = [], domain_mode = false) {
    let matrixe = {}
    let fng = {};
    let fnc = {};
    let frs = {};
    let msum_old = 0.001;
    let pr = {};

    let rl = Object.keys(result).length;
    for (let unn in result) {
        let v = false;
        if (domain_mode) {
            v = false;
            try {
                let test = new URL(unn);
                v = true;
            } catch (err) {
                v = false;
            }
        }
        if (!v) {
            delete result[unn];
            continue;
        }

        matrixe[unn] = {};
        matrixe[unn][unn] = 1;
        frs[unn] = result[unn].followers;
        fng[unn] = result[unn].following;


        let lf = Object.keys(fng[unn]).length;
        if (domain_mode) {
            let domains = [];
            for (let x of fng[unn]) {
                try {
                    let a = new URL(x);
                    domains.push(a.host);
                } catch (err) {

                }
            }
            domains = [...new Set(domains)];

            fnc[unn] = lf / (1 + domains.length);
        } else {
            fnc[unn] = lf;
        }

        pr[unn] = 0.1 / rl;
    }



    for (let unn in result) {
        let fnu = frs[unn];
        for (let follow of fnu) {
            if (follow == unn) continue;
            let dst = fnc[fnu] || 0;
            matrixe[unn][follow] = 1 + 1 / (dst + 3);
            msum_old += matrixe[unn][follow];
        }
        for (let unn2 in result) {
            if (!matrixe[unn][unn2]) {
                matrixe[unn][unn2] = 0;
            }
        }
    }

    let mm = (process.env.matrixIterations || iterations);


    for (let i = 0; i < mm; i++) {
        let prold = pr;
        let matrixf = matrixe;

        pr = [];
        matrixe = [];
        let msum = 1;
        let intv = Math.pow(0.001 / rl, Math.pow(0.09, i / mm));
        console.log(`Completed ${i} iterations with ${intv} threshold`)

        let th = -1;
        for (let una in result) {
            th++;
            pr[una] = 0.1 / rl;
            matrixe[una] = [];
            if (frs[una].length == 0) {
                pr[una] = prold[una];
                matrixe[una] = matrixf[una];
                continue;
            }

            let ar = Object.keys(result);
            let rf = pr[una];
            let muna = matrixe[una];
            let muna2 = matrixe[una];

            for (let unb of ar) {
                let prb = prold[unb];

                muna[unb] = 0.03;
                let munb = muna2[unb];

                if (prb * munb < intv || fnc[unb] == 0) {
                    if (isNaN(mfb) || !munb) continue;
                    pr[una] += prb * munb;
                    continue;
                }

                
                for (let unc in result) {
                    let mfc = muna2[unc];
                    let mfb = matrixf[unc][unb];
                    if (isNaN(mfc) || isNaN(mfb) || !mfc || !mfb) continue;
                    matrixe[una][unb] += mfc * mfb;
                }

                msum += munb;
                pr[una] += prb * munb;
            }
        }


        for (let una in result) {
            if ((frs[una]).length == 0) continue;

            for (let unb in result) {
                matrixe[una][unb] *= msum_old / msum;
            }
        }

        let ov = Object.keys(pr);
        let new_sum = ov.filter(i => !isNaN(pr[i]) && main.indexOf(i) != -1).map(n => pr[n]).reduce((a, b) => a + b, 1e-9);
        let new_sum2 = ov.filter(i => !isNaN(pr[i]) && main.indexOf(i) == -1 && (domain_mode && new URL(i).host == new URL(main[0]).host)).map(n => pr[n]).reduce((a, b) => a + b, 1e-9);
        let new_sum3 = ov.filter(i => !isNaN(pr[i]) && main.indexOf(i) == -1 && !(domain_mode && new URL(i).host == new URL(main[0]).host)).map(n => pr[n]).reduce((a, b) => a + b, 1e-9);

        for (let unn of ov) {
            if (!result[unn]) {
                pr[unn] = 0;
            } else if ((domain_mode && new URL(unn).host == new URL(main[0]).host) && main.indexOf(unn) == -1) {
                pr[unn] /= new_sum2 * 3;
            } else if (main.indexOf(unn) == -1) {
                pr[unn] /= new_sum3 * (domain_mode ? 3 : 2);
            } else {
                pr[unn] /= new_sum * (domain_mode ? 3 : 2);
            }
        }

    }

    return pr;

}

export {
    rankCalc
}