/*******************************************************************************
 * Copyright 2014 Federal Chancellery Austria
 * MOA-ID has been developed in a cooperation between BRZ, the Federal
 * Chancellery Austria - ICT staff unit, and Graz University of Technology.
 * 
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 * 
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 ******************************************************************************/
/*
 * Copyright 2003 Federal Chancellery Austria
 * MOA-ID has been developed in a cooperation between BRZ, the Federal
 * Chancellery Austria - ICT staff unit, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 */


package at.gv.egovernment.moa.id.util.client.mis.simple;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.net.ssl.SSLSocketFactory;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;

import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.xpath.XPathAPI;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import at.gv.egiz.eaaf.core.impl.utils.DOMUtils;
import at.gv.egovernment.moa.id.commons.api.AuthConfiguration;
import at.gv.egovernment.moa.id.commons.api.exceptions.MISSimpleClientException;
import at.gv.egovernment.moa.id.commons.utils.HttpClientWithProxySupport;
import at.gv.egovernment.moa.id.data.MISMandate;
import at.gv.egovernment.moa.logging.Logger;
import at.gv.egovernment.moa.util.StringUtils;


public class MISSimpleClient {

		
	private final static String SOAP_NS = "http://schemas.xmlsoap.org/soap/envelope/";
	private final static String MIS_NS = "http://reference.e-government.gv.at/namespace/mandates/mis/1.0/xsd";
	
	private static Element NS_NODE = null;
	
		
	static {
		try {
			NS_NODE = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument().createElement("test");
			NS_NODE.setAttribute("xmlns:soap", SOAP_NS);
			NS_NODE.setAttribute("xmlns:mis", MIS_NS);
		} catch (Exception e) {
			Logger.warn("Error initializing namespace node.", e);
		}
	}
	
