public class Data {
	
	private Object data [][];
	private int numberOfExamples;
	private Attribute explanatorySet[];
	private DiscreteAttribute classAttribute;
	
	Data(){
		
		
		//data
		
		data = new Object [14][5];

		// 1) TO DO: POPOLARE DATA
		
		//...
		
		// 2) TO DO: ASSEGNARE numberOfExamples
		
		//...
		
		 
		
		explanatorySet = new Attribute[4];
		
		// 3)TO DO: POPOLARE explanatory Set
		
		
		//classAttribute
		
		String playValues[]=new String[2];
		playValues[0]="no";
		playValues[1]="yes";			
		classAttribute=new DiscreteAttribute("PlayTennis", 4, playValues);

	}
	
	int getNumberOfExamples(){
			//TO DO
	}
	
	int getNumberOfExplanatoryAttributes(){
			//TO DO
	}
	
	String getClassValue(int exampleIndex){
			//TO DO
	}

	
	Object getExplanatoryValue(int exampleIndex, int attributeIndex){
			//TO DO
	}
	Attribute getExplanatoryAttribute(int index){
			//TO DO
	}
	
	DiscreteAttribute getClassAttribute(){
			//TO DO
	}
	
	public String toString(){
		String value="";
 		//TO DO
		return value;
	}


	void sort(Attribute attribute, int beginExampleIndex, int endExampleIndex){
	
			quicksort(attribute, beginExampleIndex, endExampleIndex);
	}
	
	// scambio esempio i con esempi oj
	private void swap(int i,int j){
		Object temp;
		for (int k=0;k<getNumberOfExplanatoryAttributes()+1;k++){
			temp=data[i][k];
			data[i][k]=data[j][k];
			data[j][k]=temp;
		}
		
	}
	/*
	 * Partiziona il vettore rispetto all'elemento x e restiutisce il punto di separazione
	 */
	private  int partition(DiscreteAttribute attribute, int inf, int sup){
		int i,j;
	
		i=inf; 
		j=sup; 
		int	med=(inf+sup)/2;
		String x=(String)getExplanatoryValue(med, attribute.getIndex());
		swap(inf,med);
	
		while (true) 
		{
			
			while(i<=sup && ((String)getExplanatoryValue(i, attribute.getIndex())).compareTo(x)<=0){ 
				i++; 
				
			}
		
			while(((String)getExplanatoryValue(j, attribute.getIndex())).compareTo(x)>0) {
				j--;
			
			}
			
			if(i<j) { 
				swap(i,j);
			}
			else break;
		}
		swap(inf,j);
		return j;

	}
	
	/*
	 * Algoritmo quicksort per l'ordinamento di un array di interi A
	 * usando come relazione d'ordine totale "<="
	 * @param A
	 */
	private void quicksort(Attribute attribute, int inf, int sup){
		
		if(sup>=inf){
			
			int pos;
			
			pos=partition((DiscreteAttribute)attribute, inf, sup);
					
			if ((pos-inf) < (sup-pos+1)) {
				quicksort(attribute, inf, pos-1); 
				quicksort(attribute, pos+1,sup);
			}
			else
			{
				quicksort(attribute, pos+1, sup); 
				quicksort(attribute, inf, pos-1);
			}
			
			
		}
		
	}
	
	public static void main(String args[]){
		Data trainingSet=new Data();
		System.out.println(trainingSet);
		
		System.out.println("ORDER BY "+trainingSet.getExplanatoryAttribute(0));
		trainingSet.quicksort(trainingSet.getExplanatoryAttribute(0),0 , trainingSet.getNumberOfExamples()-1);
		System.out.println(trainingSet);
		
		System.out.println("ORDER BY "+trainingSet.getExplanatoryAttribute(1));
		trainingSet.quicksort(trainingSet.getExplanatoryAttribute(1),0 , trainingSet.getNumberOfExamples()-1);
		System.out.println(trainingSet);
		
		System.out.println("ORDER BY "+trainingSet.getExplanatoryAttribute(2));
		trainingSet.quicksort(trainingSet.getExplanatoryAttribute(2),0 , trainingSet.getNumberOfExamples()-1);
		System.out.println(trainingSet);
		
		System.out.println("ORDER BY "+trainingSet.getExplanatoryAttribute(3));
		trainingSet.quicksort(trainingSet.getExplanatoryAttribute(3),0 , trainingSet.getNumberOfExamples()-1);
		System.out.println(trainingSet);
	
	
	
	}

}