/* GeneticAlgorithm.java
 * J Scott Cameron
 * 
 * This class controls a population of Genotypes 
 * for regenration using a Genetic Algorithm
 *
 * It uses the Java Reflection API so that
 * it is possible to change the fitness function
 * for new GA problems without having to touch this 
 * class
 */
 
import java.lang.reflect.*;
import java.util.*;
import java.io.*;
import Genotype;
import GenotypeComparator;

public class GeneticAlgorithm{
    
    private Genotype population[];/* population of Genotypes */
    private boolean crossover; /* boolean that control crossover */
    private boolean mutation; /* boolean that controls mutation */
    private int popSize; /* population size */
    private int genotypeLength; /* length of a genotype */
    private double mutationRate; /* rate at which mutations occur */
    private String fitnessFunction; /* name of the fitness function */
    private Random random; /* random object to be passed to genotypes */
    private Object target; /* Object that contains fitness function */
    private int sumFitness; /* sum of all the fitnesses in the population */
    private int lowestFitness; /* the worst fitness found */

    public GeneticAlgorithm()
    {
        
    }
    
    /* parameterized constructor 
     * the only non-obvious components are "target" and "fitnessFunction"
     * this is the name of the fitness function and the an instance of
     * the object which contains it
     */
    public GeneticAlgorithm(int genotypeLength, int popSize, 
                            boolean crossover, boolean mutation, 
                            double mutationRate, Object target, 
                            String fitnessFunction)
    {
        this.genotypeLength = genotypeLength;
        this.popSize = popSize;
        this.crossover = crossover;
        this.mutation = mutation;
        this.mutationRate = mutationRate;
        this.fitnessFunction = fitnessFunction;
        this.target = target;
    }
    
    /* initializes the population with random Genotypes */
    public void initPopulation()
    {
        random = new Random();
        population = new Genotype[popSize];

        for(int i=0;i<popSize;i++)
        {
            population[i] = new Genotype(genotypeLength,random);
        }
    }
    
    /* regenerates the population using crossover and/or mutation */
    public void regeneratePopulation()
    {
        Genotype nextGen[] = new Genotype[popSize];
        /* clone the best genotype into the next population */
        nextGen[0] = population[0];
        int i,j,k;
        
        sumFitness = 0;
        lowestFitness = worst().getRating()-1;
        
        /* find the adjusted sum of the fitnesses */
        for(i=0;i<popSize;i++)
        {
            sumFitness += (population[i].getRating()-lowestFitness);
        }
        
        
        /* create new population */
        for(i=1;i<popSize;i++)
        {
            /* if crossover is on then grab two genotypes and cross them
             * to produce a descendant */
            if(crossover)
            {
                nextGen[i] = new Genotype(RouletteSelection(),
                                          RouletteSelection(),
                                          random);
            }
            /* else just grab a genotype to clone */
            else
            {
                nextGen[i] = new Genotype(RouletteSelection(),random);
            }
            
            /* if mutation is on then mutate the new genotype */
            if(mutation)
            {
                nextGen[i].mutate(this.mutationRate);
            }
            
        }
        
        /* copy temp population in as the new population*/
        population = nextGen;
     
    }
    
    /*This grabs a Genotype from the population
     *the best ga's have a proportionally better chance
     *of being selected than their weaker brethren
     */
    public Genotype RouletteSelection()
    {
        
        /* If the sumfitness is 0 then return any of the population
         * this will only occur when all the individuals have exactly 
         * the same fitness */
        if (sumFitness == 0){
            return population[Math.abs(random.nextInt())%popSize];
        }
        /* else select a random individual based upon their fitness */
        else
        {
        int x = Math.abs(random.nextInt())%sumFitness;
        int count =0;
        
        for(int i=0;i <  popSize ;i++)
        {
            count+=(population[i].getRating()-lowestFitness);
            if(count >= x)
            {
                return population[i];
            }
        }
        }
        return population[popSize-1];
    }
    
    /* evaluates all the Genotypes in the population and sorts them*/
    public void evaluatePopulation()
    {
        /* iterate trough all the genotypes... */
        for(int i=0;i<popSize;i++)
        {
            /* get the method from the target object 
             * the parameters of this method is the
             * Genotype's bitset
             */
            try{
                Object[] args = {population[i].getBitSet()};
                Class [] parameters = new Class[] { 
                      population[i].getBitSet().getClass() };
                Class c = target.getClass();
                Method m =c.getMethod(fitnessFunction,parameters);
                
                population[i].setRating( 
                  ((Integer)m.invoke(target,args)).intValue() );
            }
            catch(InvocationTargetException e)
            {
                System.out.println(e);
            }
            catch(IllegalAccessException e)
            {
                System.out.println(e);
            }
            catch(NoSuchMethodException e)
            {
                System.out.println(e);
            }
        }

        /* sort the population */
        Arrays.sort(population,new GenotypeComparator());
    }
    

    /* returns a string wiith all the Bitsets printed out */
    public String toString()
    {
        StringWriter sw = new StringWriter();
        
        for(int i=0;i<popSize;i++)
        {
            sw.write(population[i].toString());
            sw.write("\n");
            
        }
        return sw.toString();
    }
    
    /* returns the worst genotype of the current population */
    public Genotype worst()
    {
        return population[population.length-1];
    }
    
    /* returns the best genotype of the current population */
    public Genotype best()
    {
        return population[0];
    }
    
    /* returns the average fitness of the current population */
    public double avg()
    {
        double total =0;
        for(int i=0;i<population.length;i++)
        {
            total += population[i].getRating();
        }
        return total/population.length;
        
    }       
}