package ca.pfv.spmf.tools.resultConverter;

/* This file is copyright (c) 2008-2012 Philippe Fournier-Viger
* 
* This file is part of the SPMF DATA MINING SOFTWARE
* (http://www.philippe-fournier-viger.com/spmf).
* 
* SPMF is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
* SPMF is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU General Public License for more details.
* You should have received a copy of the GNU General Public License along with
* SPMF. If not, see .
*/

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

/**
* This class is for converting the result from an item (integer) representation
* back to a string representation by using the metadata provided in the original
* database.  See the class MainTestConvertTransactionDatabaseARFFtoSPMF in the same package for a detailed
* explanation of the correspondance between string and integer formats.
* 
* @author Philippe Fournier-Viger
*/
public class ResultConverter {

	
	/**
	 * This method converts a result file by converting item IDs to strings according to 
	 * a provided mapping.
	 * @param mapItemIDtoStringValue  a mapping between item ID (key) and attribute value (value).
	 * @param outputFile the path of an output file to be converted
	 * @param outputFileConverted the path of the result file to be written to disk 
	 * @throws IOException  an exception is thrown if there is an error reading/writing files
	 */
	public void convert(Map mapItemIDtoStringValue,
			String outputFile, String outputFileConverted) throws IOException {
		// SECOND STEP:  READ THE RESULT FILE AND CONVERT IT BY USING THE MAP
			// AND AT THE SAME TIME WRITE THE OUTPUT FILE.
			FileInputStream finResult = new FileInputStream(new File(outputFile));
			BufferedReader myInputResult = new BufferedReader(new InputStreamReader(finResult));
			
//				// we create an object for writing the output file
			BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileConverted)); 
			
			String thisLine = null;
			boolean firstLine = true;
			// we read the file line by line until the end of the file
			while ((thisLine = myInputResult.readLine()) != null) {
				
				boolean noItemsLeft = false;
				
				// if the line starts with a comment
				if(thisLine.isEmpty() == false){
					if(firstLine){
						firstLine = false;
					}else{
						writer.newLine();
					}
					// split the line according to spaces into tokens
					String [] split = thisLine.split(" ");
					// for each token
					for(int i=0; i< split.length; i++){
						String token = split[i];
						// if the character "#" is met, it means that the rest of the line
						// does not contains items, we note it and we write the token directly
						// to the file as well as all the following tokens.
						if(token.startsWith("#") || noItemsLeft){
							noItemsLeft = true;
							// write the token as it is to the output file
							writer.write(token);
						}else{ 
							// check if the current token is a positive integer >0.
							// if so, we will convert to its string representation
							Integer itemID = isInteger(token);
							if(itemID == null){
								// write the token as it is to the output file
								writer.write(token);
							}else if (itemID >= 0){
								// convert the item to its string and write it to the output file
								writer.write(mapItemIDtoStringValue.get(itemID));
							}
							
						}
						
						// if not the last item, we write a space to the output file
						if(i != split.length-1){
							writer.write(" ");
						}
						
					}
				}
			}
			// we close the output file
			myInputResult.close();
			writer.close();
	}
	
	/**
	 * This method converts a result file by converting item IDs to strings according to 
	 * a provided mapping.
	 * @param inputDB an input file providing the mapping between item ID (key) and attribute value (value)
	 * as metadata.
	 * @param outputFile the path of an output file to be converted
	 * @param outputFileConverted the path of the result file to be written to disk 
	 * @throws IOException  an exception is thrown if there is an error reading/writing files
	 */
	public void convert(String inputDB, String outputFile, String outputFileConverted) throws IOException {

		// WE FIRST READ THE DATABASE FILE TO READ THE METADATA INDICATING
		// THE MAPPING BETWEEN ITEM TO ATTRIBUTE VALUE.
		// For example, a line: @ITEM=16=weight=red
		// indicate that the item 16 correspond to the string "weight=red"

		// Objects to read the file
		FileInputStream fin = new FileInputStream(new File(inputDB));
		BufferedReader myInputDB = new BufferedReader(new InputStreamReader(fin));

		// A map that
		// An entry in the map is :
		//   key  =  String (attribute value)
		//   value = Integer (item id)
		Map mapItemIDtoStringValue = new HashMap();
		
		String thisLine; // variable to read a line
		// we read the file line by line until the end of the file
		while ((thisLine = myInputDB.readLine()) != null) {
			// if the line starts with a comment
			if(thisLine.startsWith("@ITEM")){
				// remove "@ITEM="
				thisLine = thisLine.substring(6);
				// get the position of the first = in the remaining string
				int index = thisLine.indexOf("=");
				int itemID = Integer.parseInt(thisLine.substring(0, index));
				String stringValue = thisLine.substring(index+1);
//				System.out.println(itemID);
//				System.out.println(stringValue);
				mapItemIDtoStringValue.put(itemID, stringValue);
			}
		}// close the file
		myInputDB.close();
		
		convert(mapItemIDtoStringValue, outputFile, outputFileConverted);
	}

	/**
	 * Get the integer representation of a string or null if the string is not an integer.
	 * @param string a string
	 * @return an integer or null if the string is not an integer.
	 */
	Integer isInteger(String string) {
		Integer result = null;
	    try { 
	    	result = Integer.parseInt(string); 
	    } catch(NumberFormatException e) { 
	        return null; 
	    }
	    // only got here if we didn't return false
	    return result;
	}

}