package com.rjconsultores.ventaboletos.layouts;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.jrimum.texgit.FlatFile;
import org.jrimum.texgit.Record;
import org.jrimum.texgit.Texgit;
import org.jrimum.utilix.ClassLoaders;
import org.jrimum.utilix.Collections;
import org.jrimum.utilix.Objects;
import org.jrimum.utilix.text.Strings;

import com.rjconsultores.ventaboletos.ArquivoRemessa;
import com.rjconsultores.ventaboletos.ArquivoRemessaItemInteface;
import com.rjconsultores.ventaboletos.ArquivoRetorno;
import com.rjconsultores.ventaboletos.ArquivoRetornoItem;
import com.rjconsultores.ventaboletos.blocos.CabecalhoRemessa;
import com.rjconsultores.ventaboletos.blocos.CabecalhoRetorno;
import com.rjconsultores.ventaboletos.blocos.DadosBoleto;
import com.rjconsultores.ventaboletos.blocos.DetalheObrigatorio;
import com.rjconsultores.ventaboletos.blocos.DetalheRetorno;
import com.rjconsultores.ventaboletos.blocos.RateioDeCredito;
import com.rjconsultores.ventaboletos.blocos.RodapeRemessa;
import com.rjconsultores.ventaboletos.blocos.RodapeRetorno;
import com.rjconsultores.ventaboletos.enuns.BancoLayout;

/**
 * <p>
 * Implementação base para classes utilizadoras do <a href="http://www.jrimum.org/texgit"> JRimum-Texgit </a>.
 * </p>
 * 
 * @author <a href="http://gilmatryx.googlepages.com/">Gilmar P.S.L.</a>
 */
public abstract class AbstractFlatFile{
	
	//protected static Logger log = LoggerFactory.getLogger(AbstractFlatFile.class);
	
	/**
	 * Nome do arquivo xml de configuração. 
	 */
	protected BancoLayout cfgFile;

	/**
	 * FlatFile Texgit. 
	 */
	private FlatFile<Record> flatFile;
	
	/**
	 * Linhas do Arquivo
	 */
	private List<String> lines = new ArrayList<String>();

	/**
	 * Construtor para inicializção com layout xml.
	 * 
	 * @param cfgFile
	 *            - nome do arquivo layout em xml.
	 */
	protected AbstractFlatFile(BancoLayout cfgFile) {

		init(cfgFile);
	}

	/**
	 * Inicializador e validador do nome do e layout do arquivo.
	 * 
	 * @param cfgFile
	 */
	protected final void init(BancoLayout cfgFile) {

		//Strings.checkNotBlank(cfgFile.getPath(), "Arquivo invalido!");
		
		this.cfgFile = cfgFile;

		configure();
	}

	/**
	 * Retorna o Texgit flatfile da instância.
	 * 
	 * @return the flatFile
	 */
	protected final FlatFile<Record> getFlatFile() {
		
		return flatFile;
	}

