/*
 * 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.
 */
package at.gv.egovernment.moa.id.auth.modules.internal.tasks;

import java.util.List;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
import at.gv.egiz.eaaf.core.exceptions.EAAFException;
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.idp.controller.protocols.RequestImpl;
import at.gv.egiz.eaaf.core.impl.utils.FileUtils;
import at.gv.egovernment.moa.id.advancedlogging.MOAIDEventConstants;
import at.gv.egovernment.moa.id.auth.data.AuthenticationSessionWrapper;
import at.gv.egovernment.moa.id.auth.exception.AuthenticationException;
import at.gv.egovernment.moa.id.auth.parser.StartAuthentificationParameterParser;
import at.gv.egovernment.moa.id.commons.MOAIDAuthConstants;
import at.gv.egovernment.moa.id.commons.api.AuthConfiguration;
import at.gv.egovernment.moa.id.commons.api.IOAAuthParameters;
import at.gv.egovernment.moa.id.commons.api.exceptions.MOAIDException;
import at.gv.egovernment.moa.id.commons.db.ex.MOADatabaseException;
import at.gv.egovernment.moa.logging.Logger;
import at.gv.egovernment.moa.util.MiscUtil;

/**
 * @author tlenz
 *
 */
@Component("InitializeBKUAuthenticationTask")
public class InitializeBKUAuthenticationTask extends AbstractAuthServletTask {

	@Autowired StartAuthentificationParameterParser authInitialisationParser;
	@Autowired private AuthConfiguration moaAuthConfig;
	
	/* (non-Javadoc)
	 * @see at.gv.egovernment.moa.id.process.springweb.MoaIdTask#execute(at.gv.egovernment.moa.id.process.api.ExecutionContext, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
	 */
	@Override 
	public void execute(ExecutionContext executionContext,
			HttpServletRequest request, HttpServletResponse response)
			throws TaskExecutionException {
		
		try {
			//
			internalInitializeWithoutPersist(executionContext, request, response);			
			requestStoreage.storePendingRequest(pendingReq);
			
			
		} catch (MOADatabaseException | MOAIDException e) {
			Logger.info("Initialize BKUAuthentication FAILED. Reason:" + e.getMessage());
			throw new TaskExecutionException(pendingReq, e.getMessage(), e);
			
		} catch (Exception e) {
			Logger.warn("InitializeBKUAuthentication has an internal error", e);
			throw new TaskExecutionException(pendingReq, e.getMessage(), e);
			
		}

	}
	
	protected void internalInitializeWithoutPersist(ExecutionContext executionContext,
			HttpServletRequest request, HttpServletResponse response) throws EAAFException {
		
		Logger.info("BKU is selected -> Start BKU communication ...");			
		//AuthenticationSessionWrapper moasession = new AuthenticationSessionWrapper(pendingReq.genericFullDataStorage());
		
		AuthenticationSessionWrapper moasession = ((RequestImpl)pendingReq).getSessionData(AuthenticationSessionWrapper.class);
		
		boolean isLegacyRequest = false;
		Object isLegacyRequestObj = executionContext.get("isLegacyRequest");
		if (isLegacyRequestObj != null && isLegacyRequestObj instanceof Boolean)
			isLegacyRequest = (boolean) isLegacyRequestObj;

		if (isLegacyRequest) {
			//parse request parameter into MOASession
		    Logger.info("Start Authentication Module: " + pendingReq.requestedModule() 
		    		+ " Action: " + pendingReq.requestedAction());

		    authInitialisationParser.parse(executionContext, moasession, request, pendingReq);
											
		} else {						
	    	String bkuid = (String) executionContext.get(MOAIDAuthConstants.PARAM_BKU);
	    	String useMandate = (String) executionContext.get(MOAIDAuthConstants.PARAM_USEMANDATE);
			String ccc = (String) executionContext.get(MOAIDAuthConstants.PARAM_CCC);
											
	    	if (MiscUtil.isEmpty(bkuid)) {
	    		Logger.warn("BKU-type is empty. Maybe an old BKU-selection template is in use.");
	    		throw new MOAIDException("auth.23", new Object[] {});
	    	}
							
	    	//load OA Config
			IOAAuthParameters oaParam = pendingReq.getServiceProviderConfiguration(IOAAuthParameters.class);
			
			if (oaParam == null)
				throw new AuthenticationException("auth.00", new Object[] { pendingReq.getSPEntityId() });
			
			else {
				revisionsLogger.logEvent(pendingReq, MOAIDEventConstants.AUTHPROCESS_BKUTYPE_SELECTED, bkuid);
				
		    	//get Target from config or from request in case of SAML 1				
				String target = null;
				if (MiscUtil.isNotEmpty(pendingReq.getRawData("saml1_target", String.class)) && 
						pendingReq.requestedModule().equals("at.gv.egovernment.moa.id.protocols.saml1.SAML1Protocol"))
					target = pendingReq.getRawData("saml1_target", String.class);

				
		    	String bkuURL = oaParam.getBKUURL(bkuid);
		    	if (MiscUtil.isEmpty(bkuURL)) {
		    		Logger.info("No OA specific BKU defined. Use BKU from default configuration");
		    		bkuURL = moaAuthConfig.getDefaultBKUURL(bkuid);
		    	}
		    	
		    	//search for OA specific template
		    	String templateURL = null;
		    	List<String> oaTemplateURLList = oaParam.getTemplateURL();
		    	if ( oaTemplateURLList != null && oaTemplateURLList.size() > 0
		    			&& MiscUtil.isNotEmpty(oaTemplateURLList.get(0)) ) {
		    		templateURL = oaTemplateURLList.get(0);
		    		
		    	} else {		    	
		    		templateURL = moaAuthConfig.getSLRequestTemplates(bkuid);
		    	}
		    	
		    	//make url absolut if it is a local url
	    		if (MiscUtil.isNotEmpty(templateURL))
	    			templateURL = FileUtils.makeAbsoluteURL(templateURL, 
	    					moaAuthConfig.getRootConfigFileDir());
		    	
		    	if (oaParam.isOnlyMandateAllowed()) 
		    		useMandate = "true";
		    	
		    	if (!oaParam.isShowMandateCheckBox())
		    		useMandate = "false";
		    	
		    	//parse all OA parameters i
		    	authInitialisationParser.parse(	moasession, 
		    									target, 
		    									pendingReq.getSPEntityId(),
		    									bkuURL,
		    									templateURL,
		    									useMandate,
		    									ccc, 
		    									request,
		    									pendingReq);
			}
		}
		
		//set useMandate flag to executionContext
		executionContext.put(MOAIDAuthConstants.PARAM_USEMANDATE, moasession.isMandateUsed());
				
	}

}