package de.superx.bin;

import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.Authenticator;
import java.net.PasswordAuthentication;
import java.net.Authenticator.RequestorType;
import java.nio.charset.Charset;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.xml.soap.MessageFactory;
import javax.xml.soap.MimeHeaders;
import javax.xml.soap.SOAPConnection;
import javax.xml.soap.SOAPConnectionFactory;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPMessage;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Node;

import de.memtext.util.DateUtils;
import de.memtext.util.GetOpts;
import de.memtext.util.LogUtils;
import de.memtext.util.StringUtils;
import de.memtext.util.XMLUtils;

public class WebserviceClientBewegungsdaten extends AbstractWebserviceClient {

	private Document configDocument;
	private XMLInputFactory factory = XMLInputFactory.newInstance();

	private String hsnr;

		private String xmlConfig, datentyp;
	private String url;

	private String soap;

	private String outfilename;
	private boolean columnNamesWritten = false, columnNamesHdWritten = false;
	private File tmpFile, outFile, outFileHd;
	private String jahr;
	private PrintWriter fw, fwhd;
	private BufferedWriter bfw, bfwhd;
	private static final Logger log = Logger.getLogger("wc");

	public static void main(String args[]) {
		System.out
				.println("SuperX-WebserviceClientBewegungsdaten Version 0.9.3");
		WebserviceClientBewegungsdaten tc = new WebserviceClientBewegungsdaten();
		tc.run(args);
	
	}

	public WebserviceClientBewegungsdaten() {

	}

	public void run(String args[]) {
		try {

			XMLUtils.getExceptionHandler().setWithGui(false);
			XMLUtils.getExceptionHandler().setExitWanted(true);
			// LogUtils.initRaw(log);
			LogUtils.initRawFileDateTime("wc", "WebserviceClient.log", 100000,
					1, true, false);

			log.setLevel(Level.FINEST);
			log.getHandlers()[0].setLevel(Level.FINEST);
			GetOpts.setOpts(args);
			String isdrin = GetOpts
					.isAllRequiredOptionsPresent("-xmlconfig,-hsnr,-jahr,-out,-datentyp");
			if (isdrin != null) {
				System.err.println("Folgende Optionen fehlen: " + isdrin);
				// System.err.println(usage);
				System.exit(1);
			}
			readConfig();

			perform();

			String msg = "    fertig: " + DateUtils.getTodayString() + " "
					+ DateUtils.getNowString();
			log.info(msg);
			System.out.println(msg);
		} catch (Exception e) {
			log.severe(e.getMessage());
			System.out.println("Error " + e.getMessage());
			e.printStackTrace();
			LogUtils.close("wc");
			System.exit(1);
		} finally {
			LogUtils.close("wc");

		}
	}

	private void perform() throws Exception {

		Node n = XMLUtils.getFirstNode(configDocument, datentyp + "detailurl");
		url = XMLUtils.getTheValue(n);
		url = adaptURL(url);
		n = XMLUtils.getFirstNode(configDocument, datentyp + "detailsoap");
		soap = XMLUtils.getTheValue(n);
		soap = soap.replace("XXHSNRXX", hsnr);
		soap = soap.replace("XXJAHRXX", jahr);
		System.out.println(datentyp + "\n12x " + soap);
		//n = XMLUtils.getFirstNode(configDocument, datentyp	+ "detailreplacenode");

		initOutFile();
        //Laut Herrn Schweitzer (SAP) keine Daten für Vorjahr und Folgejahr abrufen
		// monat 0 ist Vorjahr, Monat 13 ist Folgejahr
		for (int monat = 1; monat <= 12; monat++) {
			
			String monatssoap = getMonatsoap(monat);
			log.fine(datentyp + "\nSOAP Aufruf:\n" + monatssoap);
			String msg = "starte Aufruf " + (monat );
		
			System.out.print(msg);
			tmpFile = createSoapFile(monatssoap, url);
			msg =" - empfangen ";
			if (!isDeleteTmpXmlFileWanted)
				msg += " (" + tmpFile+")";
			msg+=" "+DateUtils.getNowString();
			System.out.println(msg);

			String nodeName = "EX_" + datentyp.toUpperCase();

			if (isReplyOk()) {
				String columnNames = getColumnNames(nodeName).toString();
				if (!columnNamesWritten && !columnNames.equals("")) {
					bfw.write(columnNames);
					columnNamesWritten = true;
				}
				String data = getData(nodeName).toString();
				if (!data.equals(""))
					bfw.write(data);
				bfw.flush();

				// Header
				if (datentyp.equals("fmifiit")) {
					columnNames = getColumnNames("EX_FMIFIHD").toString();
					if (!columnNamesHdWritten && !columnNames.equals("")) {
						bfwhd.write(columnNames);
						columnNamesHdWritten = true;
					}
					data = getData("EX_FMIFIHD").toString();
					if (!data.equals(""))
						bfwhd.write(data);
					bfwhd.flush();
				}
				if (isDeleteTmpXmlFileWanted)
					tmpFile.delete();

			} else {
				msg = "Error: Aufruf von Webservice für Bewegungsdaten "
						+ datentyp + " (" + xmlConfig + ") fehlgeschlagen";
				System.out.println(msg);
				System.out.println(StringUtils.readFile(tmpFile));
				log.severe(msg);
				LogUtils.close("wc");
				System.exit(-1);
			}

		}
		closeFile();
	}