	public static List<MISMandate> sendGetMandatesRequest(String webServiceURL, String sessionId, SSLSocketFactory sSLSocketFactory, AuthConfiguration authConfig) throws MISSimpleClientException {
		if (webServiceURL == null) {
			throw new NullPointerException("Argument webServiceURL must not be null.");
		}
		if (sessionId == null) {
			throw new NullPointerException("Argument sessionId must not be null.");
		}
				
		try {
			Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
			Element mirElement = doc.createElementNS(MIS_NS, "MandateIssueRequest");
			Element sessionIdElement = doc.createElementNS(MIS_NS, "SessionID");
			sessionIdElement.appendChild(doc.createTextNode(sessionId));
			mirElement.appendChild(sessionIdElement);
	    
			// send soap request
			Element mandateIssueResponseElement = sendSOAPRequest(
					webServiceURL, 
					mirElement,
					sSLSocketFactory,
					authConfig);
	    
			// check for error
			checkForError(mandateIssueResponseElement);
	    
			// check for session id
			NodeList mandateElements  = XPathAPI.selectNodeList(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:Mandates/mis:Mandate", NS_NODE);
	    
			if (mandateElements == null || mandateElements.getLength() == 0) {
				throw new MISSimpleClientException("No mandates found in response.");
			}
	    
			ArrayList<MISMandate> foundMandates = new ArrayList<MISMandate>();
			for (int i=0; i<mandateElements.getLength(); i++) {
				Element mandate = (Element) mandateElements.item(i);
								
				MISMandate misMandate = new MISMandate();
				if (mandate.hasAttribute("ProfessionalRepresentative")) {
//					System.out.println("OID: " + mandate.getAttribute("ProfessionalRepresentative"));
					misMandate.setProfRep(mandate.getAttribute("ProfessionalRepresentative"));
				}
				if (mandate.hasAttribute("OWbPK")) {
					misMandate.setOWbPK(mandate.getAttribute("OWbPK"));
//					System.out.println("OWBPK: " + mandate.getAttribute("OWbPK"));
				}
				
				//misMandate.setMandate(Base64.decodeBase64(DOMUtils.getText(mandate)));
				misMandate.setMandate(Base64.decodeBase64(DOMUtils.getText(mandate).getBytes()));
				
				foundMandates.add(misMandate);
			}
			return foundMandates;
		} catch (ParserConfigurationException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		} catch (DOMException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		} catch (TransformerException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		} 
	}
	
	public static MISSessionId sendSessionIdRequest(String webServiceURL, byte[] idl, byte[] cert, String oaFriendlyName, String redirectURL, String referenceValue, List<String> mandateIdentifier, String targetType, byte[] authBlock, SSLSocketFactory sSLSocketFactory, AuthConfiguration authConfig) throws MISSimpleClientException {
		if (webServiceURL == null) {
			throw new MISSimpleClientException("service.04");
		}
		if (idl == null) {
			throw new NullPointerException("Argument idl must not be null.");
		}
		if (redirectURL == null) {
			throw new NullPointerException("Argument redirectURL must not be null.");
		}
				
		try {
			Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
			Element mirElement = doc.createElementNS(MIS_NS, "MandateIssueRequest");
			Element idlElement = doc.createElementNS(MIS_NS, "IdentityLink");
	    
			
			idlElement.appendChild(doc.createTextNode(new String(Base64.encodeBase64(idl))));
			mirElement.appendChild(idlElement);

			if (cert != null && cert.length > 0) {
				Element certElement = doc.createElementNS(MIS_NS, "X509SignatureCertificate");
				certElement.appendChild(doc.createTextNode(new String(Base64.encodeBase64(cert))));
				//certElement.appendChild(doc.createTextNode(Base64.encodeBase64(cert)));
				//	    	certElement.appendChild(doc.createTextNode(new String(Base64.encodeBase64(cert))));
				mirElement.appendChild(certElement);
			}
			
			if (!StringUtils.isEmpty(oaFriendlyName)) {
				Element oaFriendlyNameElement = doc.createElementNS(MIS_NS, "OAFriendlyName");
				oaFriendlyNameElement.appendChild(doc.createTextNode(oaFriendlyName));
				mirElement.appendChild(oaFriendlyNameElement);
			}
			
			Element redirectElement = doc.createElementNS(MIS_NS, "RedirectURL");
			redirectElement.appendChild(doc.createTextNode(redirectURL));
			mirElement.appendChild(redirectElement);
			
			Element referenceValueElement = doc.createElementNS(MIS_NS, "ReferenceValue");
			referenceValueElement.appendChild(doc.createTextNode(referenceValue));
			mirElement.appendChild(referenceValueElement);
			
			if (mandateIdentifier != null && mandateIdentifier.size() > 0) {
				Element filtersElement = doc.createElementNS(MIS_NS, "Filters");
				Element mandateIdentifiersElement = doc.createElementNS(MIS_NS, "MandateIdentifiers");
				for (int i=0; i<mandateIdentifier.size(); i++) {
					Element mandateIdentifierElement = doc.createElementNS(MIS_NS, "MandateIdentifier");
					mandateIdentifierElement.appendChild(doc.createTextNode(mandateIdentifier.get(i)));
					mandateIdentifiersElement.appendChild(mandateIdentifierElement);
				}
				filtersElement.appendChild(mandateIdentifiersElement);
				mirElement.appendChild(filtersElement);
			}

			//add Target element
			Element targetElement = doc.createElementNS(MIS_NS, "Target");
			Element targetTypeElement = doc.createElementNS(MIS_NS, "Type");
			targetTypeElement.appendChild(doc.createTextNode(targetType));
			targetElement.appendChild(targetTypeElement);
			mirElement.appendChild(targetElement);
			
			//add AuthBlock element
			Element authBlockElement = doc.createElementNS(MIS_NS, "authBlock");
			authBlockElement.appendChild(doc.createTextNode(new String(Base64.encodeBase64(authBlock))));
			mirElement.appendChild(authBlockElement);
						
			// send soap request
			Element mandateIssueResponseElement = sendSOAPRequest(
					webServiceURL, 
					mirElement,
					sSLSocketFactory,
					authConfig);

			// check for error
			checkForError(mandateIssueResponseElement);
	    
			// check for session id
			//String sessionId = ((Node) XPathAPI.selectSingleNode(mandateIssueResponseElement, "/mis:MandateIssueResponse/mis:SessionID/text()", NS_NODE)).getNodeValue();
			Node sessionIdNode = ((Node) XPathAPI.selectSingleNode(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:SessionID/text()", NS_NODE));
			if (sessionIdNode == null) {
				throw new MISSimpleClientException("SessionId not found in response.");
			}
			String sessionId = sessionIdNode.getNodeValue();

			Node guiRedirectURLNode = ((Node) XPathAPI.selectSingleNode(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:GuiRedirectURL/text()", NS_NODE));
			if (guiRedirectURLNode == null) {
				throw new MISSimpleClientException("GuiRedirectURL not found in response.");
			}
			String guiRedirectURL = guiRedirectURLNode.getNodeValue();
	    
			// create return object
			MISSessionId msid = new MISSessionId();
			msid.setSessiondId(sessionId);
			msid.setRedirectURL(guiRedirectURL);
	    
			return msid;
		} catch (ParserConfigurationException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		} catch (DOMException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		} catch (TransformerException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
		}
		
	}
	
	private static void checkForError(Element mandateIssueResponseElement) throws MISSimpleClientException {
		if (mandateIssueResponseElement == null) {
			throw new NullPointerException("Argument mandateIssueResponseElement must not be null.");
		}
		try {
		    Element errorElement = (Element) XPathAPI.selectSingleNode(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:Error", NS_NODE);
		    if (errorElement != null) {
		    	String code = ((Node) XPathAPI.selectSingleNode(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:Error/mis:Code/text()", NS_NODE)).getNodeValue();
		    	String text = ((Node) XPathAPI.selectSingleNode(mandateIssueResponseElement, "//mis:MandateIssueResponse/mis:Error/mis:Text/text()", NS_NODE)).getNodeValue();
		    	throw new MISSimpleClientException("service.05", code, text);	    }
		    
		} catch (TransformerException e) {
			throw new MISSimpleClientException("auth.15", e);
		}
	}
	
	private static Element sendSOAPRequest(String webServiceURL, Element request, 
			SSLSocketFactory sSLSocketFactory, 
			AuthConfiguration authConfig) throws MISSimpleClientException {
		
//		try {
//			System.out.println("REQUEST-MIS: \n"  + DOMUtils.serializeNode(request));
//		} catch (TransformerException e1) {
//			e1.printStackTrace();
//		} catch (IOException e1) {
//			e1.printStackTrace();
//		}
		
		if (webServiceURL == null) {
			throw new NullPointerException("Argument webServiceURL must not be null.");
		}
		if (request == null) {
			throw new NullPointerException("Argument request must not be null.");
		}

		CloseableHttpClient httpclient = null;
		CloseableHttpResponse httpResp = null;
		try {
			httpclient = HttpClientWithProxySupport.getHttpClient(
					sSLSocketFactory,
					authConfig.getBasicMOAIDConfigurationBoolean(AuthConfiguration.PROP_KEY_OVS_SSL_HOSTNAME_VALIDATION, true));
			
			// set http POST Request
			HttpPost post = new HttpPost(webServiceURL);		
			HttpEntity postReq = new StringEntity(
					DOMUtils.serializeNode(packIntoSOAP(request)), 
					ContentType.create("text/xml", "UTF-8") );
			post.setEntity(postReq);
			
			//request webService
			httpResp = httpclient.execute(post);
						
			//parse response			
			int responseCode = httpResp.getStatusLine().getStatusCode();			
			if (responseCode != 200) {
				throw new MISSimpleClientException("Invalid HTTP response code " + responseCode);
			}
						
			//Element elem = parse(post.getResponseBodyAsStream());
			Document doc = DOMUtils.parseDocumentSimple(httpResp.getEntity().getContent());
			return unpackFromSOAP(doc.getDocumentElement());
			
		} catch(IOException e) {
			throw new MISSimpleClientException("service.04", new Object[]{webServiceURL, e.getMessage()}, e);
			
		} catch (TransformerException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
			
		} catch (SAXException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
			
		} catch (ParserConfigurationException e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
			
		} catch (Exception e) {
			throw new MISSimpleClientException("service.06", new Object[]{e.getMessage()}, e);
			
		} finally {
				try {
					if (httpclient != null)
						httpclient.close();

					if (httpResp != null)
						httpResp.close();

					
				} catch (IOException e) {
					Logger.error("HTTP-client or Response for MIS communication can NOT be closed!", e);
					
				}
			
			
		}
		
		
	}
	
	private static Element packIntoSOAP(Element element) throws MISSimpleClientException {
		try {
			Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
			Element soapEnvelope = doc.createElement("Envelope");
			soapEnvelope.setAttribute("xmlns", SOAP_NS);
			Element soapBody = doc.createElement("Body");
			soapEnvelope.appendChild(soapBody);
			soapBody.appendChild(doc.importNode(element, true));
			return soapEnvelope;
		} catch(ParserConfigurationException e) {
			throw new MISSimpleClientException("service.06", e);
		}
	}
	
	private static Element unpackFromSOAP(Element element) throws MISSimpleClientException {
		try {
			return (Element) XPathAPI.selectSingleNode(element, "/soap:Envelope/soap:Body/child::*[position()=1]", NS_NODE);
		} catch(TransformerException e) {
			throw new MISSimpleClientException("service.06", e);
		}
	}	
}