import java.util.Vector;
import jm.music.data.CPhrase;
import jm.music.data.Note;
import jm.constants.RhythmValues;

/**
 * ChordProgression represents the sequence of chords that the piano will play.
 * @author Leslie Chong and Matthew Lipson
 */
public class ChordProgression extends CPhrase {
	// The style factory which will coordinate the various stylistic elements
	private AbstractStyleFactory style = new StandardStyleFactory();
	
	// The voice leading algorithm
	private VoiceLeading lead = style.createVoiceLeading();
	
	// The chords that make up the progression
	private Vector<Chord> chords;
	
	/**
	 * ChordProgression will take in a vector of unvoiced chords. It will then set a voicing and offset for each chord.
	 * Ultimately the voicings will be done by voice leading algorithms, and the offsets will be done probablistically.
	 * @param chds The unvoiced chords. Cannot be null.
	 */
	public ChordProgression(Vector<Chord> chds){
		super();
		assert chds != null;
		this.chords = chds;
		Voicings voicingStyle = style.createVoicings();
		int[][] voicing;
		Chord c = null;
		Vector<Note> notes;
		
		// Lead the chords
		chords = lead.lead(chords);
		
		// Offset the chords
		try{
			offset();
		} catch (ChordNotVoicedException e){
			System.out.println("Tried to offset an unvoiced chord");
		}
		
		for (int x=0; x<chords.size(); x++){
			c = chords.get(x);
			
			try{
				notes = c.getVoicedChord();
				Note[] noteArray = new Note[notes.size()];
				for(int i = 0; i < noteArray.length; i++){
					noteArray[i] = notes.elementAt(i);
				}
				this.addChord(noteArray);
			}
			catch(ChordNotVoicedException e){
				e.printStackTrace();
				System.exit(-1);
			}
		}
	}
	
	/**
	 * Offsets the chord progression
	 * @throws ChordNotVoicedException if one of the chords is not voiced
	 */
	public void offset() throws ChordNotVoicedException{
		double[] offsets = {0.0,1.0,0.0};
		double prob,
						 increment,
						 old;
		int pick = 1; // Initially set to offset directly on the beat. Should be picked anyway
		Chord c;
		
		for(int i = 0; i < chords.size(); i++){
			prob = Math.random();
			increment = 0.0;
			old = 0.0;
			c = chords.get(i);
			
			for(int j = 0; j < offsets.length; j++){
				increment = increment + offsets[j];
				if(prob <= increment){
					pick = j;
					old = offsets[j];
					break;
				}
			}
			
			switch(pick){
				case 0: // Offset ahead by an eighth note
					try{ 
						c.setOffset(-RhythmValues.EIGHTH_NOTE);
						offsets[0] = (Math.pow(offsets[0],2.0))/2.0;
						offsets[1] += Math.abs(offsets[0] - old)/2.0;
						offsets[2] += Math.abs(offsets[0] - old)/2.0;
					} catch(ChordNotVoicedException e){
						throw new ChordNotVoicedException();
					}
					break;
				case 1: // Don't offset
					offsets[1] = (Math.pow(offsets[1],2.0))/2.0;
					offsets[0] += Math.abs(offsets[1] - old)/2.0;
					offsets[2] += Math.abs(offsets[1] - old)/2.0;
					break;
				case 2: // Offset forward an eighth note
					try{ 
						c.setOffset(RhythmValues.EIGHTH_NOTE);
						offsets[2] = (Math.pow(offsets[2],2.0))/2.0;
						offsets[0] += Math.abs(offsets[2] - old)/2.0;
						offsets[1] += Math.abs(offsets[2] - old)/2.0;
					} catch(ChordNotVoicedException e){
						throw new ChordNotVoicedException();
					}
			}
		}
	}
	
	/**
	 * Returns the size of the chord progression
	 * @return the size of the chord progression
	 */
	public int getSize(){
		return chords.size();
	}
}