/*====================================================/
/ Name:    generate.cc                                /
/ Author:  Joy Schoenberger                           /
/ Date:    April 2002                                 /
/ Purpose: Implementation of genetic algorithm for    /
/          CS710 Masters research project: Genetic    /
/          Algorithms for Musical Composition with    /
/          Coherency Through Genotype                 /
/====================================================*/

#include "composer.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "rvgs.h"

int main(int argc, char *argv[]){
  
  bool badUsage = false;
  double scoreLimit = 0.85;
  int numGenerations = 50;
  int numComposers = 60;
  long seed = -1;
  int numMutations = 0;
  bool display = false;

  for(int i = 1;i<argc && !badUsage;i++){
    if(strcmp(argv[i],"-d")==0){
      display = true;
    }//end else if -s flag
    else if(strcmp(argv[i],"-s")==0){
      if(i<argc) seed = atol(argv[i+1]);
      else {
	badUsage = true;
	printf("else argc>=i\n");
      }
      if((seed > 1018600000)||(seed<1)){
	printf("Please select a seed from 1 to 1018600000\n");
	badUsage = true;
      }
      i++;
    }//end else if -s flag
    else if(strcmp(argv[i],"-l")==0){
      if(i<argc) scoreLimit = atof(argv[i+1]);
      else badUsage = true;
      if((scoreLimit <= 0.0)||(scoreLimit > 1)){
        printf("Please select a limit between 0 and 1\n");
        badUsage = true;
      }
      else numGenerations = 500;
      i++; 
    }//end if -l flag
    else if(strcmp(argv[i],"-p")==0){
      if(i<argc) numComposers = atoi(argv[i+1]);
      else badUsage = true;
      if(numComposers < 0){
        printf("Please select a population greater than 0\n");
        badUsage = true;
      }
      i++; 
    }//end if -l flag
    else if(strcmp(argv[i],"-g")==0){
      if(i<argc) numGenerations = atoi(argv[i+1]);
      else badUsage = true;
      if(numGenerations < 1){
        printf("Please select num generations greater than 0\n");
	badUsage = true;
      }
      else scoreLimit = 1.0;
      i++; 
    }// end else if -g flag
    else 
      badUsage = true;
  }//end for 

  if(badUsage){
    printf("\nUsage: generate [-g numGenerations] [-l scoreLimit] [-p population] [-s seed] [-d]\n");
    printf("       default: 50 generations or until average scoreof 0.85, whichever comes\n");
    printf("                first, with population of 60 composers and a random seed \n");
    printf("                -d displays a song by the best composer of the last generation\n");
    return 0;
  }

  PutSeed(seed);  // seed the random number generator
  GetSeed(&seed);

  cout << endl << "Initial seed: " << seed << endl << endl;

  Composer Population[numComposers];
  int parents[numComposers];
  int tempScore, gen;
  Composer tmpComposer;
  double rawScores[numComposers];
  double avgScore = 0;
  double scoreSum;
  double maxScore = 0;
  double improvement, imSum, prevAvg;
  Song composition;
  Composer offspring[numComposers];

  imSum = 0;
  for(gen = 0;(gen < numGenerations)&&(avgScore < scoreLimit);gen++){

    //Repopulate
    if(gen > 0){
      for(int i = 0;i<numComposers;i++){
	delete(Population[i].genMap);
	Population[i].genMap = NULL;
	Population[i].genMap= offspring[i].genMap;
	offspring[i].genMap = NULL;
      }//end for
    }

    printf("Generation #%d...",gen+1);
    fflush(stdout);
    scoreSum = 0;
    maxScore = -1;
    for(int comp = 0;comp<numComposers;comp++){
      printf("."); 
      fflush(stdout);
      composition.initialize();
      composition = Population[comp].composeSong();
      rawScores[comp] = judge(composition);
      /*
      printf("%6.3f ",rawScores[comp]);
      fflush(stdout);*/
      if (rawScores[comp] > maxScore) maxScore = rawScores[comp];
      scoreSum+= rawScores[comp];
    }
    avgScore = scoreSum/(double)numComposers;

    printf("\n    Average score = %6.4f\n",avgScore);
    printf("    Max Score = %6.4f\n",maxScore);
    if(gen>0){
      improvement = avgScore-prevAvg;
      printf("   Improvement = %6.4f\n",improvement);
      imSum+=improvement;
    }
    prevAvg = avgScore;
    fflush(stdout);

    // Convert raw scores to fitness value
    double fitness[numComposers];
    double mult = 1.5; //factor by which max fitness favored over average
    double slope = ((mult-1)*avgScore)/(maxScore-avgScore);
    double constVal = (avgScore*(maxScore-mult*avgScore))/(maxScore-avgScore);
    double fitAvg = 0.0;
    double fitSum = 0.0;
    /*
    printf("slope = %4.3f\n",slope);
    printf("constVal = %4.3f\n",constVal);
    */
    for(int i = 0;i<numComposers;i++){
      fitness[i] = slope*rawScores[i]*constVal;
      fitSum+=fitness[i];
    }
    fitAvg = fitSum/numComposers;

    // Convert fitness values to expected frequency of selection as parents
    double selFreq[numComposers];
    for(int i = 0;i<numComposers;i++)
      selFreq[i] = fitness[i]/fitAvg;

    // select parents according to selection frequency
    // Phase 1: assign parents according to integer part 
    // of their expected frequencies

    int k = 0; // index for parent array
    int expected;
    for(int i = 0;i<numComposers;i++){
      expected = (int)selFreq[i];     // assign this much now
      selFreq[i] -= (double)expected; // save fractional remainder
      while(expected--)
	parents[k++] = i;
    }

    // Phase 2: randomly select individuals with probability equal
    // to their remaining fractional expectation

    double rand;
    int pick;
    while(k<numComposers){
      rand = Random();
      pick = Equilikely(0,numComposers-1);
      if(selFreq[pick]>=rand){
	parents[k++] = pick;
	selFreq[pick]-=1.0;
      }
    }
 
    // Randomly pair up parents for reproduction
    bool mated[numComposers];
    int parentsLeft = numComposers;
    int osIndex = 0;
    for(int i = 0;i<numComposers;i++) mated[i] = false;
    while(parentsLeft>0){
      int mom, dad, index;
      pick = Equilikely(1,parentsLeft);
      index = 0;
      for(int pindex = 1;pindex<pick;pindex++)
	while(mated[index])index++;
      mom = parents[index];
      mated[index] = true;
      pick = Equilikely(1,parentsLeft);
      index = 0;
      for(int pindex = 1;pindex<pick;pindex++)
	while(mated[index])index++;
      dad = parents[index];
      mated[index] = true;
      offspring[osIndex++].genMap = Population[mom].crossBreed(Population[dad]);
      offspring[osIndex++].genMap = Population[dad].crossBreed(Population[mom]);
      parentsLeft-=2;
    }//end while

    // Mutate
    pick = Equilikely(1,1000); // 1 in a 1000 chance
    if(pick == 1){
      printf("**** Mutation ****\n");
      pick = Equilikely(0,numComposers-1); // pick mutant randomly
      offspring[pick].mutate();  // give random DNA
      numMutations++;
    }
  }

  printf("Average Improvement is %6.4f per generation\n",imSum/(double)(gen-1));
  if(numMutations > 0) printf("Number of mutations: %d\n",numMutations);

  if(display){
    printf("Song by the best Composer of the last generation:\n");
    int compIndex = 0;
    for(int i = 0;i<numComposers;i++)
      if(rawScores[i] == maxScore) compIndex = i;
    composition = Population[compIndex].composeSong();
    composition.display();
  }

  return 1;
}