/*
 * 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.eidas.utils;

import at.gv.egovernment.moa.id.auth.modules.eidas.config.MOAIDCertificateManagerConfigurationImpl;
import at.gv.egovernment.moa.id.auth.modules.eidas.engine.MOAProtocolEngine;
import at.gv.egovernment.moa.logging.Logger;
import eu.eidas.auth.engine.ProtocolEngineFactory;
import eu.eidas.auth.engine.ProtocolEngineI;
import eu.eidas.auth.engine.SamlEngineClock;
import eu.eidas.auth.engine.configuration.FixedProtocolConfigurationAccessor;
import eu.eidas.auth.engine.configuration.ProtocolEngineConfiguration;
import eu.eidas.auth.engine.configuration.SamlEngineConfigurationException;
import eu.eidas.auth.engine.configuration.dom.ProtocolEngineConfigurationFactory;
import eu.eidas.auth.engine.core.ProtocolProcessorI;
import eu.eidas.samlengineconfig.CertificateConfigurationManager;

/**
 * @author tlenz
 *
 */
public class MOAProtocolEngineFactory extends ProtocolEngineFactory {

	/**
     * Initialization-on-demand holder idiom.
     * <p/>
     * See item 71 of Effective Java 2nd Edition.
     * <p/>
     * See http://en.wikipedia.org/wiki/Initialization-on-demand_holder_idiom.
     */
    private static final class LazyHolder {

        private static final MOAProtocolEngineFactory DEFAULT_SAML_ENGINE_FACTORY;

        private static final Exception INITIALIZATION_EXCEPTION;

        static {
            Exception initializationException = null;
            MOAProtocolEngineFactory defaultProtocolEngineFactory = null;
            try {
            	//get eIDAS SAMLengine configuration from MOA-ID configuration
				CertificateConfigurationManager configManager = new MOAIDCertificateManagerConfigurationImpl();
            					
				ProtocolEngineConfigurationFactory engineConfigurationFactory = new ProtocolEngineConfigurationFactory(configManager);
                defaultProtocolEngineFactory = new MOAProtocolEngineFactory(engineConfigurationFactory);
                                                
            } catch (Exception ex) {
                initializationException = ex;
                Logger.error("Unable to instantiate default SAML engines: " + ex, ex);
                
            }
            
            DEFAULT_SAML_ENGINE_FACTORY = defaultProtocolEngineFactory;
            INITIALIZATION_EXCEPTION = initializationException;
        }

        static MOAProtocolEngineFactory getDefaultSamlEngineFactory() {
            if (null == INITIALIZATION_EXCEPTION) {
                return DEFAULT_SAML_ENGINE_FACTORY;
                
            } else {
                throw new IllegalStateException(INITIALIZATION_EXCEPTION);
                
            }
        }
    }
	

	public static MOAProtocolEngineFactory getInstance() {
		return LazyHolder.getDefaultSamlEngineFactory();
		
	}

	/**
	 * @param configurationFactory
	 * @throws SamlEngineConfigurationException
	 */
	private MOAProtocolEngineFactory(ProtocolEngineConfigurationFactory configurationFactory)
			throws SamlEngineConfigurationException {
		super(configurationFactory);
		
	}

	public static ProtocolEngineI ownCreateProtocolEngine(String instanceName,
			CertificateConfigurationManager configManager, ProtocolProcessorI protocolProcessor,
			SamlEngineClock samlEngineClock) throws SamlEngineConfigurationException {
		ProtocolEngineConfigurationFactory protocolEngineConfigurationFactory = new ProtocolEngineConfigurationFactory(
				configManager);

		return createProtocolEngine(instanceName, protocolEngineConfigurationFactory, protocolProcessor,
				samlEngineClock);
	}
	
	public static ProtocolEngineI createProtocolEngine(String instanceName,
			ProtocolEngineConfigurationFactory protocolEngineConfigurationFactory,
			ProtocolProcessorI protocolProcessor, SamlEngineClock samlEngineClock)
					throws SamlEngineConfigurationException {
	
		ProtocolEngineConfiguration preConfiguration = protocolEngineConfigurationFactory
				.getConfiguration(instanceName);

		protocolProcessor.configure();

		ProtocolEngineConfiguration configuration = ProtocolEngineConfiguration.builder(preConfiguration)
				.protocolProcessor(protocolProcessor).clock(samlEngineClock).build();

		ProtocolEngineI samlEngine = new MOAProtocolEngine(new FixedProtocolConfigurationAccessor(configuration));

		return samlEngine;
	}

}