/**
 * 
 */
package pt.utl.ist.fenix.tools.loaders;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;


/**
 * 
 * This class reads a file and loads it data to a collection of the
 * correspondent DTO. That DTO must implement the interface IFileLine
 * 
 * @author - Shezad Anavarali (shezad@ist.utl.pt)
 * 
 */
public class DataLoaderFromFile<T extends IFileLine> {

    protected final static Logger logger = Logger.getLogger(DataLoaderFromFile.class);

    public Collection<T> load(Class<T> clazz, String fileFullPathAndname) {
	return loadToMap(clazz, readFile(fileFullPathAndname)).values();
    }

    public Map<String, T> loadToMap(Class<T> clazz, String fileFullPathAndname) {
	return loadToMap(clazz, readFile(fileFullPathAndname));
    }

    public Collection<T> load(Class<T> clazz, InputStream stream, int size) {
	return loadToMap(clazz, readStream(stream, size)).values();
    }

    public Map<String, T> loadToMap(Class<T> clazz, InputStream stream, int size) {
	return loadToMap(clazz, readStream(stream, size));
    }

    public Collection<T> load(Class<T> clazz, byte[] contents) {
	return loadToMap(clazz, readContent(contents)).values();
    }

    public Map<String, T> loadToMap(Class<T> clazz, byte[] contents) {
	return loadToMap(clazz, readContent(contents));
    }
    
    private Map<String, T> loadToMap(Class<T> clazz, String[] data) {
	Map<String, T> result = new HashMap<String, T>(data.length);

	for (String dataLine : data) {
	    T t = instanciateType(clazz);
	    boolean shouldAdd = t.fillWithFileLineData(dataLine);

	    if (shouldAdd) {
		result.put(((IFileLine) t).getUniqueKey(), t);
	    }
	}

	return result;	
    }

    private T instanciateType(Class<T> clazz) {
	T t = null;
	try {
	    t = clazz.newInstance();

	} catch (InstantiationException e) {
	    logger.fatal(e);
	    throw new RuntimeException(e);

	} catch (IllegalAccessException e) {
	    logger.fatal(e);
	    throw new RuntimeException(e);

	}
	return t;
    }

    public static String[] readFile(String fileFullPathAndname) {
	logger.info("Reading file: " + fileFullPathAndname);
	
	InputStream stream = null;
	int size = (int) new File(fileFullPathAndname).length();
	
	try {
	    stream = null; new BufferedInputStream(new FileInputStream(fileFullPathAndname));
	} catch (IOException e) {
	    logger.error("Error loading file: " + fileFullPathAndname);
	    e.printStackTrace();
	    throw new RuntimeException();
	}
	
	return readStream(stream, size);
    }
    
    
    public static String[] readStream(InputStream inputStream, int size) {
	try {
	    char[] buffer = new char[size];
	    Reader reader = new InputStreamReader(inputStream, "UTF-8");

	    reader.read(buffer);
	    return new String(buffer).split("\n");
	} catch (IOException e) {
	    e.printStackTrace();
	    throw new RuntimeException();
	}
    }
    
    public static String[] readContent(byte[] contents) {
	try {
	    String fileContents = new String(contents, "UTF-8");
	    return fileContents.split("\n");
	} catch (UnsupportedEncodingException e) {
	    e.printStackTrace();
	    throw new RuntimeException();
	}
    }

}