package test.thaliana;

import java.io.File;
import java.util.ArrayList;

import jimena.binaryrn.NetworkInput;
import jimena.binaryrn.RegulatoryNetwork;
import jimena.calculationparameters.StandardSSSearchParameters;
import jimena.libs.NetworkAnalyzer;
import jimena.libs.StringLib;
import jimena.simulationmethods.NormalizedHillCubeMethod;
import jimena.sssearcher.RandomSearcher;
import jimena.sssearcher.SSSSearchResult;

public class ThalianaMutationsBasins {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // Create a new GRN
        RegulatoryNetwork network = new RegulatoryNetwork();

        try {
            network.loadYEdFile(new File(
                    "G:\\secondpaper\\realnetworks\\Thaliana\\Arabidopsis Floral Organ Fate Determination 2010 Real Boolean Functions.graphml"));
        } catch (Exception e) {
            e.printStackTrace();
        }

        StringLib.printDiscreteSSS(network.getNodeNames(), network.discreteStableSteadyStates());
//        System.out.println(basinOfInflStates(network));

        BasinAnalyzer analyzer = (new ThalianaMutationsBasins()).new BasinAnalyzer();
        mutationAnalysis(network, 2, analyzer);
    }

    public static double basinOfInflStates(RegulatoryNetwork network) {
        final int starts = 500;
        int basin = 0;
        SSSSearchResult sss = network.stableSteadyStatesWithCounter(starts, new StandardSSSearchParameters(new NormalizedHillCubeMethod(),
                0.05), new RandomSearcher());
        for (int i = 0; i < sss.getResults().size(); i++) {
            if ((sss.getResults().get(i)[3] > 0.5) && (sss.getResults().get(i)[11] > 0.5)) {
                basin += sss.getCounter().get(i);
            }
        }

        return ((double) basin) / starts;
    }

    public static void mutationAnalysis(RegulatoryNetwork original, ArrayList<NetworkInput> usedInputs, NetworkInput curInput,
            int numberOfMutations, NetworkAnalyzer analyzer) {
        if (numberOfMutations == 0) {
            return;
        }

        if (original.getNextInput(curInput) != null) {
            mutationAnalysis(original, usedInputs, original.getNextInput(curInput), numberOfMutations, analyzer);
        }

        // RegulatoryNetwork mutated = original.cloneClean();
        //
        // @SuppressWarnings("unchecked")
        // ArrayList<NetworkInput> newUsedInputs = (ArrayList<NetworkInput>) usedInputs.clone();
        // newUsedInputs.add(curInput);
        // mutated.addNullMutation(newUsedInputs);
        // analyzer.run(mutated, original.getInputString(newUsedInputs));

        @SuppressWarnings("unchecked")
        ArrayList<NetworkInput> newUsedInputs = (ArrayList<NetworkInput>) usedInputs.clone();
        newUsedInputs.add(curInput);
        original.addNullMutation(newUsedInputs);
        analyzer.run(original, original.getInputString(newUsedInputs));
        original.restore();

        if (original.getNextInput(curInput) != null) {
            mutationAnalysis(original, newUsedInputs, original.getNextInput(curInput), numberOfMutations - 1, analyzer);
        }
    }

    public static void mutationAnalysis(RegulatoryNetwork original, int numberOfMutations, NetworkAnalyzer analyzer) {
        mutationAnalysis(original, new ArrayList<NetworkInput>(), original.getFirstInput(), numberOfMutations, analyzer);
    }

    private class BasinAnalyzer extends NetworkAnalyzer {

        @Override
        public void run(RegulatoryNetwork network) {
            // DUMMY
        }

        @Override
        public void run(RegulatoryNetwork network, String description) {            
            System.out.print(description + ": ");
//            if (description.equals("{ AP1 => TFL1 }")) {
                double basin = basinOfInflStates(network);
                System.out.println(basin);
//            }

        }
    }
}