package de.superx.bin;
/**
 * Diese Klasse bereitet die Zeilen der angegebenen ASCII-Dateien für den Upload vor.<br>
		+ "Gebrauch: java de.superx.bin.UnlFileConverter -logger:<Pfad zu logging.properties> -IN:<Pfad zur unl-Datei> -OUT:<Pfad zur Ausgabedatei> -INDESCR:<Pfad zum Eingabe-Descriptor> -OUTDESCR:<Pfad zum Ausgabe-Descriptor> -dbproperties:<Pfad zu db.properties> "
		+ "-table:<Tabellenname (wenn auch die Tabelle auf Typkompatitibilität gechekct werden soll>."
 * @version 0.1  4.7.2003
 * @author Eugen Ermantraut, D. Quathamer*/

/*
 * Änderungen
 * 
 * 26.8.04 MB XMLUtils.buildDocumentFromFile -> buildDocument
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.logging.LogManager;
import java.util.logging.Logger;

import org.apache.commons.lang.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import de.memtext.util.GetOpts;
import de.memtext.util.GetOpts.Options;
import de.memtext.util.XMLUtils;

public class UnlFileConverter {

	/* Klassenvariablen */
	private static String _dateiPfad = "";

	private static String DELIMITER = "^";

	private static String _outDateiPfad = "";

	private static String _tabelle = "";

	private static String _indescr = "";

	private static String _outdescr = "";

	private static String logfile = "../conf/logging.properties";

	private static String dbpropfile = "";

	private static String usage = "-------------------------------------\n"
			+ "Gebrauch: java de.superx.bin.UnlFileConverter -logger:<Pfad zu logging.properties> -IN:<Pfad zur unl-Datei> -OUT:<Pfad zur Ausgabedatei> -INDESCR:<Pfad zum Eingabe-Descriptor> -OUTDESCR:<Pfad zum Ausgabe-Descriptor> -dbproperties:<Pfad zu db.properties> "
			+ "-table:<Tabellenname (wenn auch die Tabelle auf Typkompatitibilität gechekct werden soll>."
			+ "\n---------------------------------------------------";

	private static String indescr_name = "";

	private static String indescr_dbsystem = "";

	private static String indescr_app = "";

	private static String indescr_cmd = "";

	private static String in_rec_sep = "";

	private static String in_line_sep = "";

	private static String in_rec_header = "";

	private static String in_rec_footer = "";

	private static String in_header = "";

	private static String in_header_delim = "";

	private static boolean in_fixedwidth = false;

	private static String in_escapemode = "";

	private static String in_chmod = "";

	private static String out_rec_sep = "";

	private static String out_line_sep = "";

	private static String out_rec_header = "";

	private static String out_rec_footer = "";

	private static String out_header = "";

	private static String out_header_delim = "";

	private static boolean out_fixedwidth = false;

	private static String out_escapemode = "";

	private static String out_chmod = "";

	private static int plaintextcount = 0;

	private static Document inDocument;

	private static Document outDocument;

	private static String plaintextTag = "plaintext";

	private static String[] searchtext = new String[10];

	private static String[] replacetext = new String[10];

	private static final String newline = "{newline}";

	private static final String tab = "{tab}";

	Logger logger = (Logger) Logger.getLogger(UnlFileConverter.class.toString());

	public UnlFileConverter() {
	}

	public static void main(String[] args) throws FileNotFoundException, IOException {
		UnlFileConverter r = new UnlFileConverter();
		GetOpts.setOpts(args);
		String isdrin = GetOpts
				.isAllRequiredOptionsPresent(new Options[] { Options.opt_logger, Options.opt_in, Options.opt_idescr });
		if (isdrin != null) {
			System.err.println("Datei-Pfade werden als Parameter erwartet. Folgende Optionen fehlen: " + isdrin);
			r.zeige_hilfe();
			System.exit(1);
		}

		// GetOpts myOpts=new GetOpts();
		if (GetOpts.isPresent(Options.opt_logger))
			logfile = GetOpts.getValue(Options.opt_logger);
		File f = new File(logfile);
		if (!f.exists()) {
			throw new IOException("Datei nicht gefunden: " + logfile);
		}
		FileInputStream ins = new FileInputStream(logfile);
		LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
		MyLogManager.readConfiguration(ins);
		logfile = MyLogManager.getProperty(".level");
		// logger.info("Using Loggging-Level " + logfile);
		if (GetOpts.isPresent(Options.opt_in))
			_dateiPfad = GetOpts.getValue(Options.opt_in);
		if (GetOpts.isPresent(Options.opt_out))
			_outDateiPfad = GetOpts.getValue(Options.opt_out);
		if (GetOpts.isPresent(Options.opt_idescr))
			_indescr = GetOpts.getValue(Options.opt_idescr);
		if (GetOpts.isPresent(Options.opt_odescr))
			_outdescr = GetOpts.getValue(Options.opt_odescr);
		if (GetOpts.isPresent(Options.opt_dbprops))
			dbpropfile = GetOpts.getValue(Options.opt_dbprops);
		if (GetOpts.isPresent(Options.opt_table))
			if (dbpropfile.equals("")) {
				System.err.println(
						"Wenn auch die Ziel-Tabelle geprüft werden soll, dann muss dbproperties gesetzt sein.");
				System.err.println(usage);
				System.exit(1);
			} else
				_tabelle = GetOpts.getValue(Options.opt_table);
		if (args[0].toString().equals("?") || args[0].toString().equals("/?") || args[0].toString().equals("\\?")
				|| args[0].toString().toLowerCase().equals("-h") || args[0].toString().toLowerCase().equals("--h")) {
			r.zeige_hilfe();
			System.exit(1);
		}

		try {
			init_descr();
			r.updateFile(_dateiPfad, _outDateiPfad);
			System.out.println("Datei: " + _dateiPfad + " nach " + _outDateiPfad + " umgesetzt");
		} catch (Exception e) {
			System.err.println(e.toString());
		}
		// }

	} // Ende der Methode

	private void updateFile(String inDateiPfad, String outDateiPfad) throws IOException, Exception {
		File f = new File(inDateiPfad);
		if (!f.exists()) {
			throw new Exception("Datei nicht gefunden: " + inDateiPfad);
		}
		BufferedReader in;
		BufferedWriter out;
		// --- File-Instanz für temporäre Ergebnis-Datei anlegen ---//
		File out_tmp;
		if (inDateiPfad.equals(outDateiPfad))
			out_tmp = new File(inDateiPfad + ".tmp2");
		else
			out_tmp = new File(outDateiPfad);
		// --- IputStream und OutputStream generieren ---//
		in = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
		// --- Output-Stream der temporären Datei erzeugen ---//
		out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(out_tmp)));

		// --- Verarbeiten der Datei ---//
		String text;
		String text2;
		String tt;
		/*
		 * char[] cbuf = new char[1024]; while(true) { int status =
		 * in.read(cbuf,0,1024); if(status == -1) break; //text=cbuf.toString();
		 * text=String.valueOf(cbuf); if (text.startsWith(in_rec_header)) text =
		 * StringUtils.substringAfter(text, in_rec_header); text = createRow(in, text +
		 * out_rec_header); //in text steht ein Datensatz text = StringUtils.chomp(text,
		 * in_rec_footer); text += out_rec_footer; text = replacePlainText(text);
		 * checkTable(text); //Wenn Tabelle gecheckt werden sollte
		 * 
		 * out.write(text, 0, text.length()); out.write(out_rec_sep); // muss NeuLine
		 * schreiben da die Zeile ohne eingelesen wird out.flush(); }
		 */

		text = in.readLine();
		while (text != null) { // Datei nicht leer
			if (text.startsWith(in_rec_header))
				text = StringUtils.substringAfter(text, in_rec_header);
			text = createRow(in, text + out_rec_header);
			// in text steht ein Datensatz
			text = StringUtils.chomp(text, in_rec_footer);
			text += out_rec_footer;
			text = replacePlainText(text);
			checkTable(text); // Wenn Tabelle gecheckt werden sollte

			out.write(text, 0, text.length());
			out.write(out_rec_sep);
			// muss NeuLine schreiben da die Zeile ohne eingelesen wird
			out.flush();

			text = in.readLine();

		} // Ende der While-Schleife,alle records bearbeitet.

		in.close();
		out.close();
		// --- Umbenennen Quell-Dateien ---//
		/*
		 * String alt = inDateiPfad + ".in"; File altFile = new File(alt); if
		 * (altFile.exists()) altFile.delete();
		 * 
		 * f.renameTo(altFile);
		 */

		// --- Umformatierte temporäre Datei unter dem ursprünglichen Namen ablegen
		// ---//
		if (inDateiPfad.equals(outDateiPfad)) {
			File neuFile = new File(outDateiPfad);
			if (neuFile.isFile())
				neuFile.delete();
			if (!out_tmp.renameTo(neuFile))
				logger.severe("Kann " + outDateiPfad
						+ " nicht erzeugen! Existiert die Datei bereits? Die umgesetzte Datei befindet sich in "
						+ out_tmp.getPath() + System.getProperty("file.separator") + out_tmp.getName());
			else
				out_tmp.delete();
		}

		// --- Berechtigung für die neu angelegete Datei neu Vergeben ---//
		if (!out_chmod.equals("")) {
			if (!chmode(out_chmod, outDateiPfad)) {
				logger.severe("Kann Berechtigung nicht ändern " + outDateiPfad);
			}
		}
		// --- Schliessen der Streams und Löschen der temporären Datei ---//
		in.close();
		out.close();

	}

	private String createRow(BufferedReader in, String text) throws IOException {
		String tt;

		try {
			// System.out.println(text);
			if (text.endsWith(in_line_sep) && !in_line_sep.equals("")) {
				text = StringUtils.chomp(text, in_line_sep);
				text += out_line_sep;
				tt = in.readLine();
				if (tt != null) {
					text += StringUtils.chomp(tt, in_line_sep);
					while (tt.endsWith(in_line_sep)) {
						tt = in.readLine();
						if (tt != null) {

							text += out_line_sep + StringUtils.chomp(tt, in_line_sep);
						}
						// (tt.substring(0,tt.length()));
					}
				}
			} else
				text = SxDBUtils.replaceString(text, in_line_sep, out_line_sep);
		} catch (Exception e) {
			logger.severe("Fehler beim Umsetzen: " + e.toString() + "\n" + text);
			throw new IOException();
		}
		// Sonderzeichen in xil_proplist abfangen:
		// text=SxDBUtils.replaceString(text,"\\000" , "\\\\000");
		return text;
	}

	private void checkTable(String text) throws Exception {
		if (!_tabelle.equals("") && !_tabelle.equals("null")) {
			// Die Datei ist eine entladene Tabelle
			// int start=_dateiPfad.indexOf("_",_dateiPfad.length()-4);
			// if(start <0 )
			// start=0;
			// String tabname=_dateiPfad.substring(start,_dateiPfad.length()-4);
			int numFelder = 0;
			// System.out.println("Tabelle "+_tabelle+ " DELIM " + DELIMITER);
			try {
				numFelder = SxDBUtils.fieldCount(_tabelle);
				// System.out.println("Felderanzahl:"+numFelder);
			} catch (Exception e) {
				System.err.println("Fehler beim Abfragen der Tabellen-Metadaten: " + e.toString());
			}
			int k = 0;
			int i = 0;
			int p = 0;
			do {
				p = text.indexOf(DELIMITER, i);
				if (p > 0) {
					k++;
					i = p + 1;
				}

			} while (p > 0);
			if (k != numFelder) {
				throw new Exception("unl-Datei entspricht nicht der Tabelle in der Datenbank;\nDie Tabelle hat "
						+ numFelder + " Felder, die unl-Datei hat " + k + " Felder ");
			}

		}
	} // Ende der Methode

	private boolean chmode(String inBerechtigung, String inDat) {
		String befehl = "chmod " + inBerechtigung + " " + inDat;
		try {
			Runtime r = Runtime.getRuntime();
			Process p = r.exec(befehl);
			int exitCode = p.waitFor();
		} catch (Exception e) {
			logger.severe("Error: " + e.toString());
			return false;
		}

		return true;
	} // Ende der Methode

	private String replacePlainText(String inS) {
		String outS = "";
		for (int i = 0; i <= plaintextcount - 1; i++) {
			if ((searchtext[i].equals("") && replacetext[i].equals("")) || (searchtext[i].equals(replacetext[i])))
				outS = inS;
			else
				outS = SxDBUtils.replaceString(inS, searchtext[i], replacetext[i]);
			inS = outS;
		}
		return outS;
	}

	/**
	 * Liefert den Teilsstring von 0 bis zu letzten Delimiterzeichen(Exclusive)
	 * 
	 * @param inS
	 * @return String
	 */
	private String reorgString(String inS) throws Exception {
		int ldPos = inS.lastIndexOf(DELIMITER);
		// --- Wenn Delimiter-Zeichen nicht letztes Zeichen im String ist,
		// --- muss die Verarbeitung abgebrochen werden---//

		if ((ldPos + 1) < inS.length() || ldPos == -1)
			// throw new Exception("Datei ist bereits umgesetzt!");
			return inS;
		else
			return inS.substring(0, ldPos);

	} // Ende der Methode

	public boolean check_param_ok(String[] inTab) { // --- Anzahl der übergebenen Parameter prüfen ---//
		// System.out.println(inTab.length);
		if (inTab.length < 2) {
			System.out.println("Mindestens 2 Parameter erwartet! Mit -h oder ? rufen sie Hilfe auf.");
			return false;
		}
		// --- Dateinpfad übernehmen ---//
		_dateiPfad = inTab[0].trim();
		_outDateiPfad = inTab[1].trim();

		if (inTab.length >= 3)
			DELIMITER = inTab[2].trim();
		// ---Wenn Delimiter-Zeichen übergeben wurde dann übernehmen ---//
		if (inTab.length > 3)
			_tabelle = inTab[3].toString().trim();

		return true;
	} // Ende der Methode

	/**
	 * Prüfen der Datei auf Vorhandensein und Leseberechrigung
	 * 
	 * @param inFile
	 */
	private boolean check_Directory(File inFile) {
		if (inFile.exists()) {
			if (!inFile.isDirectory()) {
				System.out.println(inFile + " ist kein Verzeichnis!");
				return false;
			}
		} else {
			System.out.println(inFile + " Verzeichniss nicht gefunden!");
			return false;
		}

		return true;
	} // Ende der Methode

	private void progEnde() {
		System.runFinalization();
		System.exit(0);
	} // Ende der Methode

	private static void init_descr() throws IOException, SAXException {
		inDocument = XMLUtils.buildDocument(new File(_indescr), false);
		NodeList myInNodes = inDocument.getElementsByTagName(plaintextTag);
		outDocument = XMLUtils.buildDocument(new File(_outdescr), false);
		NodeList myOutNodes = outDocument.getElementsByTagName(plaintextTag);
		int i = 0;
		for (i = 0; i < myInNodes.getLength(); i++) {
			Node myInNode = myInNodes.item(i);
			if (myInNode.getNodeType() == Node.TEXT_NODE)
				continue;
			String plaintexttype = XMLUtils.getAttribValue(myInNode, "type");
			try {
				searchtext[i] = XMLUtils.getTheValue(myInNode);
			} catch (IllegalArgumentException e) {
				searchtext[i] = "";
			}
			searchtext[i] = SxDBUtils.replaceString(searchtext[i], tab, "\t");
			searchtext[i] = SxDBUtils.replaceString(searchtext[i], newline, "\n");

			/*
			 * if (searchtext[i].equals(tab)) searchtext[i] = "\t"; if
			 * (searchtext[i].equals(newline)) searchtext[i] = "\n";
			 */
			for (int k = 0; k < myOutNodes.getLength(); k++) {
				Node myOutNode = myOutNodes.item(k);
				if (XMLUtils.getAttribValue(myOutNode, "type").equals(plaintexttype)) {

					try {
						replacetext[i] = XMLUtils.getTheValue(myOutNode);
					} catch (IllegalArgumentException e) {
						replacetext[i] = "";
					}
					replacetext[i] = SxDBUtils.replaceString(replacetext[i], tab, "\t");
					replacetext[i] = SxDBUtils.replaceString(replacetext[i], newline, "\n");
					/*
					 * if (replacetext[i].equals(tab)) replacetext[i] = "\t";
					 * 
					 * if (replacetext[i].equals(newline)) replacetext[i] = "\n";
					 */
				}
			}

		}
		plaintextcount = i;
		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "record-separator");
			in_rec_sep = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_rec_sep = newline;
		}
		if (in_rec_sep.endsWith(newline))
			in_rec_sep = StringUtils.chomp(in_rec_sep, newline);

		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "record-separator");
			out_rec_sep = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_rec_sep = newline;
		}

		if (out_rec_sep.endsWith(newline))
			out_rec_sep = StringUtils.chomp(out_rec_sep, newline) + "\n";

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "line-separator");
			in_line_sep = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_line_sep = newline;
		}

		if (in_line_sep.endsWith(newline))
			in_line_sep = StringUtils.chomp(in_line_sep, newline) + "\n";
		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "line-separator");
			out_line_sep = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_line_sep = newline;
		}
		if (out_line_sep.endsWith(newline))
			out_line_sep = StringUtils.chomp(out_line_sep, newline) + "\n";

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "record-header");
			in_rec_header = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_rec_header = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "record-header");
			out_rec_header = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_rec_header = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "record-footer");
			in_rec_footer = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_rec_footer = "";
		}
		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "record-footer");
			out_rec_footer = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_rec_footer = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "header");
			in_header = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_header = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "header");
			out_header = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_header = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "header-delim");
			in_header_delim = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_header_delim = "^";
		}
		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "header-delim");
			out_header_delim = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_header_delim = "^";
		}
		String s = "";
		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "fixedwidth");
			s = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			s = "";
		}
		if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes"))
			in_fixedwidth = true;
		else
			in_fixedwidth = false;

		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "fixedwidth");
			s = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			s = "";
		}

		if (s.equalsIgnoreCase("true") || s.equalsIgnoreCase("yes"))
			out_fixedwidth = true;
		else
			out_fixedwidth = false;

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "escapemode");
			in_escapemode = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_escapemode = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(inDocument, "chmod");
			in_chmod = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			in_chmod = "";
		}
		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "escapemode");
			out_escapemode = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_escapemode = "";
		}

		try {
			Node myNode = XMLUtils.getFirstNode(outDocument, "chmod");
			out_chmod = XMLUtils.getTheValue(myNode);
		} catch (IllegalArgumentException e) {
			out_chmod = "";
		}

	}

	private void zeige_hilfe() {
		System.out.println("\n Diese Klasse bereinigt die Zeilen der angegebenen ASCII-Dateien.");
		System.out.println(" Es wird der letzte Delimeter-Zeichen aus jeder Zeile entfernt.");
		System.out.println("\n Parameter: ");
		System.out.println("1. Eingabe-Dateiname mit Pfadangabe ");
		System.out.println("2. Ausgabe-Dateiname mit Pfadangabe");
		System.out.println("3. Delimiter-Zeichen(optional)");
		System.out.println(
				"4. Tabellenname in der Datenbank, der auf Übereistimmung der Felderanzahl geprüft werden soll (optional, wenn keine Überprüfung, dann 'none').");
		// System.out.println(" Wenn in einer Zeile Zeichen hinter dem letzten
		// Delimiter-Zeichen ");
		// System.out.println(" wird die Bearbeitung abgebrochen, da es anzunehmen ist
		// daß diese Datei");
		// System.out.println(" bereits umgesetzt ist!");
		System.out.println(" Defaultwert fuer Delimiter ist ^. \n");
	} // Ende der Methode

} // Ende der Klasse