package figures;

import jimena.analysis.ConvergenceComparator;
import jimena.analysis.FunctionsAnalysis;
import jimena.analysis.NetworkGenerator;
import jimena.binaryrn.RegulatoryNetwork;
import jimena.calculationparameters.SSSearchParameters;
import jimena.calculationparameters.StandardSSSSearchParameters;
import jimena.libs.MathLib;
import jimena.simulationmethods.SQUADMethod;

public class CentralitiesOutgoing {

    public static void main(String[] args) {
        final int simulations = 2000;
        SSSearchParameters parameters = new StandardSSSSearchParameters(new SQUADMethod(), 0.05);
        ConvergenceComparator comparator = new ConvergenceComparator(simulations, parameters);

        for (int reps = 0; reps < 1000000000; reps++) {
            boolean erOrSf = Math.random() < 0.5 ? true : false; // true = ER, false = SF
            int size = 15;
            int connections = 25;
            int cycles = MathLib.getRandom().nextInt(5);
            double act = Math.random();
            boolean inputLoops = false;

            RegulatoryNetwork network;
            if (erOrSf) {
                network = NetworkGenerator.constructERnetwork(size, connections, cycles, inputLoops, act);
            } else {
                network = NetworkGenerator.constructSFnetwork(size, connections, cycles, inputLoops, act);
            }

            if (network == null) {
                continue;
            }

            try {
                double[][] matrixTC;
                matrixTC = FunctionsAnalysis.totalCentralityMatrix(network, comparator);

                if (matrixTC == null) {
                    continue;
                }

                double[][] matrixNDC;
                matrixNDC = FunctionsAnalysis.nonDynamicCentralityMatrix(network, simulations, parameters);

                if (matrixTC == null || matrixNDC == null) {
                    continue;
                }

                double[] ndcCentralities = FunctionsAnalysis.centralitiesFromMatrix(matrixNDC);
                double[] tcCentralities = FunctionsAnalysis.centralitiesFromMatrix(matrixTC);
                double[] ndcSensitivities = FunctionsAnalysis.sensitivitiesFromMatrix(matrixNDC);
                double[] tcSensitivities = FunctionsAnalysis.sensitivitiesFromMatrix(matrixTC);

                for (int i = 0; i < network.nodeCount(); i++) {
//                    if (!(network.getInputsByTarget(i).size() == 5 || network.getInputsBySource(i).size() == 5)) {
//                        continue;
//                    }

                    System.out.print(ndcCentralities[i] + "\t");
                    System.out.print(FunctionsAnalysis.dynamicCentrality(network, i, 200, 200, parameters) + "\t");
//                     System.out.print("\t");
                    System.out.print(tcCentralities[i] + "\t");
                    System.out.print(ndcSensitivities[i] + "\t");
                    System.out.print(tcSensitivities[i] + "\t");

                    System.out.print(network.cycleIndex(i, true) + "\t");
                    System.out.print(network.cycleIndex(i, false) + "\t");
                    System.out.print(network.getInputsBySource(i).size() + "\t");
                    System.out.print(network.getInputsByTarget(i).size() + "\t");

                    System.out.print(size + "\t");
                    System.out.print(connections + "\t");
                    System.out.print(cycles + "\t");
                    System.out.print(act + "\t");
                    System.out.print((erOrSf ? "er" : "sf") + "\t");
                    System.out.print((inputLoops ? "inputLoops" : "noInputLoops") + "\t");
                    System.out.print(network.hasLoop(i) + "\t");
                    System.out.print("\n");
                }
            } catch (NullPointerException e) {
                continue;
            }

        }

    }
}