/*====================================================/
/ Name:    genmus.h                                   /
/ Author:  Joy Schoenberger                           /
/ Date:    April 2002                                 /
/ Purpose: Header file containing data structures for /
/          CS710 Masters research project: Genetic    /
/          Algorithms for Musical Composition with    /
/          Coherency Through Genotype                 /
/====================================================*/

#include <math.h>
#include <fstream.h>
#include "bitFunctions.h"
#include <ctype.h>

#define numChords 8
#define numIntervals 25
#define numPhrasePatterns 8
#define numSemiTones 12
#define numBeats 32
#define convert "CdDeEFgGaAbBCdDeEFgGaAbBCdDeEFgGaAbBCdDeEFgGaAbBCdDeEFgGaAbBC"
#define bitKey 3418u
#define numPhrases 4

struct Chord{
  int numNotes;
  unsigned int semitones;
  void initialize(){
    semitones = clearAll();
  }
  void setTone(int n){
    semitones = setBit(semitones,n);
  }
  bool isOn(int n){
    return (isSet(semitones,n));
  }
  bool adj(int a, int b){
    char aLet, bLet;
    aLet = toupper(convert[a]);
    bLet = toupper(convert[b]);
    if(aLet == bLet) return true;
    if( ((aLet-1) == bLet)||((aLet+1) == bLet) ) return true;
    if((aLet == 'A') && (bLet == 'G')) return true;
    if((aLet == 'G') && (bLet == 'A')) return true;
    return false;
  }
  bool dissonant(){
    // if any two pitches in the chord share the same 
    // conversion letter, the chord is dissonant
    for(int i = 0;i<11;i++){
      for(int j = i+1;j<12;j++){
	if(isSet(semitones,i) && isSet(semitones,j) &&
	   adj(i,j)) return true;
      }
    }
    return false;
  }
  void display(){
    for(int i = 0;i<numSemiTones;i++)
      if(isSet(semitones,i)) cout << i << " ";
    cout << endl;
  }
}; // end Chord

struct Note {
  // notes 0 to 60 translate
  // to MIDI values 31 to 91
  unsigned int played1; // 0 to 30
  unsigned int played2; // 31 to 60
  void initialize(){
    played1 = clearAll();
    played2 = clearAll();
  }
  void setPlay(int n){
    if(n < 31)
      played1 = setBit(played1,n);
    else
      played2 = setBit(played2,n-31);
  }
  void unPlay(int n){
    if(n < 31)
      played1 = unset(played1,n);
    else
      played2 = unset(played2,n-31);
  }
  void copyNote(Note& dest){
    for(int i = 0;i<31;i++)
      if(dest.isPlayed(i)) setBit(played1,i);
    for(int i = 31;i<61;i++)
      if(dest.isPlayed(i)) setBit(played2,i-31);
  }
  bool isPlayed(int n){
    if(n < 31)
      return (isSet(played1, n));
    else return (isSet(played2,n-31));
  }
  int getNth(int n){
    int index = -1;
    for(int pindex = 0;pindex<n;pindex++){
      index++;
      while(!isSet(played1,index) && index < 31)index++;
      if(index >30) while(!isSet(played2,index-31))index++;
    }
    return index;
  }

  bool isEmpty(){
    for(int i = 0;i<31;i++)
      if(isSet(played1,i))return false;
    for(int i = 31;i<61;i++)
      if(isSet(played2,i-31))return false;
    return true;
  }
  
  void display(){
    for(int k = 0;k<31;k++)
      if(isSet(played1,k)) cout << k << "(" << convert[k] << ") ";
    for(int k = 31;k<61;k++)
      if(isSet(played2,k-31)) cout << k << "(" << convert[k] << ") ";     cout << endl;
  }
  
  int min(){
    int k = 61;
    while((!isSet(played2,k-31))&&(k>30)) k--;
    if(k == 30) while((!isSet(played1,k))&&(k>-1)) k--;
    return k;
  }