	private String getMonatsoap(int monat) {
		String tempsoap = soap;
		if (monat == 0) {
			int vorjahr = Integer.parseInt(jahr);
			vorjahr--;
			tempsoap = tempsoap.replaceAll("XXSTARTXX", vorjahr + "-01-01");
			tempsoap = tempsoap.replaceAll("XXENDEXX", vorjahr + "-12-31");
		}

		if (monat >= 1 && monat <= 12) {
			int jahrint = Integer.parseInt(jahr);
			GregorianCalendar cal = new GregorianCalendar(jahrint,monat-1, 1);
			String monatstr;
			if (monat < 10)
				monatstr = "0" + monat;
			else
				monatstr = monat + "";
			tempsoap = tempsoap.replaceAll("XXSTARTXX", jahr + "-" + monatstr
					+ "-01");
			int maxDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
		//	System.out.println(maxDay);
			tempsoap = tempsoap.replaceAll("XXENDEXX", jahr + "-" + monatstr
					+ "-" + maxDay);
		}

		if (monat == 13) {
			int folgejahr = Integer.parseInt(jahr);
			folgejahr++;
			tempsoap = tempsoap.replaceAll("XXSTARTXX", folgejahr + "-01-01");
			tempsoap = tempsoap.replaceAll("XXENDEXX", folgejahr + "-12-31");
		}
		return tempsoap;
	}

	private void readConfig() {

		xmlConfig = GetOpts.getValue("-xmlconfig");
		outfilename = GetOpts.getValue("-out");

		hsnr = GetOpts.getValue("-hsnr");
		jahr = GetOpts.getValue("-jahr");
		datentyp = GetOpts.getValue("-datentyp");
		System.out.println("\n" + DateUtils.getTodayString() + " "
				+ DateUtils.getNowString() + "\nHochschulnummer " + hsnr);
		log.info("\nHochschulnummer " + hsnr);
		if (GetOpts.isPresent("-nodelete"))
			isDeleteTmpXmlFileWanted = false;
		log.log(Level.INFO, "Geschaeftsjahr " + jahr);
		System.out.println("Geschaeftsjahr " + jahr);

		log.log(Level.INFO, "Verarbeite " + xmlConfig);
		System.out.println("Verarbeite " + xmlConfig);
		configDocument = XMLUtils.buildDocument(new File(xmlConfig));

	}

	private void initOutFile() throws Exception {
		outFile = new File(outfilename);
		if (outFile.exists())
			outFile.delete();
		// FileWriter fw = new FileWriter(f);
		fw = new PrintWriter(outFile);
		// FileOutputStream fos = new FileOutputStream(f, false);
		// BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(fos));

		bfw = new BufferedWriter(fw);

		if (datentyp.equals("fmifiit")) {

			String hdfilename = StringUtils.replace(outfilename, ".", "hd.");
			outFileHd = new File(hdfilename);
			String msg = "Erzeuge zusaetzliche Header_Datei " + hdfilename;
			log.log(Level.INFO, msg);
			System.out.println(msg);
			fwhd = new PrintWriter(outFileHd);
			bfwhd = new BufferedWriter(fwhd);
		}

	}

