package com.fidufosyga.model;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class PaqueteModel {

    private String nombrePaquete;
    private String directorioSalida;
    private Map<String, Boolean> archivosAEmpaquetar = new HashMap<String, Boolean>();
    private boolean borrarOrigen = true;

    public PaqueteModel(String paquete, Map<String, Boolean> archivos,
            String directorio) {
        if (!directorio.endsWith(File.separator)) {
            directorio = directorio + File.separator;
        }
        this.nombrePaquete = paquete;
        this.directorioSalida = directorio;
        this.archivosAEmpaquetar = archivos;
    }

    public String getDirectorioSalida() {
        return directorioSalida;
    }

    public void setDirectorioSalida(String directorioSalida) {
        this.directorioSalida = directorioSalida;
    }

    public Map<String, Boolean> getArchivosAEmpaquetar() {
        return archivosAEmpaquetar;
    }

    public void setArchivosAEmpaquetar(Map<String, Boolean> archivosAEmpaquetar) {
        this.archivosAEmpaquetar = archivosAEmpaquetar;
    }

    public String getNombrePaquete() {
        return nombrePaquete;
    }

    public void setNombrePaquete(String nombrePaquete) {
        this.nombrePaquete = nombrePaquete;
    }

    public boolean isBorrarOrigen() {
        return borrarOrigen;
    }

    public void setBorrarOrigen(boolean borrarOrigenes) {
        this.borrarOrigen = borrarOrigenes;
    }

    public void empaquetar() {

        if (archivosAEmpaquetar.size() != 0) {
            List<String> listaComprimir = new ArrayList<String>();
            List<String> listaDelete = new ArrayList<String>();
            Iterator<String> iter = archivosAEmpaquetar.keySet().iterator();

            String archivoCifrado = null;

            while (iter.hasNext()) {
                String nombreArchivo = iter.next();
                if (nombreArchivo.endsWith("XML")) {
                    archivoCifrado = cifrarArchivo(nombreArchivo);
                    listaComprimir.add(archivoCifrado);
                    listaDelete.add(archivoCifrado);
                } else {
                    listaComprimir.add(nombreArchivo);
                    listaDelete.add(nombreArchivo);
                }
            }

            listaComprimir.add(directorioSalida + "keyEncryptKey");
            listaDelete.add(directorioSalida + "keyEncryptKey");

            System.out.println("Lista delete: " + listaDelete);
            comprimir(nombrePaquete, listaComprimir);
            if (borrarOrigen) {
                borrarAchivos(listaDelete);
                borrarAchivos(listaDelete);
            }
        }
    }

    public void desempaquetar() {
        List<String> archivosDescomprimidos = null;
        archivosDescomprimidos = descomprimirArchivos(nombrePaquete);
        Iterator<String> iter = archivosDescomprimidos.iterator();

        while (iter.hasNext()) {
            String nombreArchivo = iter.next();

            //System.out.println("Archivo desmpaquetado \n" + nombreArchivo);

            if (nombreArchivo.endsWith("val")) {
                File f1 = new File(nombreArchivo);

                String NewnombreArchivo = nombreArchivo;

                File f2 = new File(NewnombreArchivo);
                f1.renameTo(f2);
            }
            if (nombreArchivo.endsWith("tmpcry")) {
                descifrarArchivo(nombreArchivo);
            }
        }
    }

    public void comprimir(String Archivo) {
        Zip compresion = new Zip(directorioSalida + Archivo);
        List<String> lista = new ArrayList<String>();
        Iterator<String> iter = archivosAEmpaquetar.keySet().iterator();
        while (iter.hasNext()) {
            lista.add(iter.next());
        }
        compresion.Comprimir(lista);
    }

    public void comprimir(String Archivo, List<String> listaComprimir) {
        Zip compresion = new Zip(Archivo);
        compresion.Comprimir(listaComprimir);
    }

    public String cifrarArchivo(String nombreArchivo) {

        File archivo = new File(nombreArchivo);
        String nombre = archivo.getName();
        //System.out.println("Cifrando Archivo: " + nombre);
        String nombreCifrado = directorioSalida + nombre + ".tmpcry";

        try {
            Crypto.Encrypt(nombreArchivo, nombreCifrado, "Paquete", directorioSalida);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //System.out.println("El fichero " + nombreArchivo + " esta siendo cifrado");
        if (archivosAEmpaquetar.get(nombreArchivo)) {
            if (borrarOrigen) {
                archivo.delete();
            }
        }

        return nombreCifrado;
    }

    public String descifrarArchivo(String nombreCifrado) {

        File archivo = new File(nombreCifrado);
        String path;
        path = archivo.getParent() + "\\";

        String nombre = path + archivo.getName();
        String nombreArchivo = nombre.replaceAll(".tmpcry", "");

        System.out.println("Path Archivo: " + nombreArchivo);

        try {
            Crypto.Decrypt(nombreCifrado, nombreArchivo, path);
        } catch (Exception e) {
            System.out.println("Problema Decifrando:" + e.getMessage());
        }

        if (borrarOrigen) {
            archivo.delete();
        }
        return nombreCifrado;
    }

    public List<String> descomprimirArchivos(String nombreArchivo) {

        List<String> archivosDescomprimidos = new ArrayList<String>();
        Zip compresion = new Zip(nombreArchivo);
        archivosDescomprimidos = compresion.Descomprimir(directorioSalida);
        return archivosDescomprimidos;
    }

    public void borrarAchivos(List<String> listaBorrar) {
        Iterator<String> iterator = listaBorrar.iterator();

        while (iterator.hasNext()) {
            String nombreArchivo = iterator.next();
            System.gc();


            File archivo = new File(nombreArchivo);
            boolean permiso = archivo.getParentFile().canWrite();
            System.out.println("Permiso : " + permiso);


            if (archivo.delete()) {
                System.out.println("El fichero " + archivo.getName() + " ha sido borrado satisfactoriamente");
            } else {
                System.out.println("El fichero " + archivo.getName() + " no puede ser borrado");

                if (archivo.exists()) {
                    archivo.delete();
                }

            }
        }
//	public static void main(String[] args) {
//
//		Map<String, Boolean> archivosAEmpaquetar = new HashMap<String, Boolean>();
//		PaqueteModel test = null;
//		String paquete = null;
//		String tipoProceso = null;
//		String rutaDestino = null;
//		boolean mostrarAyuda = false;
//
//		//java PaqueteModel -d E:\USUARIOS\rborja\My Documents\Proyectos\ProcesaArchivosMA\PlanosPruebasMA\Resultados\MAEPS00120052010.pak -p
//		// E:\Resultados\salida
//
//		/*
//		 * archivosAEmpaquetar.add("E:\\Resultados\\FURIPS112345678901234567890.txt"
//		 * );
//		 * archivosAEmpaquetar.add("E:\\Resultados\\furips212345678901234567890.TXT"
//		 * );
//		 * archivosAEmpaquetar.add("E:\\Resultados\\FURIPS312345678901234567890.txt"
//		 * ); test = new PaqueteModel("miPaquete.pak", archivosAEmpaquetar,
//		 * "E:\\Resultados\\");
//		 */
//
//		/*
//		 * test = new PaqueteModel("E:\\Resultados\\miPaquete.pak",
//		 * archivosAEmpaquetar, "E:\\Resultados\\salida\\");
//		 * test.desempaquetar();
//		 */
//		/*
//		 * args = new String[] { "-e", "E:\\Resultados\\miPaquete2.pak",
//		 * "E:\\Resultados\\FURIPS112345678901234567890.txt",
//		 * "E:\\Resultados\\furips212345678901234567890.txt",
//		 * "E:\\Resultados\\FURIPS312345678901234567890.txt" };
//		 */
//		
//		  args = new String[] { "-d",
//	  "F:\\ELM1612201301.pak", "-p",
//	  "F:\\" };
//		 
//		//  args = new String[] { "-d",
//			//	  "E:\\S4ESS07615062011.pak", "-p",
//				//  "E:\\Res\\" };
//
//		for (int i = 0; i < args.length; i++) {
//			String parametro = args[i];
//			if (parametro.equalsIgnoreCase("-p")) {
//				i++;
//				rutaDestino = args[i];
//			}
//			if (parametro.equalsIgnoreCase("-d")) {
//				tipoProceso = "desempaquetar";
//				i++;
//				paquete = args[i];
//			}
//			if (parametro.equalsIgnoreCase("-e")) {
//				tipoProceso = "empaquetar";
//				i++;
//				paquete = args[i];
//				for (i++; i < args.length; i++) {
//					if (!args[i].contains("-")) {
//						File archivo = new File(args[i]);
//						String nombreArchivo = archivo.getName();
//						String rutaArchivo = archivo.getPath().substring(
//								0,
//								archivo.getPath().length()
//										- nombreArchivo.length());
//						if (!archivo.canRead()) {
//							System.out.println("No se puede leer el archivo: "
//									+ args[i]);
//							return;
//						}
//						if (!(new File(rutaArchivo)).isDirectory()) {
//							System.out.println("Ruta no valida del archivo: "
//									+ args[i]);
//							return;
//						}
//						archivosAEmpaquetar.put(args[i], true);
//					} else {
//						i--;
//						break;
//					}
//				}
//			}
//			if (parametro.equalsIgnoreCase("-h")
//					|| parametro.equalsIgnoreCase("/h")) {
//				mostrarAyuda = true;
//				break;
//			}
//		}
//
//		if (paquete == null
//				|| tipoProceso == null
//				|| (tipoProceso.equals("empaquetar") && archivosAEmpaquetar
//						.size() == 0)) {
//			if (!mostrarAyuda) {
//				System.out.println("Sintaxis incorrecta de parametros !!!");
//			}
//			System.out.println("Los Parametros Permitidos son:\n");
//			System.out
//					.println("-e  Empaquetar uno o varios archivos, se debe suministrar el nombre del paquete seguido de los archivos a empaquetar con la ruta completa");
//			System.out
//					.println("Sintaxis: -e [Nombre Paquete] [Archivo1] [Archivo2] [Archivo n] ...\n");
//			System.out
//					.println("-d  Desempaqueta uno archivo, el nombre se debe suministrar con la ruta completa");
//			System.out.println("Sintaxis: -d [Nombre Paquete] \n");
//			System.out
//					.println("-p  Indica la ruta de salida de los archivos a desempaquetar, si se omite se usa la ruta del paquete");
//			System.out.println("Sintaxis: -p [Ruta destino] \n");
//			System.out
//					.println("Ejemplo: java PaqueteModel -d E:\\Resultados\\miPaquete.pak -p E:\\Resultados\\salida \n");
//			System.out.println("Copy Rigth VIVCOM 2008");
//			return;
//		}
//
//		File archivoPaquete = new File(paquete);
//		if (tipoProceso.equals("desempaquetar") && !archivoPaquete.canRead()) {
//			System.out.println("!ERROR!!!\nNo se puede alcanzar el archivo "
//					+ paquete);
//			return;
//		}
//
//		String nombrepaquete = archivoPaquete.getName();
//		if (rutaDestino == null) {
//			rutaDestino = archivoPaquete.getPath().substring(0,
//					archivoPaquete.getPath().length() - nombrepaquete.length());
//		}
//		if (!(new File(rutaDestino)).isDirectory()) {
//			System.out.print("Directorio Destino No Valido!!!");
//		}
//		if (tipoProceso.equals("empaquetar")) {
//			test = new PaqueteModel(nombrepaquete, archivosAEmpaquetar,
//					rutaDestino);
//			test.empaquetar();
//		}
//		if (tipoProceso.equals("desempaquetar")) {
//			test = new PaqueteModel(paquete, archivosAEmpaquetar, rutaDestino);
//			test.desempaquetar();
//		}
//		System.out.print("Proceso Terminado!!!");
//	}
    }
}