package uk.ac.leeds.ccg.projects.MedAction.NeuralNetwork;

public class GeneticLearning implements java.io.Serializable{
    
    //private NeuroNetwork[] bestTwoNN=new NeuroNetwork[2];
    private NeuralNetwork tempNN = null;
    int mutationRate = 0;
    double[][] childrenWeight = null;
    double[][] parentWeight = null;
    private int childNumber = 0;
    private int singleParentNumber = 0;
    //training data x and y
    double[][] x = null;
    double[][] y = null;
    double[][] randomPopulation = null;
    //Vector moreWeight=new Vector();
    /** Creates a new instance of GeneticLearning */
    
    
    public GeneticLearning(int singleParentNumber, int childNumber, int mutationRate,int firstTimeRandom, NeuralNetwork temp,double[][] x,double[][] y) throws Exception{
        this.mutationRate = mutationRate;
        setChildNumber(childNumber);
        setParentNumber(singleParentNumber);
        this.x = x;
        this.y = y;
        //do a big random in this first time
        //randomPopulation = randomPopulation( firstTimeRandom, temp.getWeightsForGeneticLearning().length );
        randomPopulation = getRandomPopulation( firstTimeRandom, temp.getWeights() );
        tempNN = temp;
        System.out.println( firstTimeRandom + " random population done" );
        //selectionTwo();
        //bestNN=selection(singleParentNumber,this.totalW);
        parentWeight = selection( singleParentNumber, randomPopulation );
        childrenWeight = new double[singleParentNumber*childNumber][];
    }
    
    /**
     * After construct the Learning Object, this method will run the algorithm once and
     * return the best Neural Network in this round.
     */
    public NeuralNetwork runOnce() throws Exception{
        crossOver();
        mutationWithCrossOveredChildren();
        //mutationWithParentPopulation();
        selectAndReplace();
        double[][] theBest = selection( 1, parentWeight );
        this.tempNN.setWeightByGeneticLearning( theBest[ 0 ] );
        double[][] fire = tempNN.runNN( x );
        System.out.println( NNUtility.getRMS( fire, y ) );
        return this.tempNN;
    }
    
    public void crossOver() {
        double[][] parent = getParentWeight();
        int parentNum = parent.length;
        int childNum = getChildNumber();
        for ( int i = 0; i < parentNum; i ++ ) {
            
            for ( int j = 0; j < childNum; j ++ ) {
                setChildrenWeight( crossOverOnce( parent[ i ], parent[ randomMother( parentNum, i ) ] ), i * childNum + j );
            }
            
        }
        System.out.println( " Cross Over Done " );
        
    }
    
    private int randomMother( int total, int fatherIndex ) {
        
        int motherIndex = 0;
        
        do {
            motherIndex = new Double( Math.random() * total ).intValue();
        } while ( motherIndex == fatherIndex );
        
        return motherIndex;
        
    }
    
    private double[] crossOverOnce( double[] parent1, double[] parent2) {
        int crossOverPosition = new Double( Math.random() * parent1.length ).intValue();
        double[] offSpring = new double[ parent1.length ];
        
        for ( int i = 0; i < crossOverPosition; i ++ ) {
            offSpring[ i ] = parent1[ i ];
        }
        
        for ( int i = crossOverPosition; i < parent2.length; i ++ ) {
            offSpring[ i ] = parent2[ i ];
        }
        
        return offSpring;
        
    }
    
    
    private void mutationWithCrossOveredChildren() throws Exception{
        double[][] children = this.getChildrenWeight();
        
        for ( int i = 0; i < children.length; i ++ ) {
            // get a copy of a child array, in order to prevent confusing array reference
            double[] temp = new double[ children[ 0 ].length ];
            for ( int j = 0; j < temp.length; j ++ ) {
                temp[ j ] = children[ i ][ j ];
            }
            
            this.setChildrenWeight( mutation( temp, this.mutationRate ), i );
            
        }
        
        System.out.println("Genetic Learning Mutation Done");
    }
    
