package at.gv.egovernment.moa.id.protocols.pvp2x.metadata;

import iaik.util.logging.Log;

import java.security.cert.CertificateException;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Timer;

import javax.xml.namespace.QName;

import org.apache.commons.httpclient.HttpClient;
import org.opensaml.saml2.metadata.EntitiesDescriptor;
import org.opensaml.saml2.metadata.EntityDescriptor;
import org.opensaml.saml2.metadata.RoleDescriptor;
import org.opensaml.saml2.metadata.provider.ChainingMetadataProvider;
import org.opensaml.saml2.metadata.provider.HTTPMetadataProvider;
import org.opensaml.saml2.metadata.provider.MetadataFilter;
import org.opensaml.saml2.metadata.provider.MetadataProvider;
import org.opensaml.saml2.metadata.provider.MetadataProviderException;
import org.opensaml.xml.XMLObject;
import org.opensaml.xml.parse.BasicParserPool;

import at.gv.egovernment.moa.id.commons.db.ConfigurationDBRead;
import at.gv.egovernment.moa.id.commons.db.dao.config.OAPVP2;
import at.gv.egovernment.moa.id.commons.db.dao.config.OnlineApplication;
import at.gv.egovernment.moa.id.protocols.pvp2x.verification.MetadataSignatureFilter;
import at.gv.egovernment.moa.logging.Logger;
import at.gv.egovernment.moa.util.MiscUtil;

public class MOAMetadataProvider implements MetadataProvider {

	private static MOAMetadataProvider instance = null;

	private static Object mutex = new Object();
	private static Date timestamp;
	
	
	public static MOAMetadataProvider getInstance() {
		if (instance == null) {
			synchronized (mutex) {
				if (instance == null) {
					instance = new MOAMetadataProvider();
				}
			}
		}
		return instance;
	}

	public static Date getTimeStamp() {
		return timestamp;
	}
	
	public void reInitialize() {
		synchronized (mutex) {
			Log.info("ReInitalize MOAMetaDataProvider.");
			instance = new MOAMetadataProvider();
		}
	}
	
	MetadataProvider internalProvider;

	private MOAMetadataProvider() {
		ChainingMetadataProvider chainProvider = new ChainingMetadataProvider();
		Logger.info("Loading metadata");
		List<OnlineApplication> oaList = ConfigurationDBRead
				.getAllActiveOnlineApplications();
		Iterator<OnlineApplication> oaIt = oaList.iterator();
		while (oaIt.hasNext()) {
			try {
				OnlineApplication oa = oaIt.next();
				Logger.info("Loading metadata for: " + oa.getFriendlyName());
				OAPVP2 pvp2Config = oa.getAuthComponentOA().getOAPVP2();
				if (pvp2Config != null && MiscUtil.isNotEmpty(pvp2Config.getMetadataURL())) {
//				if (pvp2Config != null) {
					String metadataURL = pvp2Config.getMetadataURL();
					try {
						// TODO: use proper SSL checking
						HTTPMetadataProvider httpProvider = 
								new HTTPMetadataProvider(new Timer(), new HttpClient(), 
										metadataURL);
						httpProvider.setParserPool(new BasicParserPool());
						httpProvider.setRequireValidMetadata(true);
						httpProvider.setMinRefreshDelay(1000*60*5); //5min
						httpProvider.setMaxRefreshDelay(1000*60*30); //30min
						//httpProvider.setRefreshDelayFactor(0.1F);
						MetadataFilter filter = new MetadataSignatureFilter(
								metadataURL, pvp2Config.getCertificate());
						httpProvider.setMetadataFilter(filter);
						chainProvider.addMetadataProvider(httpProvider);
						httpProvider.initialize();

					} catch (MetadataProviderException e) {
						Logger.error(
								"Failed to add Metadata file for "
										+ oa.getFriendlyName() + "[ "
										+ e.getMessage() + " ]", e);
					} catch (CertificateException e) {
						Logger.error(
								"Failed to add Metadata file for "
										+ oa.getFriendlyName() + "[ "
										+ e.getMessage() + " ]", e);
					}
				} else {
					Logger.info(oa.getFriendlyName()
							+ " is not a PVP2 Application skipping");
				}
			} catch (Throwable e) {
				Logger.error(
						"Failed to add Metadata (unhandled reason: "
								+ e.getMessage(), e);
			}			
		}
		
		internalProvider = chainProvider;
		timestamp = new Date();
	}
	
	public boolean requireValidMetadata() {
		return internalProvider.requireValidMetadata();
	}

	public void setRequireValidMetadata(boolean requireValidMetadata) {
		internalProvider.setRequireValidMetadata(requireValidMetadata);
	}

	public MetadataFilter getMetadataFilter() {
		return internalProvider.getMetadataFilter();
	}

	public void setMetadataFilter(MetadataFilter newFilter)
			throws MetadataProviderException {
		internalProvider.setMetadataFilter(newFilter);
	}

	public XMLObject getMetadata() throws MetadataProviderException {
		return internalProvider.getMetadata();
	}

	public EntitiesDescriptor getEntitiesDescriptor(String name)
			throws MetadataProviderException {
		return internalProvider.getEntitiesDescriptor(name);
	}

	public EntityDescriptor getEntityDescriptor(String entityID)
			throws MetadataProviderException {
		return internalProvider.getEntityDescriptor(entityID);
	}

	public List<RoleDescriptor> getRole(String entityID, QName roleName)
			throws MetadataProviderException {
		return internalProvider.getRole(entityID, roleName);
	}

	public RoleDescriptor getRole(String entityID, QName roleName,
			String supportedProtocol) throws MetadataProviderException {
		return internalProvider.getRole(entityID, roleName, supportedProtocol);
	}

}