	private void closeFile() throws Exception {

		bfw.close();
		fw.close();

		if (datentyp.equals("fmifiit")) {
			bfwhd.close();
			fwhd.close();
		}

		if (isDeleteTmpXmlFileWanted)
			if (tmpFile.exists()) tmpFile.delete();
	}

	private boolean isReplyOk() throws XMLStreamException, IOException {
		InputStream in = new FileInputStream(tmpFile);
		XMLStreamReader parser = factory.createXMLStreamReader(in);
		boolean checkReturn = false;
		String result = "";
		while (parser.hasNext()) {
			switch (parser.getEventType()) {
			case XMLStreamConstants.START_ELEMENT:
				if (parser.getLocalName().equals("RETURN")) {
					checkReturn = true;

				}
				break;

			case XMLStreamConstants.CHARACTERS:
				if (checkReturn && !parser.isWhiteSpace()) {
					result = parser.getText();
					checkReturn = false;
				}
				break;
			case XMLStreamConstants.END_DOCUMENT:

				parser.close();
				break;

			}

			parser.next();

		}
		in.close();
		return result.equals("I");
	}

	private StringBuilder getData(String topnode) throws XMLStreamException,
			IOException {
		InputStream in = new FileInputStream(tmpFile);
		XMLStreamReader parser = factory.createXMLStreamReader(in);
		final String datumspattern = "(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)";

		StringBuilder result = new StringBuilder();
		boolean getData = false;
		while (parser.hasNext()) {

			switch (parser.getEventType()) {
			case XMLStreamConstants.START_ELEMENT:
				String name = parser.getLocalName();
				if (name.equals(topnode))
					getData = true;
				// Spaltennamen zu Debugzwecken anzeigen
				// else if (getData && !name.equals("item"))
				// result.append(prefix + "_" + parser.getLocalName());
				break;
			case XMLStreamConstants.CHARACTERS:
				if (getData && !parser.isWhiteSpace()) {
					String data = parser.getText();

					if (data.matches(datumspattern))
						data = data.replaceAll(datumspattern, "$3.$2.$1");
					else
						data = purge(data);

					result.append(data);
				}
				break;
			case XMLStreamConstants.END_ELEMENT:
				if (parser.getLocalName().equals(topnode))
					getData = false;
				else if (getData && parser.getLocalName().equals("item"))
					result.append("\n");
				else if (getData) {
					result.append("^");
				}
				break;

			case XMLStreamConstants.END_DOCUMENT:
				parser.close();
				break;
			}
			parser.next();
		}
		in.close();
		// abschließendes ^ entfernen
		//if (result.length() > 0)	result.setLength(result.length() - 1);
		return result;

	}

	private String getColumnNames(String topnode)
			throws XMLStreamException, IOException {
		InputStream in = new FileInputStream(tmpFile);
		XMLStreamReader parser = factory.createXMLStreamReader(in);

		String prefix = topnode.replaceAll("EX_", "");
		StringBuilder result = new StringBuilder();
		boolean getNames = false;
		while (parser.hasNext()) {

			switch (parser.getEventType()) {
			case XMLStreamConstants.START_ELEMENT:
				String name = parser.getLocalName();
				if (parser.getLocalName().equals(topnode))
					getNames = true;
				else if (getNames && !name.equals("item"))
					result.append(prefix + "_" + parser.getLocalName() + "^");
				break;
			case XMLStreamConstants.END_ELEMENT:
				if (parser.getLocalName().equals(topnode)||parser.getLocalName().equals("item"))
					getNames = false;
				break;

			case XMLStreamConstants.END_DOCUMENT:
				parser.close();
				break;
			}
			parser.next();
		}
		in.close();
		// abschließendes ^ entfernen
		if (result.length() > 0)
			result.setLength(result.length() - 1);
		if (result.length() > 0)
			result.append("\n");
		return result.toString().toLowerCase();
	}
}