    public void setParentNumber(int parentNum){
        this.singleParentNumber=parentNum;
    }
    
    private  double[] getRandomWeightArray(int length){
        double[] temp = new double[length];
        for(int i=0;i<length;i++){
            temp[i]=Math.random();
        }
        return temp;
    }
    

    /**
     * @TODO docs
     */
     /*private double[][] randomPopulation(int length,int weightLength){
        double[][] random=new double[length][weightLength];
        for(int i=0;i<length;i++)
        {random[i] = this.getRandomWeightArray(weightLength);}
        return random;
    }*/
    private double[][] getRandomPopulation( int length, int weightLength){
        double[][] random=new double[length][weightLength];
        for(int i=0;i<length;i++)
        {random[i] = this.getRandomWeightArray(weightLength);}
        return random;
    }
    
    private void mutationWithParentPopulation() throws Exception{
        int parentLength = this.getParentWeight().length;
        
        for ( int i = 0; i < parentLength; i ++ ) {
            double[] tempBest = this.getParentWeight(i);
            for ( int j = i * this.childNumber; j < ( i + 1 ) * this.childNumber; j ++ ) {
                this.setChildrenWeight( mutation( tempBest, this.mutationRate ), j );
            }
        }
        
        System.out.println("Genetic Learning Mutation Done");
    }
    
    // replace the parent with only its own best child.
    private void selectAndReplace() throws Exception{
        double[][] tempChildren=new double[this.childNumber][];
        for(int i=0;i<this.singleParentNumber;i++){
            for(int j=0;j<this.childNumber;j++){
                tempChildren[j]=this.getChildrenWeight(i*this.childNumber+j);
            }
            //get the best child RMS for this selection
            double[][] temp = selection(1,tempChildren);
            
            this.tempNN.setWeightByGeneticLearning(temp[0]);
            double[][] fire = tempNN.runNN( x );
            double tempRMS=NNUtility.getRMS(fire,y);
            
            //get the corresponding parent's RMS
            this.tempNN.setWeightByGeneticLearning(this.getParentWeight(i));
            fire = tempNN.runNN( x );
            
            if(NNUtility.getRMS(fire,y) > tempRMS) this.setParentWeight(temp[0],i);
            
        }
        System.out.println("best child selection from chirdren population done");
    }
    /*
    private NeuroNetwork[] selection(int num,double[][] inTotalWeight){
     
        double temp=tempNN.RMS;
        double lastBest=0.0;
        NeuroNetwork[] bestNN=new NeuroNetwork[num];
        int bestPosition=0;
        double[][] totalW=inTotalWeight;
        double[] rms=new double[totalW.length];
        // get all the fire using all weights array
        for(int i=0;i<rms.length;i++)
        {
        tempNN.setWeightByGeneticLearning(totalW[i]);
        rms[i]=tempNN.RMS;
     
     
        }
     
        //compare rms, get the best single parent
        temp=rms[0];
        for(int i=0;i<num;i++){
     
            for(int j=1;j<totalW.length;j++) {
                if((temp>rms[j])&&(rms[j]>lastBest)) {temp=rms[j];bestPosition=j;}
     
            }
     
            bestNN[i]=new NeuroNetwork(layerNumber,neuroNumber,rate,alfa,x,y);
            bestNN[i].setWeightByGeneticLearning(totalW[bestPosition]);
            bestNN[i].getFire();
            lastBest=bestNN[i].RMS;
            System.out.println("best selection from population " + i +" done");
            System.out.println(System.currentTimeMillis());
        }
     
     
        return bestNN;
    }
     */
    
