package at.gv.egovernment.moa.id.auth.modules.internal.tasks;

import static at.gv.egovernment.moa.id.commons.MOAIDAuthConstants.REQ_GET_FOREIGN_ID;

import java.io.IOException;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileUploadException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
import at.gv.egiz.eaaf.core.exceptions.TaskExecutionException;
import at.gv.egiz.eaaf.core.impl.idp.auth.modules.AbstractAuthServletTask;
import at.gv.egiz.eaaf.core.impl.utils.DataURLBuilder;
import at.gv.egovernment.moa.id.advancedlogging.MOAIDEventConstants;
import at.gv.egovernment.moa.id.auth.AuthenticationServer;
import at.gv.egovernment.moa.id.auth.data.AuthenticationSessionWrapper;
import at.gv.egovernment.moa.id.auth.exception.AuthenticationException;
import at.gv.egovernment.moa.id.commons.api.exceptions.MOAIDException;
import at.gv.egovernment.moa.id.util.CitizenCardServletUtils;
import at.gv.egovernment.moa.logging.Logger;
import at.gv.egovernment.moa.spss.util.CertificateUtils;
import iaik.x509.X509Certificate;

/**
 * Parses the certificate from {@code InfoBoxReadResponse} (via POST parameter {@linkplain at.gv.egovernment.moa.id.commons.MOAIDAuthConstants#PARAM_XMLRESPONSE PARAM_XMLRESPONSE}), creates the auth block to be signed and returns a {@code CreateXMLSignatureRequest} for auth block signature.<p/>
 * In detail:
 * <ul>
 * <li>Renames the moa session id.</li>
 * <li>Retrieves the certificate via {@code InfoBoxReadResponse} from POST parameter {@linkplain at.gv.egovernment.moa.id.commons.MOAIDAuthConstants#PARAM_XMLRESPONSE PARAM_XMLRESPONSE}.</li>
 * <li>Verifies the certificate.</li>
 * <li>Creates the auth block to be signed using information from the certificate (Organwalter, foreign citizen.</li>
 * <li>Puts it in a {@code CreateXMLSignatureRequest}.</li>
 * <li>Updates moa session.</li>
 * <li>Responds with {@code CreateXMLSignatureRequest}.</li>
 * </ul>
 * Expects:
 * <ul>
 * <li>HttpServletRequest parameter {@linkplain at.gv.egovernment.moa.id.commons.MOAIDAuthConstants#PARAM_SESSIONID PARAM_SESSIONID}</li>
 * <li>HttpServletRequest parameter {@linkplain at.gv.egovernment.moa.id.commons.MOAIDAuthConstants#PARAM_XMLRESPONSE PARAM_SESSIONID} containing a {@code InfoBoxReadResponse}.</li>
 * </ul>
 * Result:
 * <ul>
 * <li>{@code CreateXMLSignatureRequest} send as HttpServletResponse (for CCE).</li>
 * </ul>
 * Code taken from {@link at.gv.egovernment.moa.id.auth.servlet.VerifyCertificateServlet}.
 * @see #execute(ExecutionContext, HttpServletRequest, HttpServletResponse)
 *
 */
@Component("VerifyCertificateTask")
public class VerifyCertificateTask extends AbstractAuthServletTask {

	@Autowired @Qualifier("CitizenCardAuthenticationServer") private AuthenticationServer authServer;
	
	@Override 
	public void execute(ExecutionContext executionContext, HttpServletRequest req, HttpServletResponse resp)
			throws TaskExecutionException {

		// note: code taken from at.gv.egovernment.moa.id.auth.servlet.VerifyCertificateServlet

		Logger.debug("Reveive VerifyCertificate Response");
				
		Map<String, String> parameters;
	    try 
	    {
	      parameters = getParameters(req);
	    } catch (FileUploadException | IOException e) 
	    {
	      Logger.error("Parsing mulitpart/form-data request parameters failed: " + e.getMessage());
	      throw new TaskExecutionException(pendingReq, "Parsing mulitpart/form-data request parameters failed", new IOException(e.getMessage()));
	     }
				
	    try {
	    	//execute default task initialization
	    	AuthenticationSessionWrapper moasession = pendingReq.getSessionData(AuthenticationSessionWrapper.class);
			
			revisionsLogger.logEvent(pendingReq, MOAIDEventConstants.AUTHPROCESS_BKU_DATAURL_IP, req.getRemoteHost());
	    		    	
	    	//read certificate from response
    		X509Certificate cert = authServer.getCertificate(pendingReq, parameters);
    		if (cert == null) {
    			Logger.error("Certificate could not be read.");
    			throw new AuthenticationException("auth.14", null);    		
    		}
    			    	
	    	if (moasession.isMandateUsed()) {

	    		// verify certificate for OrganWalter	    		
	    		authServer.verifyCertificate(moasession, cert, pendingReq);
	    		
	    		//create AuthBlock
	    		String createXMLSignatureRequestOrRedirect = 
	    				authServer.getCreateXMLSignatureRequestAuthBlockOrRedirect(moasession, pendingReq);
	    		
	    		//store pending request with new MOASession data information
				requestStoreage.storePendingRequest(pendingReq);
	    		
		    	CitizenCardServletUtils.writeCreateXMLSignatureRequestOrRedirect(resp, pendingReq, createXMLSignatureRequestOrRedirect, AuthenticationServer.REQ_PROCESS_VALIDATOR_INPUT, "VerifyCertificate");
	    		
	    	} else {
	    					    	
	    		String countrycode = CertificateUtils.getIssuerCountry(cert);
	    		if (countrycode != null) {
	    			if (countrycode.compareToIgnoreCase("AT") == 0) {
	    				Logger.error("Certificate issuer country code is \"AT\". Login not support in foreign identities mode.");
	    				throw new AuthenticationException("auth.22", null);
	    			}
	    		}
	    		
	    		// Foreign Identities Modus	
	    		revisionsLogger.logEvent(pendingReq, MOAIDEventConstants.AUTHPROCESS_FOREIGN_FOUND);
	    		
		    	String createXMLSignatureRequest = authServer.createXMLSignatureRequestForeignID(pendingReq, cert);
		    	
		      // build dataurl (to the GetForeignIDSerlvet)
		    	String dataurl =
	             new DataURLBuilder().buildDataURL(
	               pendingReq.getAuthURL(),
	               REQ_GET_FOREIGN_ID,
	               pendingReq.getPendingRequestId());
	      		    	
		    	CitizenCardServletUtils.writeCreateXMLSignatureRequest(resp, createXMLSignatureRequest, AuthenticationServer.REQ_PROCESS_VALIDATOR_INPUT, "GetForeignID", dataurl);
		    	
		    	Logger.debug("Send CreateXMLSignatureRequest to BKU");
	    	}	    		    	 
	    }
	    catch (MOAIDException ex) {
	    	throw new TaskExecutionException(pendingReq, ex.getMessage(), ex);
	      
	    } catch (Exception e) {
	    	Logger.error("CertificateValidation has an interal Error.", e);
	    	throw new TaskExecutionException(pendingReq, e.getMessage(), e);
	    	
	    }
	       
	    
	    finally {
	    	
	    }

	}

}