import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.File;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Enumeration;

import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.trees.J48;
import weka.core.Instance;
import weka.core.Instances;

/**
 * WekaTest - example to illustrate the Weka-API 
 * 
 *  This example takes data from an arff-file, trains a J48 classifier
 *  on it and reports classification results for some test data
 *  
 *  
 * @author timo
 * @version 1.0-20070911
 */

public class WekaTest {
	
	private static final String TEST_FILENAME = "res/test.arff";
	private static final String TRAINING_FILENAME = "res/train.arff";
	private static final String CLASSIFIER_FILENAME = "res/j48.classifier";

	/**
	 * train classifier on training data
	 * @param arffFilename name of an arff-file to train on
	 * @return trained decision tree (J48) 
	 */
	public static Classifier createJ48Classifier(String arffFilename) { 
		File arffFile = new File(arffFilename); 
		FileReader arffReader;
		Instances instances;
		Classifier classifier;
		try {
			arffReader = new FileReader(arffFile);
			instances = new Instances(arffReader);
			instances.setClassIndex(instances.numAttributes() - 1);
			classifier = new J48();
			classifier.buildClassifier(instances);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(e.toString());
			return null;
		}
		return classifier;
	}
	
	/**
	 * load classifier from file
	 * @param filename name of the file the serialized classifier is stored in
	 * @return classifier from file
	 */
	public static Classifier loadClassifier(String filename) {
		Classifier classifier;
		try {
			InputStream is = new FileInputStream(filename);
			ObjectInputStream ois = new ObjectInputStream(is);
			classifier = (Classifier) ois.readObject();
			ois.close();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return classifier;
	}
	
	/**
	 * store classifier in a file
	 * @param classifier to store
	 * @param filename of file to store to
	 * @return true on success, false on failure
	 */
	public static boolean saveClassifier(Classifier classifier, String filename) {
		try {
			OutputStream os = new FileOutputStream(filename);
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(classifier);
			oos.close();
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}
	
	/**
	 * evaluate a classifier using the template in weka.classifiers.Evaluation
	 * prints evaluation details to standard out
	 * 
	 * @param c classifier
	 */
	public static void evaluate(Classifier c) {
		try {
			Instances trainInstances = new Instances(new FileReader(new File(TRAINING_FILENAME)));
			trainInstances.setClassIndex(trainInstances.numAttributes() - 1);
			Instances testInstances = new Instances(new FileReader(new File(TEST_FILENAME)));
			testInstances.setClassIndex(testInstances.numAttributes() - 1);
			Evaluation eva = new Evaluation(trainInstances);
			eva.evaluateModel(c, testInstances);
			System.out.println(eva.toSummaryString());
		} catch (Exception e) {
			e.printStackTrace();
		}		
	}
	
	/**
	 * classifies the instance <b>i</b> given classifier <b>c</b> and 
	 * prints the result to standard out
	 * @param c
	 * @param i
	 */
	public static void classifyInstance(Classifier c, Instance i) {
		double gold = i.classValue();
		double silver = -1.0;
		double[] distribution = new double[i.numAttributes()];
		try {
			silver = c.classifyInstance(i);
			distribution = c.distributionForInstance(i);
		} catch (Exception e) {
			e.printStackTrace();
		}
		StringBuffer sb = new StringBuffer();
		sb.append("instance ");
		sb.append(i.toString());
		sb.append("\n");
		sb.append("\twith class attribute ");
		sb.append(gold);
		sb.append("\n");
		sb.append("\tis classified as ");
		sb.append(silver);
		sb.append("\n");
		sb.append("distribution among classes is \n");
		for (int j = 0; j < distribution.length; j++) {
			sb.append("\t");
			sb.append(j);
			sb.append(": ");
			sb.append(distribution[j]);
			sb.append("\n");
		}
		System.out.println(sb.toString());
	}
	
	public static void classifyFile(Classifier c, String filename) {
		try {
			Instances testInstances = new Instances(new FileReader(new File(filename)));
			testInstances.setClassIndex(testInstances.numAttributes() - 1);
			for (Enumeration<Instance> e = testInstances.enumerateInstances(); 
				 e.hasMoreElements(); ) {
				Instance i = e.nextElement();
				classifyInstance(c, i);				
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

	
	public static void main(String[] args) {
		
/* create classifier from training data: */		
		/* OR load classifier from file: */
		Classifier c = createJ48Classifier(TRAINING_FILENAME);
		//Classifier c = loadClassifier(CLASSIFIER_FILENAME);

/* classify the samples in the test data and output the results one-by-one */
		classifyFile(c, TEST_FILENAME);
		/* evaluate classifier with given test data: */
		evaluate(c);

/* store classifier to disk */
		saveClassifier(c, CLASSIFIER_FILENAME);
	}
	
}