	/**
	 * Configura o flat file a partir do nome do arquivo layout xml da instância
	 * procurando no classpath.
	 */
	private void configure() {

		InputStream in = null;
		
		try {
			
			//in = ClassLoaders.getResourceAsStream(cfgFile.getPath(), this.getClass());
			in = getClass().getResourceAsStream(cfgFile.getPath());

			File config = File.createTempFile(cfgFile.getTemp(), null);
			
			copyInputStreamToFile(in, config);
			
			//FileUtils.copyInputStreamToFile(in, config);
			
			flatFile = Texgit.createFlatFile(config);
			
		} catch (Exception e) {

			throw new IllegalStateException(e);
			
		}finally {

			if (in != null) {

				try {

					in.close();

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}

		Objects.checkNotNull(flatFile, "NAO FOI POSSIVEL INICIALIZAR A LIB TEXGIT!");
	}
	
	public void copyInputStreamToFile(InputStream initialStream, File targetFile) throws IOException {
			  
	    OutputStream outStream = new FileOutputStream(targetFile);
	 
	    byte[] buffer = new byte[8 * 1024];
	    int bytesRead;
	    while ((bytesRead = initialStream.read(buffer)) != -1) {
	        outStream.write(buffer, 0, bytesRead);
	    }
	    
	    IOUtils.closeQuietly(initialStream);
	    IOUtils.closeQuietly(outStream);
	    
//	    Reader reader = new BufferedReader(new InputStreamReader(initialStream));
//	    Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(targetFile), "Cp1252"));
//	    
//	    char[] buffer = new char[8 * 1024];
//	    int bytesRead;
//	    while ((bytesRead = reader.read(buffer)) != -1){
//	    	writer.write(buffer, 0, bytesRead);
//	    }
//	    
//	    IOUtils.closeQuietly(initialStream);
//	    IOUtils.closeQuietly(reader);
//	    IOUtils.closeQuietly(writer);
	}
	
	/**
	 * <p>
	 * Lê um arquivo do layout da instancia.
	 * </p>
	 * 
	 * @param lines
	 *            linhas do arquivo
	 */
	@SuppressWarnings("unchecked")
	public <FF extends AbstractFlatFile> FF read(final List<String> lines) {

		Collections.checkNotEmpty(lines, "Linhas ausentes!");

		try {
			
			getFlatFile().read(lines);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return (FF) this;
	}
	
	/**
	 * <p>
	 * Lê um arquivo do layout da instancia com enconding UTF-8.
	 * </p>
	 * 
	 * @param file
	 *            arquivo texto
	 */
	@SuppressWarnings("unchecked")
	public <FF extends AbstractFlatFile> FF read(final File file) {

		Objects.checkNotNull(file, "Arquivo TXT a ser importado nulo!");

		try {
			
			getFlatFile().read(FileUtils.readLines(file));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return (FF) this;
	}
	
	/**
	 * <p>
	 * Lê um arquivo do layout da instancia.
	 * </p>
	 * 
	 * @param file
	 *            - Arquivo texto
	 * @param encoding
	 *            - Econding em que o arquivo será lido
	 */
	@SuppressWarnings("unchecked")
	public <FF extends AbstractFlatFile> FF read(final File file, String encoding) {

		Objects.checkNotNull(file, "Arquivo TXT a ser importado nulo!");
		Strings.checkNotBlank(encoding, "Encoding inválido!");

		try {
			
			getFlatFile().read(FileUtils.readLines(file, encoding));
			
		} catch (IOException e) {

			e.printStackTrace();
		}
		
		return (FF) this;
	}

	/**
	 * <p>
	 * Escreve um arquivo do layout da instancia com enconding UTF-8.
	 * </p>
	 * 
	 * @return arquivo texto
	 * @throws IOException
	 */
	public File write() throws IOException {
		
		Objects.checkNotNull(getFlatFile(), "Arquivo TXT a ser importado nulo!");

		File f = File.createTempFile(this.getClass().getName() + ""
				+ new Date().getTime(), "_jnfmtmp.txt");

		FileUtils.writeLines(f, getFlatFile().write());
		
		return f;
	}
	
	/**
	 * <p>
	 * Escreve um arquivo do layout da instancia.
	 * </p>
	 * @param encoding - Econding em que o arquivo será escrito
	 * @return arquivo texto
	 * @throws IOException
	 */
	public File write(String encoding) throws IOException {
		
		if (getFlatFile() != null) {

			File f = File.createTempFile(this.getClass().getName() + ""
					+ new Date().getTime(), "_jnfmtmp.txt");

			FileUtils.writeLines(f, getFlatFile().write(), encoding);
			
			return f;

		} else{
			
			throw new IllegalArgumentException(new NullPointerException(
					"Arquivo TXT a ser importado nulo!"));
		}
	}
	
	/**
	 * <p>
	 * Escreve um arquivo do layout da instancia.
	 * </p>
	 * @param arquivoRemessaFisico
	 * @throws IOException
	 */
	protected void write(File arquivoRemessaFisico) throws IOException{
		
		if(arquivoRemessaFisico == null){
			throw new IllegalArgumentException(new NullPointerException(
					"Arquivo TXT a ser importado nulo!"));
		}
		
		FileUtils.writeLines(arquivoRemessaFisico, getFlatFile().write(), "\r\n");  
	}
	
	protected void writeLines(File arquivoRemessaFisico) throws IOException{
		
		if(arquivoRemessaFisico == null){
			throw new IllegalArgumentException(new NullPointerException(
					"Arquivo TXT a ser importado nulo!"));
		}
		
		FileUtils.writeLines(arquivoRemessaFisico, "Cp1252", this.lines, "\r\n");  
		//FileUtils.writeLines(file, encoding, lines, lineEnding);
	}
	
	protected void writeLines() throws IOException{
		this.lines.addAll(getFlatFile().write());
		
		flatFile = null;
		configure();
	}
	
	/**
	 * 
	 * @param arquivoRemessaFisico
	 * @param arquivoRemessa
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public List<String> gerarRemessa(File arquivoRemessaFisico, ArquivoRemessa arquivoRemessa) throws FileNotFoundException, IOException{
		
		//log.info("Gerando Remessa: " + cfgFile.name());
		//log.info("INICIO - Bloco de Header...");
		
		for(ArquivoRemessaItemInteface arquivoRemessaItem : arquivoRemessa.getItens()){
			createHeader(arquivoRemessaItem.getCabecalhoRemessa());
			//log.info("FIM - Bloco de Header...");
			
			//log.info("INICIO - Bloco de Titulos...");
	        for (DetalheObrigatorio titulo : arquivoRemessaItem.getTitulos()) { 
	        	createTransacaoTitulos(titulo);
	        }
	        //log.info("FIM - Bloco de Titulos...");
			
	        //log.info("INICIO - Bloco de Trailler...");
	        createTrailler(arquivoRemessaItem.getRodapeRemessa());
	        //log.info("FIM - Bloco de Trailler...");
	        
	        //log.info("INICIO - Gerando arquivo...");
	        writeLines();
	        //log.info("FIM - Gerando arquivo...");
		}
		
		writeLines(arquivoRemessaFisico);
		
		return this.lines;
	}
	
	
	public ArquivoRetorno lerRetorno(File arquivoRetornoFisico) throws FileNotFoundException, IOException{
		
		//log.info("Gerando Retorno: " + cfgFile.name());
		//log.info("INICIO - Bloco de Header...");		
		
		read(arquivoRetornoFisico);
		
		return loadInfo();
	}
	
	private ArquivoRetorno loadInfo() {
		
		ArquivoRetorno arquivoRetorno = new ArquivoRetorno();
		
		Record header = getFlatFile().getRecord("Header");
		
		ArquivoRetornoItem arquivoRetornoItem = new ArquivoRetornoItem();
		
		arquivoRetornoItem.setCabecalhoRetorno(readHeader(header));
		
		Collection<Record> registrosDeTransacoes = getFlatFile().getRecords(
				"TransacaoTitulo");
		
		List<DetalheRetorno> titulos = readTransacaoTitulos(registrosDeTransacoes);
		
		for(DetalheRetorno titulo : titulos){
			arquivoRetornoItem.addTitulo(titulo);
		}
		
		
		Record trailler = getFlatFile().getRecord("Trailler");
		
		arquivoRetornoItem.setRodapeRetorno(readTrailler(trailler));
		
		arquivoRetorno.addItem(arquivoRetornoItem);
		
		return arquivoRetorno;
	}
	

	protected abstract void createHeader(CabecalhoRemessa cabecalhoRemessaParam);

	protected abstract void createTransacaoTitulos(DetalheObrigatorio tituloParam);

	protected abstract Record createDadosBoletos(DadosBoleto boleto);

	protected abstract Record createRateioDeCredito(RateioDeCredito rateioDeCredito);

	protected abstract void createTrailler(RodapeRemessa trailler);
	
	protected abstract CabecalhoRetorno readHeader(Record header);
	
	protected abstract List<DetalheRetorno> readTransacaoTitulos(Collection<Record> registrosDeTransacoes);
	
	protected abstract RodapeRetorno readTrailler(Record trailler);
}