  int max(){
    int k = 0;
    while((!isSet(played1,k))&&(k<31)) k++;
    if(k == 31) while((!isSet(played2,k-31))&&(k<62)) k++;
    return k;
  }
  
  Chord compress(){
    // compress note into one octave
    Chord retChord;
    retChord.initialize();
    int sounded;
    for(int n = 0; n<12; n++){ 
      for(int octave = 0;octave < 5; octave++){
	sounded = n + octave * 12;
	if((sounded < 31)&&(isSet(played1,sounded)))
	   retChord.setTone(n);
	else if((sounded >30)&&(isSet(played2,sounded-31)))
	  retChord.setTone(n);
      }
    }
    return retChord;
  }

  int numInCommon(Note compare){
    int ret = 0;
    for(int i = 0;i<31;i++)
      if(compare.isPlayed(i) && isSet(played1,i)) ret++;
    for(int i = 31;i<61;i++)
      if(compare.isPlayed(i) && isSet(played2,i-31)) ret++;
    return ret;
  }
  
  int numVoices(){
    int ret = 0;
    for(int i = 0;i<31;i++){
      if(isSet(played1,i)) ret++;
      if(isSet(played2,i)) ret++;
    }
    return ret;
  }

};

struct Phrase {
  Note notes[numBeats];
  void initialize(){
    for(int i = 0; i < numBeats; i++)
      notes[i].initialize();
  }
  void display(){
    for(int i = 0;i<numBeats;i++){
      cout << i+1 << ": ";
      notes[i].display();
    }
  }
};

struct Song {
  Phrase phrases[numPhrases];
  void initialize(){
    for(int i = 0;i<4;i++)
      phrases[i].initialize();
  }
  void display(){
    for (int i = 0;i<4;i++){
      cout << " Phrase " << i << endl;
      cout << "===========" << endl;
      phrases[i].display();
    }
  }
};

struct IntervalMap{
  unsigned int intervals;
  // 0-11 corresponds to -12 through -1
  // 12 corresponds to 0
  // 13-24 correspond to 1 through 12
  void initialize(){
    intervals = clearAll();
  }
  void setValid(int n){
    intervals = setBit(intervals,n);
  }
  bool isValid(int n){
    return (isSet(intervals,n));
  }
};


struct DNA {

  // ====== The following three genes will cross-breed ========
  // ====== within the genes themselves =======================
  Chord validNotes[numChords];
  // set of valid notes in succession
    
  int numActualChords;
  IntervalMap validIntervals[numBeats];

  int phrasePatterns[numPhrasePatterns];
  // 4-digit combination of numbers 1,2,3, and 4

  // ====== min/max values ===================================
  int minChordLen; // mininum length of a chord (0 to 16)
  int maxChordLen; // maximum length of a chord (0 to 16)
  int minVoices;   // min number of concurrent voices (0 to 12)
  int maxVoices;   // max number of concurrent voices (0 to 12)
  int maxRange;    // distance between highest & lowest note of phrase (0 to 36)
  int maxConRange; // distance between highest & lowest consecutive notes (0 to 36)

};  // end struct DNA

struct keys{
  unsigned int scales[12]; // scales[i] contains diatonic
                           // set for key of i
  void initialize(void){
    scales[0] = 2741;
    for(int i = 1;i<12;i++){
      scales[i] = scales[i-1]<<1;
      if(isSet(scales[i-1],11)){
	scales[i]-=4096;
	scales[i]+=1;
      }
    }
  }

  int numOffKey(unsigned int toCheck, int index){
    // return the number of pitches by which
    // toCheck differs from the indexed
    // diatonic collection 
    unsigned int diffString = toCheck | scales[index];
    diffString = diffString ^ scales[index];
    return numSet(diffString);
  }

  void display(){
    Note aScale;
    aScale.initialize();
    for(int i = 0;i<12;i++){
      aScale.played1 = scales[i];
      aScale.display();
    }
  }

};

double judge(Song composition);