    private double[][] selection( int num, double[][][] inTotalWeight ) throws Exception{
        double[][] fire = tempNN.runNN( x );
        double temp=NNUtility.getRMS(fire,y);
        double[][] bestW=new double[num][];
        double[][] totalW=inTotalWeight;
        double[] rms=new double[totalW.length];
        int lastBestPosition=0;
        int thisBestPosition=0;
        
        // get all the fire using all weights array
        for(int i=0;i<rms.length;i++) {
            tempNN.setWeightByGeneticLearning(totalW[i]);
            fire = tempNN.runNN( x );
            rms[i] = NNUtility.getRMS(fire,y);
            System.out.println("Run NN population " + i + " Get RMS Done");
        }
        
        //compare rms, get the best single parent
        for(int i=0;i<num;i++){
            temp=rms[0];
            for(int j=1;j<totalW.length;j++) {
                if((rms[j]<temp)&&(rms[j]>rms[lastBestPosition])) {temp = rms[j];thisBestPosition=j;}
            }
            bestW[i]=this.getNewArray(totalW[thisBestPosition]);
            lastBestPosition=thisBestPosition;
            System.out.println("best selection from population " + i +" done");
        }
        return bestW;
    }
    
    private double[] mutation(double[] in,int mutationRate){
        double[] temp = new double[in.length];// for return
        for(int i=0;i<in.length;i++) {
            temp[i]=in[i];
        }
        // mutation the weight array by mutationRate time
        for(int i=0;i<mutationRate;i++){
            // get a random int used as the index of a weight in the array to be mutated
            int random=NNUtility.randomInt(temp.length);
            // small amount value to adjust the random indexed weight in the array
            double smallAmount=Math.random()/Math.pow(10.0,NNUtility.randomInt(5));
            // random plus or minus
            if(NNUtility.randomInt(1000)%2==0)
                temp[random]=temp[random] + smallAmount;
            else
                temp[random]=temp[random] - smallAmount;
            
        }
        
        return temp;
    }
    
    public void setParentWeight(double[][] best) {
        this.parentWeight=new double[best.length][];
        for(int i=0;i<best.length;i++) {
            setParentWeight(best[i],i);
        }
    }
    
    public void setChildNumber(int cNum) {
        this.childNumber=cNum;
    }
    
    public void setParentWeight(double[] weight, int index) {
        this.parentWeight[index]=new double[weight.length];
        for(int i=0;i<weight.length;i++){
            this.parentWeight[index][i]=weight[i];
        }
    }
    
    public void setChildrenWeight(double[][] total) {
        this.childrenWeight=new double[total.length][];
        for(int i=0;i<total.length;i++) {
            setChildrenWeight(total[i],i);
        }
    }
    public void setChildrenWeight(double[] one,int index) {
        this.childrenWeight[ index ] = new double[ one.length ];
        for( int i = 0;i < one.length; i ++ ) {
            this.childrenWeight[ index ][ i ] = one[ i ];
        }
        
    }
    
    public double[][] getChildrenWeight() {
        double[][] total=new double[this.childrenWeight.length][];
        for(int i=0;i<total.length;i++)
        {total[i]=getChildrenWeight(i);}
        
        return total;
    }
    public double[] getChildrenWeight(int index){
        double[] one = new double[this.childrenWeight[index].length];
        for(int i=0;i<one.length;i++)
            one[i]=this.childrenWeight[index][i];
        return one;
    }
    
    public double[][] getParentWeight() {
        double[][] parent=new double[this.parentWeight.length][];
        for(int i=0;i<parent.length;i++)
        {parent[i]=getParentWeight(i);}
        
        return parent;
    }
    private double[] getNewArray(double[] old){
        double[] temp=new double[old.length];
        for(int i=0;i<temp.length;i++){
            temp[i]=old[i];
        }
        return temp;
    }
    
    public double[] getParentWeight(int index){
        double[] one=new double[this.parentWeight[index].length];
        for(int i=0;i<one.length;i++)
            one[i]=this.parentWeight[index][i];
        return one;
    }
    
    public int getChildNumber() {
        return this.childNumber;
    }
    
}