package net.ihe.xcpd.init.transport;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.KeyStore;

import javax.mail.MessagingException;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMultipart;
import javax.mail.util.ByteArrayDataSource;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import net.ihe.gazelle.simulator.common.model.ApplicationConfiguration;

import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.w3c.dom.Document;

public class SOAPSender2 {

	/**
	 * 
	 * @param inUrl
	 * @param messageToSend
	 * @return
	 */
	public static String sendToUrlAndGetResponse(String inUrl,
			String messageToSend) throws Exception {
		URL url;
		InputStream inputStream;

		try {
			url = new URL(inUrl);

			if (inUrl.startsWith("https")) {
				inputStream = sendOverHttps(url, messageToSend);
			} else {
				inputStream = sendOverHttp(url, messageToSend);
			}

			BufferedReader in = new BufferedReader(new InputStreamReader(
					inputStream));

			if (in != null) {
				StringBuffer response = new StringBuffer();
				String line = null;
				response.append(in.readLine());
				while ((line = in.readLine()) != null) {
					response.append(line);
				}
				in.close();
				return response.toString();
			} else {
				return null;
			}

		} catch (Exception e) {
			System.out
					.println("ERROR: an error occurred when sending the message to "
							+ inUrl + ": " + e.getMessage());
			e.printStackTrace();
			throw e;
		}
	}

	/**
	 * 
	 * @param inString
	 * @return
	 */
	public static org.dom4j.Document stringToXmlTransformer(String inString) {
		org.dom4j.Document document = null;
		try {
			document = DocumentHelper.parseText(inString);
		} catch (DocumentException e) {
			e.printStackTrace();
			return null;
		}
		return document;
	}

	private static InputStream sendOverHttp(URL inUrl, String inMessageToSend)
			throws IOException {
		// System.out.println("inMessageToSend = " + inMessageToSend);
		java.net.HttpURLConnection connection = (HttpURLConnection) inUrl
				.openConnection();
		connection.setDoInput(true);
		connection.setDoOutput(true);
		connection.setUseCaches(false);
		connection
				.setRequestProperty(
						"Content-Type",
						"application/soap+xml; charset=UTF-8;action=\"urn:hl7-org:v3:PRPA_IN201305UV02:CrossGatewayPatientDiscovery\"");
		connection
				.setRequestProperty("SOAPAction",
						"urn:hl7-org:v3:PRPA_IN201305UV02:CrossGatewayPatientDiscovery");
		DataOutputStream out = new DataOutputStream(
				connection.getOutputStream());
		out.writeBytes(inMessageToSend);
		out.flush();
		out.close();

		int responseCode = connection.getResponseCode();
		String r = connection.getContentType();
		System.out.println("ct = " + r);
		InputStream inputStream;
		if (responseCode == HttpURLConnection.HTTP_OK) {
			System.out.println("code = normal");
			inputStream = connection.getInputStream();
		} else {
			System.out.println("code = error");
			inputStream = connection.getErrorStream();
		}
		return inputStream;

	}

	private static InputStream sendOverHttps(URL inUrl, String inMessageToSend)
			throws Exception {
		String keystorePath = ApplicationConfiguration
				.getValueOfVariable("keystore_path");
		return sendOverHttps(inUrl, inMessageToSend, keystorePath, "gazelle",
				"gazelle");
	}

	public static void main(String[] args) throws MalformedURLException,
			Exception {
		sendOverHttps(
				new URL("https://vmepsos.hcuge.ch:8443/SpiritProxy/RspGW"),
				"TEST", "/tmp/398.jks", "gazelle", "gazelle");
	}

