/**
 * Created with IntelliJ IDEA.
 * User: rebeccamancy
 * Date: 07/11/2013
 * Time: 11:32
 * To change this template use File | Settings | File Templates.
 */
public class QSDOld {

    // QSD slice contains a 2xN array containing time spent (row 1) in states (row 2); states in decimal
    private double[] QSDTimes;  // 2 row array of times and states
    private String[] QSDStates; // Store as strings as there could be lots of patches / states
    private int[] QSDNumActive; // Store num patches active to help with indexing
    private int arrPointer; // Pointer to the current number of states stored (array index)
    private double totalTime;
    private double maxTime;

    /**
     * This doesn't appear to be used ...
     * @param QSDTimes
     * @param QSDStates
     * @param QSDNumActive
     */
    public QSDOld(double[] QSDTimes, String[] QSDStates, int[] QSDNumActive) {
        this.QSDTimes = QSDTimes;
        this.QSDStates = QSDStates;
        this.QSDNumActive = QSDNumActive;
    }


    public QSDOld(int maxIndexed) {
        this.QSDTimes = new double[maxIndexed];
        this.QSDStates = new String[maxIndexed];
        this.QSDNumActive = new int[maxIndexed];
        arrPointer = 0; totalTime = 0;
    }

/*    *//**
     * Construct the QSD
     * @param eco
     * @param numSims
     * @param timeWindowLength
     * @param numDraws
     * @param rhatThreshold
     *//*
    public QSD(Ecology eco, int numSims, int timeWindowLength, int numDraws, double rhatThreshold, int maxIndexed) {
        this.QSDTimes = new double[maxIndexed];
        this.QSDStates = new String[maxIndexed];
        this.QSDNumActive = new int[maxIndexed];
        arrPointer = 0; totalTime = 0;

        int numPatches = eco.getHab().getNumPatches();
        double[] rhat = new double[numPatches];    // assume zero initialisation far enough away from one

        // Initialise the simulators (one per "run")
        Simulator[] sims = new Simulator[numSims]; // one per "run"
        for (int sim=0; sim<numSims; sim++) {
            sims[sim] = new Simulator(eco, numDraws, timeWindowLength);   // initialise the simulators
        }

        // Initialise the sequences (one per patch; each has numSim chains in it)
        Sequences[] seqs = new Sequences[numPatches]; // one per patch, each has numSim chains in it
        double[] zeros = new double[numSims];
        for (int seq=0; seq<numPatches; seq++) {
            seqs[seq] = new Sequences(0,zeros,zeros);
        }

        // Storage for patch status for each patch at each of the drawpoints
        int[][] curSlice = new int[numSims][numDraws]; // holds state at each drawpoint for one patch

        // Simulate until convergence of chains
        // Keep simulating until the rhat value for each *patch* has converged
        QSD testqsd = new QSD(maxIndexed);
        while (Util.largestAbsVal(Util.minus(rhat,1)) > rhatThreshold) {
            // Simulate the next time window, collecting states at sample points into an array (rows=sample points; cols=seqs)
            for (Simulator sim:sims) {
                testqsd = sim.runDeOliveira(numSims, timeWindowLength, false, maxIndexed);
            }
            // For each patch, collect current excerpts per patch from sim into array, update sequences, and calculate rhat
            for (int patch = 0; patch<numPatches; patch++) {
                for (int s = 0; s < numSims; s++) {
                    curSlice[s] = sims[s].getExcerptPatch(patch);
                }
               rhat[patch] = seqs[patch].testConvergence(Util.transposeMatrix(Util.int2dbl(curSlice)));
            }
            System.out.print("rhat values: "); Util.print(rhat);
        }

*//*        // Now simulate a stretch to give us the QSD, up until 10x maximum number of events required for convergence amongst the chains
        int numEvents = 0;
        for (Simulator sim: sims) {
            if (sim.getNumEvents() > numEvents) {
                numEvents = sim.getNumEvents();
            }
        }
        numEvents = 10*numEvents;
        // Run forward on simulator 0, resetting time to zero for start
        sims[0].setTime(0);
        sims[0].run4QSD(this,numEvents,false);  // Using the first simulator
        //Util.print(QSDTimes);
        // Output as binary strings
        for (int i=0; i<QSDStates.length; i++) {
            System.out.print(" " + QSDStates[i]);
        }
        System.out.println();
        // Output as state ids    ... breaks for large networks ... (for comparison with matlab code)
        for (int i=0; i<QSDStates.length; i++) {
            System.out.print(" " + Util.bi2de(Util.biStr2biArr( QSDStates[i])));
        }
        System.out.println();*//*
    }*/

    public void addState(int numPatchesAlive, String currState, double timeInState ) {
        Boolean found = false;
        for (int i=0; i<arrPointer; i++) {
            // Check all array elements with the right number of patches alive to see if one matches
            //System.out.println(arrPointer);
            //Util.print(QSDTimes);
            if (QSDNumActive[i] == numPatchesAlive) {
                if(QSDStates[i].equals(currState) ){
                    found = true;
                    QSDTimes[i] = QSDTimes[i] + timeInState;
                }
            }
        }
        if (!found) {
            // Haven't found this state in the existing array
            QSDNumActive[arrPointer] = numPatchesAlive;
            QSDStates[arrPointer] = currState;
            QSDTimes[arrPointer] = timeInState;
            arrPointer ++;
        }
        // update total time stored in QSD so far ...
        totalTime = totalTime + timeInState;
    }

    public void setQSDTimes (double[] QSDTimes) {
        this.QSDTimes = QSDTimes;
    }

    public void setQSDStates (String[] QSDStates) {
        this.QSDStates = QSDStates;
    }

    public void setMaxTime(double time) {
        this.maxTime = time;
    }
    public int getArrPointer() {
        return this.arrPointer;
    }

    /**
     * Draw a state from the QSD returned as an array of integers 0-1 for each patch
     * @return
     */
    public int[] drawFromQSD() {
        int index = 0;
        double p = Math.random() * this.totalTime;
        double cumulTime = 0;
        for (int ind = 0; ind < QSDTimes.length; ind ++) {
            cumulTime = cumulTime + QSDTimes[ind];
            if (p < cumulTime) {   // if p falls in this segment
                index = ind;
                break;
            }
        }
        String state = QSDStates[index];
        return Util.biStr2biArr(state);
    }

    public String toString() {
        String mystring = "";
        for (int i = 0; i<QSDTimes.length; i++) {
            mystring = mystring + QSDStates[i] + ", " + QSDNumActive[i]+ ", " + QSDTimes[i] + "\n";
        }
        return mystring;
    }

    public String toStringTruncated() {
        String mystring = "";
        for (int i = 0; i<arrPointer; i++) {
            mystring = mystring + QSDStates[i] + ", " + QSDNumActive[i]+ ", " + QSDTimes[i] + "\n";
        }
        return mystring;
    }
}