	private static InputStream sendOverHttps(URL inUrl, String inMessageToSend,
			String keystorePath, String keyStorePassword, String keyPassword)
			throws Exception {
		KeyStore keyStore = KeyStore.getInstance("JKS");
		keyStore.load(
				new FileInputStream(keystorePath),
				keyStorePassword == null ? null : keyStorePassword
						.toCharArray());

		KeyManagerFactory keyManagerFactory = KeyManagerFactory
				.getInstance(KeyManagerFactory.getDefaultAlgorithm());
		keyManagerFactory.init(keyStore, keyPassword == null ? null
				: keyPassword.toCharArray());
		KeyManager[] km = keyManagerFactory.getKeyManagers();

		TrustManagerFactory trustManagerFactory = TrustManagerFactory
				.getInstance(TrustManagerFactory.getDefaultAlgorithm());
		trustManagerFactory.init(keyStore);
		TrustManager[] tm = trustManagerFactory.getTrustManagers();

		SSLContext context = SSLContext.getInstance("TLS");
		context.init(km, tm, null);
		SSLSocketFactory sslSocketFactory = context.getSocketFactory();

		HttpsURLConnection connection = (HttpsURLConnection) inUrl
				.openConnection();
		HostnameVerifier verifier = new CustomizedHostnameVerifier();
		connection.setHostnameVerifier(verifier);
		if (connection instanceof HttpsURLConnection) {
			((HttpsURLConnection) connection)
					.setSSLSocketFactory(sslSocketFactory);
		}

		connection.setDoInput(true);
		connection.setDoOutput(true);
		connection.setUseCaches(false);
		connection
				.setRequestProperty(
						"Content-Type",
						"application/soap+xml; charset=UTF-8;action=\"urn:hl7-org:v3:PRPA_IN201305UV02:CrossGatewayPatientDiscovery\"");
		connection
				.setRequestProperty("SOAPAction",
						"urn:hl7-org:v3:PRPA_IN201305UV02:CrossGatewayPatientDiscovery");

		DataOutputStream out = new DataOutputStream(
				connection.getOutputStream());
		out.writeBytes(inMessageToSend);
		out.flush();
		out.close();
		int responseCode = connection.getResponseCode();
		InputStream inputStream;
		if (responseCode == HttpURLConnection.HTTP_OK) {
			inputStream = connection.getInputStream();
		} else {
			inputStream = connection.getErrorStream();
		}
		return inputStream;
	}

	/**
	 * This class is used to avoid java.security.cert.CertificateException: No
	 * name matching "hostname" found exception
	 * 
	 * @author aberge
	 * 
	 */
	private static class CustomizedHostnameVerifier implements HostnameVerifier {
		public boolean verify(String hostname, SSLSession session) {
			return true;
		}
	}

	/**
	 * 
	 * @param document
	 * @return
	 */
	public static String xmlToStringTransformer(Document document) {
		if (document == null)
			return null;
		try {
			Source source = new DOMSource(document);
			StringWriter stringWriter = new StringWriter();
			Result result = new StreamResult(stringWriter);
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer transformer = factory.newTransformer();
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			transformer.transform(source, result);
			return stringWriter.getBuffer().toString();
		} catch (Exception e) {
			System.out.println("error when converting XML to String: "
					+ e.getMessage());
			e.printStackTrace();
			return null;
		}
	}

	public static String prettyFormat(String input) {
		try {
			Source xmlInput = new StreamSource(new StringReader(input));
			StringWriter stringWriter = new StringWriter();
			StreamResult output = new StreamResult(stringWriter);
			Transformer transformer = TransformerFactory.newInstance()
					.newTransformer();
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			transformer.setOutputProperty(
					"{http://xml.apache.org/xslt}indent-amount",
					String.valueOf(4));
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			transformer.transform(xmlInput, output);
			return output.getWriter().toString();
		} catch (Exception e) {
			return input;
		}
	}

	public static void getMimeParts(byte[] response) {
		ByteArrayDataSource ds = new ByteArrayDataSource(response, null);
		try {
			MimeMultipart multipart = new MimeMultipart(ds);
			System.out.println("nb of parts in multipart mime: "
					+ multipart.getCount());
			Integer nbOfParts = multipart.getCount();
			if (nbOfParts != null && nbOfParts > 0) {
				for (Integer index = 0; index < nbOfParts; index++) {
					MimeBodyPart body = (MimeBodyPart) multipart
							.getBodyPart(index);
					InputStream is = body.getInputStream();
					BufferedReader reader = new BufferedReader(
							new InputStreamReader(is));
					StringBuffer buffer = new StringBuffer();
					String line = null;
					buffer.append(reader.readLine());
					while ((line = reader.readLine()) != null) {
						buffer.append(line);
					}
					reader.close();
					String part = buffer.toString();
					String type = body.getContentType();
					System.out.println(index + " : " + type + "--" + part);
				}
			}
		} catch (MessagingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static String transformXmlToHtml(String documentContent) {

		if (documentContent == null || documentContent.length() == 0)
			return null;

		try {
			String xslPath = ApplicationConfiguration
					.getValueOfVariable("cda_xsl_path");
			if (xslPath == null || xslPath.length() == 0)
				return null;

			Source xmlInput = new StreamSource(
					new StringReader(documentContent));
			TransformerFactory tFactory = TransformerFactory.newInstance();
			Transformer transformer = tFactory
					.newTransformer(new javax.xml.transform.stream.StreamSource(
							xslPath));
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			StreamResult out = new StreamResult(baos);
			transformer.transform(xmlInput, out);
			String tmp = new String(baos.toByteArray());
			return tmp;
		} catch (Exception e) {
			e.printStackTrace();
			return "The document cannot be displayed using this stylesheet";
		}
	}
}