/*
 * Copyright 2003 Federal Chancellery Austria
 * MOA-SPSS 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.spss.api.impl;

import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.cert.X509Certificate;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import at.gv.egovernment.moa.spss.api.SPSSFactory;
import at.gv.egovernment.moa.spss.api.cmssign.CMSSignatureResponse;
import at.gv.egovernment.moa.spss.api.cmssign.CreateCMSSignatureRequest;
import at.gv.egovernment.moa.spss.api.cmssign.CreateCMSSignatureResponse;
import at.gv.egovernment.moa.spss.api.cmsverify.CMSContent;
import at.gv.egovernment.moa.spss.api.cmsverify.CMSDataObject;
import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureRequest;
import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureResponse;
import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureResponseElement;
import at.gv.egovernment.moa.spss.api.common.CheckResult;
import at.gv.egovernment.moa.spss.api.common.Content;
import at.gv.egovernment.moa.spss.api.common.ExtendedCertificateCheckResult;
import at.gv.egovernment.moa.spss.api.common.MetaInfo;
import at.gv.egovernment.moa.spss.api.common.SignerInfo;
import at.gv.egovernment.moa.spss.api.common.Transform;
import at.gv.egovernment.moa.spss.api.common.TslInfos;
import at.gv.egovernment.moa.spss.api.common.X509IssuerSerial;
import at.gv.egovernment.moa.spss.api.common.XMLDataObjectAssociation;
import at.gv.egovernment.moa.spss.api.common.XPathFilter;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureEnvironmentProfile;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureInfo;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateSignatureLocation;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateTransformsInfo;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateTransformsInfoProfile;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateXMLSignatureRequest;
import at.gv.egovernment.moa.spss.api.xmlsign.CreateXMLSignatureResponse;
import at.gv.egovernment.moa.spss.api.xmlsign.DataObjectInfo;
import at.gv.egovernment.moa.spss.api.xmlsign.ErrorResponse;
import at.gv.egovernment.moa.spss.api.xmlsign.SignatureEnvironmentResponse;
import at.gv.egovernment.moa.spss.api.xmlsign.SingleSignatureInfo;
import at.gv.egovernment.moa.spss.api.xmlverify.ManifestRefsCheckResult;
import at.gv.egovernment.moa.spss.api.xmlverify.ManifestRefsCheckResultInfo;
import at.gv.egovernment.moa.spss.api.xmlverify.ReferenceInfo;
import at.gv.egovernment.moa.spss.api.xmlverify.ReferencesCheckResult;
import at.gv.egovernment.moa.spss.api.xmlverify.ReferencesCheckResultInfo;
import at.gv.egovernment.moa.spss.api.xmlverify.SignatureManifestCheckParams;
import at.gv.egovernment.moa.spss.api.xmlverify.SupplementProfile;
import at.gv.egovernment.moa.spss.api.xmlverify.TransformParameter;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifySignatureInfo;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifySignatureLocation;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifyTransformsInfoProfile;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifyXMLSignatureRequest;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifyXMLSignatureResponse;

/**
 * Default implementation of <code>SPSSFactory</code>.
 * 
 * @author Patrick Peck
 * @version $Id$
 */
public class SPSSFactoryImpl extends SPSSFactory {

	public CreateXMLSignatureRequest createCreateXMLSignatureRequest(String keyIdentifier, List singleSignatureInfos) {
		CreateXMLSignatureRequestImpl createXMLSignatureRequest = new CreateXMLSignatureRequestImpl();
		createXMLSignatureRequest.setKeyIdentifier(keyIdentifier);
		createXMLSignatureRequest.setSingleSignatureInfos(singleSignatureInfos);
		return createXMLSignatureRequest;
	}

	public CreateCMSSignatureRequest createCreateCMSSignatureRequest(String keyIdentifier, List singleSignatureInfos) {
		CreateCMSSignatureRequestImpl createCMSSignatureRequest = new CreateCMSSignatureRequestImpl();
		createCMSSignatureRequest.setKeyIdentifier(keyIdentifier);
		createCMSSignatureRequest.setSingleSignatureInfos(singleSignatureInfos);
		return createCMSSignatureRequest;

	}

	public CreateCMSSignatureResponse createCreateCMSSignatureResponse(List responseElements) {
		CreateCMSSignatureResponseImpl createCMSSignatureResponse = new CreateCMSSignatureResponseImpl();
		createCMSSignatureResponse.setResponseElements(responseElements);
		return createCMSSignatureResponse;
	}

	public CMSSignatureResponse createCMSSignatureResponse(String base64value) {
		CMSSignatureResponseImpl cmsSignatureResponse = new CMSSignatureResponseImpl();
		cmsSignatureResponse.setCMSSignature(base64value);

		return cmsSignatureResponse;
	}

	public SingleSignatureInfo createSingleSignatureInfo(List dataObjectInfos, CreateSignatureInfo createSignatureInfo,
			boolean securityLayerConform) {
		SingleSignatureInfoImpl singleSignatureInfo = new SingleSignatureInfoImpl();
		singleSignatureInfo.setDataObjectInfos(dataObjectInfos);
		singleSignatureInfo.setCreateSignatureInfo(createSignatureInfo);
		singleSignatureInfo.setSecurityLayerConform(securityLayerConform);
		return singleSignatureInfo;
	}

	public at.gv.egovernment.moa.spss.api.cmssign.SingleSignatureInfo createSingleSignatureInfoCMS(
			at.gv.egovernment.moa.spss.api.cmssign.DataObjectInfo dataObjectInfo, boolean securityLayerConform) {
		SingleSignatureInfoCMSImpl singleSignatureInfo = new SingleSignatureInfoCMSImpl();
		singleSignatureInfo.setDataObjectInfo(dataObjectInfo);
		singleSignatureInfo.setSecurityLayerConform(securityLayerConform);
		return singleSignatureInfo;
	}

	public DataObjectInfo createDataObjectInfo(String structure, boolean childOfManifest, Content dataObject,
			CreateTransformsInfoProfile createTransformsInfoProfile) {
		DataObjectInfoImpl dataObjectInfo = new DataObjectInfoImpl();
		dataObjectInfo.setStructure(structure);
		dataObjectInfo.setChildOfManifest(childOfManifest);
		dataObjectInfo.setDataObject(dataObject);
		dataObjectInfo.setCreateTransformsInfoProfile(createTransformsInfoProfile);
		return dataObjectInfo;
	}

	public at.gv.egovernment.moa.spss.api.cmssign.DataObjectInfo createDataObjectInfo(String structure,
			CMSDataObject dataObject) {
		DataObjectInfoCMSImpl dataObjectInfo = new DataObjectInfoCMSImpl();
		dataObjectInfo.setStructure(structure);
		dataObjectInfo.setDataObject(dataObject);
		return dataObjectInfo;
	}

	public CreateTransformsInfoProfile createCreateTransformsInfoProfile(String profileID) {

		CreateTransformsInfoProfileIDImpl createTransformsInfoProfile = new CreateTransformsInfoProfileIDImpl();
		createTransformsInfoProfile.setCreateTransformsInfoProfileID(profileID);
		return createTransformsInfoProfile;
	}

	public CreateTransformsInfoProfile createCreateTransformsInfoProfile(CreateTransformsInfo transformsInfo,
			List supplements) {
		CreateTransformsInfoProfileExplicitImpl createTransformsInfoProfile = new CreateTransformsInfoProfileExplicitImpl();
		createTransformsInfoProfile.setCreateTransformsInfo(transformsInfo);
		createTransformsInfoProfile.setSupplements(supplements);
		return createTransformsInfoProfile;
	}

	public CreateTransformsInfo createCreateTransformsInfo(List transforms, MetaInfo finalDataMetaInfo) {
		CreateTransformsInfoImpl createTransformsInfo = new CreateTransformsInfoImpl();

		createTransformsInfo.setTransforms(transforms);
		createTransformsInfo.setFinalDataMetaInfo(finalDataMetaInfo);
		return createTransformsInfo;
	}

	public CreateSignatureInfo createCreateSignatureInfo(Content createSignatureEnvironment,
			CreateSignatureEnvironmentProfile createSignatureEnvironmentProfile) {
		CreateSignatureInfoImpl createSignatureInfo = new CreateSignatureInfoImpl();
		createSignatureInfo.setCreateSignatureEnvironment(createSignatureEnvironment);
		createSignatureInfo.setCreateSignatureEnvironmentProfile(createSignatureEnvironmentProfile);
		return createSignatureInfo;
	}

	public CreateSignatureEnvironmentProfile createCreateSignatureEnvironmentProfile(
			CreateSignatureLocation createSignatureLocation, List supplements) {
		CreateSignatureEnvironmentProfileExplicitImpl createSignatureEnvironmentProfile = new CreateSignatureEnvironmentProfileExplicitImpl();
		createSignatureEnvironmentProfile.setCreateSignatureLocation(createSignatureLocation);
		createSignatureEnvironmentProfile.setSupplements(supplements);
		return createSignatureEnvironmentProfile;
	}

	public CreateSignatureLocation createCreateSignatureLocation(String signatureLocationXPath,
			int signatureLocationIndex, Map namespaceDeclarations) {
		CreateSignatureLocationImpl createSignatureLocation = new CreateSignatureLocationImpl();
		createSignatureLocation.setIndex(signatureLocationIndex);
		createSignatureLocation.setNamespaceDeclarations(namespaceDeclarations);
		createSignatureLocation.setXPathExpression(signatureLocationXPath);
		return createSignatureLocation;
	}

	public CreateSignatureEnvironmentProfile createCreateSignatureEnvironmentProfile(String profileID) {
		CreateSignatureEnvironmentProfileIDImpl createSignatureEnvironmentProfile = new CreateSignatureEnvironmentProfileIDImpl();
		createSignatureEnvironmentProfile.setCreateSignatureEnvironmentProfileID(profileID);
		return createSignatureEnvironmentProfile;
	}

	public CreateXMLSignatureResponse createCreateXMLSignatureResponse(List responseElements) {
		CreateXMLSignatureResponseImpl createXMLSignatureResponse = new CreateXMLSignatureResponseImpl();
		createXMLSignatureResponse.setResponseElements(responseElements);
		return createXMLSignatureResponse;
	}

	public SignatureEnvironmentResponse createSignatureEnvironmentResponse(Element signatureEnvironment) {
		SignatureEnvironmentResponseImpl signatureEnvironmentResponse = new SignatureEnvironmentResponseImpl();
		signatureEnvironmentResponse.setSignatureEnvironment(signatureEnvironment);
		return signatureEnvironmentResponse;
	}

	public ErrorResponse createErrorResponse(int code, String info) {
		ErrorResponseImpl errorResponse = new ErrorResponseImpl();
		errorResponse.setErrorCode(code);
		errorResponse.setInfo(info);
		return errorResponse;
	}

	public VerifyCMSSignatureRequest createVerifyCMSSignatureRequest(int[] signatories, Date dateTime,
			InputStream cmsSignature, CMSDataObject dataObject, String trustProfileID, boolean pdf) {
		return this.createVerifyCMSSignatureRequest(signatories, dateTime, cmsSignature, dataObject, trustProfileID, pdf, false);
	}

	public VerifyCMSSignatureRequest createVerifyCMSSignatureRequest(int[] signatories, Date dateTime,
			InputStream cmsSignature, CMSDataObject dataObject, String trustProfileID, boolean pdf, boolean extended) {
		VerifyCMSSignatureRequestImpl verifyCMSSignatureRequest = new VerifyCMSSignatureRequestImpl();
		verifyCMSSignatureRequest.setDateTime(dateTime);
		verifyCMSSignatureRequest.setCMSSignature(cmsSignature);
		verifyCMSSignatureRequest.setDataObject(dataObject);
		verifyCMSSignatureRequest.setTrustProfileId(trustProfileID);
		verifyCMSSignatureRequest.setSignatories(signatories);
		verifyCMSSignatureRequest.setPDF(pdf);
		verifyCMSSignatureRequest.setExtended(extended);
		return verifyCMSSignatureRequest;
	}
	
	public CMSDataObject createCMSDataObject(MetaInfo metaInfo, CMSContent content, BigDecimal excludeByteRangeFrom,
			BigDecimal excludeByteRangeTo) {

		CMSDataObjectImpl cmsDataObject = new CMSDataObjectImpl();
		cmsDataObject.setMetaInfo(metaInfo);
		cmsDataObject.setContent(content);
		cmsDataObject.setExcludeByteRangeFrom(excludeByteRangeFrom);
		cmsDataObject.setExcludeByteRangeTo(excludeByteRangeTo);

		return cmsDataObject;
	}

	public CMSContent createCMSContent(InputStream binaryContent) {
		CMSContentExplicitImpl cmsContent = new CMSContentExplicitImpl();

		cmsContent.setBinaryContent(binaryContent);
		return cmsContent;
	}

	public CMSContent createCMSContent(String referenceURI) {
		CMSContentReferenceImpl cmsContent = new CMSContentReferenceImpl();

		cmsContent.setReference(referenceURI);
		return cmsContent;
	}

	public CMSDataObject createCMSDataObject(MetaInfo metaInfo, String referenceURI) {
		CMSDataObjectImpl cmsDataObject = new CMSDataObjectImpl();
		CMSContentReferenceImpl cmsContent = new CMSContentReferenceImpl();
		cmsDataObject.setMetaInfo(metaInfo);
		cmsContent.setReference(referenceURI);
		return cmsDataObject;
	}

	public VerifyCMSSignatureResponse createVerifyCMSSignatureResponse(List responseElements) {
		VerifyCMSSinatureResponseImpl verifyCMSSignatureResponse = new VerifyCMSSinatureResponseImpl();
		verifyCMSSignatureResponse.setResponseElements(responseElements);
		return verifyCMSSignatureResponse;
	}

	public VerifyCMSSignatureResponseElement createVerifyCMSSignatureResponseElement(SignerInfo signerInfo,
			CheckResult signatureCheck, CheckResult certificateCheck, List adesResult, 
		    ExtendedCertificateCheckResult extendedCertificateCheckResult) {
		VerifyCMSSignatureResponseElementImpl verifyCMSSignatureResponseElement = new VerifyCMSSignatureResponseElementImpl();
		verifyCMSSignatureResponseElement.setSignerInfo(signerInfo);
		verifyCMSSignatureResponseElement.setSignatureCheck(signatureCheck);
		verifyCMSSignatureResponseElement.setCertificateCheck(certificateCheck);
		verifyCMSSignatureResponseElement.setAdESFormResults(adesResult);
		verifyCMSSignatureResponseElement.setExtendedCertificateCheck(extendedCertificateCheckResult);
		return verifyCMSSignatureResponseElement;
	}

	public VerifyXMLSignatureRequest createVerifyXMLSignatureRequest(Date dateTime,
			VerifySignatureInfo verifySignatureInfo, List supplementProfiles,
			SignatureManifestCheckParams signatureManifestParams, boolean returnHashInputData, String trustProfileID) {
		return this.createVerifyXMLSignatureRequest(dateTime, verifySignatureInfo, supplementProfiles,
				signatureManifestParams, returnHashInputData, trustProfileID, false);
	}

	public VerifySignatureInfo createVerifySignatureInfo(Content verifySignatureEnvironment,
			VerifySignatureLocation verifySignatureLocation) {
		VerifySignatureInfoImpl verifySignatureInfo = new VerifySignatureInfoImpl();
		verifySignatureInfo.setVerifySignatureEnvironment(verifySignatureEnvironment);
		verifySignatureInfo.setVerifySignatureLocation(verifySignatureLocation);
		return verifySignatureInfo;
	}

	public VerifySignatureLocation createVerifySignatureLocation(String xPathExpression, Map namespaceDeclarations) {
		VerifySignatureLocationImpl verifySignatureLocation = new VerifySignatureLocationImpl();
		verifySignatureLocation.setXPathExpression(xPathExpression);
		verifySignatureLocation.setNamespaceDeclarations(namespaceDeclarations);
		return verifySignatureLocation;
	}

	public SupplementProfile createSupplementProfile(String profileID) {
		SupplementProfileIDImpl supplementProfileID = new SupplementProfileIDImpl();
		supplementProfileID.setSupplementProfileID(profileID);
		return supplementProfileID;
	}

	public SupplementProfile createSupplementProfile(XMLDataObjectAssociation supplementProfile) {
		SupplementProfileExplicitImpl supplementProfileExplicit = new SupplementProfileExplicitImpl();
		supplementProfileExplicit.setSupplementProfile(supplementProfile);
		return supplementProfileExplicit;
	}

	public SignatureManifestCheckParams createSignatureManifestCheckParams(List referenceInfos,
			boolean returnReferenceInputData) {
		SignatureManifestCheckParamsImpl signatureManifestCheckParams = new SignatureManifestCheckParamsImpl();
		signatureManifestCheckParams.setReferenceInfos(referenceInfos);
		signatureManifestCheckParams.setReturnReferenceInputData(returnReferenceInputData);
		return signatureManifestCheckParams;
	}

	public ReferenceInfo createReferenceInfo(List verifyTransformsInfoProfiles) {
		ReferenceInfoImpl referenceInfo = new ReferenceInfoImpl();
		referenceInfo.setVerifyTransformsInfoProfiles(verifyTransformsInfoProfiles);
		return referenceInfo;
	}

	public VerifyTransformsInfoProfile createVerifyTransformsInfoProfile(List transforms, List transformParameters) {
		VerifyTransformsInfoProfileExplicitImpl verifyTransformsInfoProfile = new VerifyTransformsInfoProfileExplicitImpl();

		verifyTransformsInfoProfile.setTransforms(transforms);
		verifyTransformsInfoProfile.setTransformParameters(transformParameters);

		return verifyTransformsInfoProfile;
	}

	public VerifyTransformsInfoProfile createVerifyTransformsInfoProfile(String profileID) {
		VerifyTransformsInfoProfileIDImpl verifyTransformsInfoProfile = new VerifyTransformsInfoProfileIDImpl();
		verifyTransformsInfoProfile.setVerifyTransformsInfoProfileID(profileID);
		return verifyTransformsInfoProfile;
	}

	public TransformParameter createTransformParameter(String URI, String digestMethod, byte[] digestValue) {
		TransformPatameterHashImpl transformParameter = new TransformPatameterHashImpl();
		transformParameter.setURI(URI);
		transformParameter.setDigestMethod(digestMethod);
		transformParameter.setDigestValue(digestValue);
		return transformParameter;
	}

	public TransformParameter createTransformParameter(String URI, InputStream binaryData) {
		TransformParameterBinaryImpl transformParameter = new TransformParameterBinaryImpl();
		transformParameter.setURI(URI);
		transformParameter.setBinaryContent(binaryData);
		return transformParameter;
	}

	public TransformParameter createTransformParameter(String URI) {
		TransformParameterURIImpl transformParameter = new TransformParameterURIImpl();
		transformParameter.setURI(URI);
		return transformParameter;
	}

	public VerifyXMLSignatureResponse createVerifyXMLSignatureResponse(SignerInfo signerInfo, List hashInputDatas,
			List referenceInputDatas, ReferencesCheckResult signatureCheck,
			ReferencesCheckResult signatureManifestCheck, List xmlDsigManifestChecks, CheckResult certificateCheck,
			List adesFormResults, ExtendedCertificateCheckResult extCheckResult) {
		VerifyXMLSignatureResponseImpl verifyXMLSignatureResponse = new VerifyXMLSignatureResponseImpl();
		verifyXMLSignatureResponse.setSignerInfo(signerInfo);
		verifyXMLSignatureResponse.setHashInputDatas(hashInputDatas);
		verifyXMLSignatureResponse.setReferenceInputDatas(referenceInputDatas);
		verifyXMLSignatureResponse.setSignatureCheck(signatureCheck);
		verifyXMLSignatureResponse.setSignatureManifestCheck(signatureManifestCheck);
		verifyXMLSignatureResponse.setXMLDsigManifestChecks(xmlDsigManifestChecks);
		verifyXMLSignatureResponse.setCertificateCheck(certificateCheck);
		verifyXMLSignatureResponse.setAdESFormResults(adesFormResults);
		verifyXMLSignatureResponse.setExtendedCertificateCheck(extCheckResult);
		return verifyXMLSignatureResponse;
	}

	public ReferencesCheckResult createReferencesCheckResult(int code, ReferencesCheckResultInfo info) {
		ReferencesCheckResultImpl referencesCheckResult = new ReferencesCheckResultImpl();
		referencesCheckResult.setCode(code);
		referencesCheckResult.setInfo(info);
		return referencesCheckResult;
	}

	public ReferencesCheckResultInfo createReferencesCheckResultInfo(NodeList anyOtherInfo, int[] failedReferences) {
		ReferencesCheckResultInfoImpl referencesCheckResultInfo = new ReferencesCheckResultInfoImpl();
		referencesCheckResultInfo.setAnyOtherInfo(anyOtherInfo);
		referencesCheckResultInfo.setFailedReferences(failedReferences);
		return referencesCheckResultInfo;
	}

	public ManifestRefsCheckResult createManifestRefsCheckResult(int code, ManifestRefsCheckResultInfo info) {
		ManifestRefsCheckResultImpl manifestRefsCheckResult = new ManifestRefsCheckResultImpl();
		manifestRefsCheckResult.setCode(code);
		manifestRefsCheckResult.setInfo(info);
		return manifestRefsCheckResult;
	}

	public ManifestRefsCheckResultInfo createManifestRefsCheckResultInfo(NodeList anyOtherInfo, int[] failedReferences,
			int referringSigReference) {
		ManifestRefsCheckResultInfoImpl manifestRefsCheckResultInfo = new ManifestRefsCheckResultInfoImpl();
		manifestRefsCheckResultInfo.setAnyOtherInfo(anyOtherInfo);
		manifestRefsCheckResultInfo.setReferringSignatureReference(referringSigReference);
		manifestRefsCheckResultInfo.setFailedReferences(failedReferences);
		return manifestRefsCheckResultInfo;
	}

	public Content createContent(InputStream binaryData, String referenceURI) {
		ContentBinaryImpl content = new ContentBinaryImpl();
		content.setBinaryContent(binaryData);
		content.setReference(referenceURI);
		return content;
	}

	public Content createContent(String locationReferenceURI, String referenceURI) {
		ContentLocRefImpl content = new ContentLocRefImpl();
		content.setLocationReferenceURI(locationReferenceURI);
		content.setReference(referenceURI);
		return content;
	}

	public Content createContent(String referenceURI) {
		ContentReferenceImpl content = new ContentReferenceImpl();
		content.setReference(referenceURI);
		return content;
	}

	public Content createContent(NodeList xmlData, String referenceURI) {
		ContentXMLImpl content = new ContentXMLImpl();
		content.setXMLContent(xmlData);
		content.setReference(referenceURI);
		return content;
	}

	public XMLDataObjectAssociation createXMLDataObjectAssociation(MetaInfo metaInfo, Content xmlContent) {
		XMLDataObjectAssociationImpl xmlDataObjectAssociation = new XMLDataObjectAssociationImpl();
		xmlDataObjectAssociation.setMetaInfo(metaInfo);
		xmlDataObjectAssociation.setContent(xmlContent);
		return xmlDataObjectAssociation;
	}

	public MetaInfo createMetaInfo(String mimeType, String description, NodeList otherInfo, String type) {
		MetaInfoImpl metaInfo = new MetaInfoImpl();
		metaInfo.setMimeType(mimeType);
		metaInfo.setDescription(description);
		metaInfo.setAnyElements(otherInfo);
		metaInfo.setType(type);
		return metaInfo;
	}

	public Transform createCanonicalizationTransform(String algorithmURI) {
		CanonicalizationTransformImpl transform = new CanonicalizationTransformImpl(algorithmURI);
		return transform;
	}

	public Transform createExclusiveCanonicalizationTransform(String algorithmURI, List inclusiveNamespacePrefixes) {
		ExclusiveCanonicalizationTransformImpl transform = new ExclusiveCanonicalizationTransformImpl(algorithmURI);
		transform.setInclusiveNamespacePrefixes(inclusiveNamespacePrefixes);
		return transform;
	}

	public Transform createBase64Transform() {
		Base64TransformImpl transform = new Base64TransformImpl();
		return transform;
	}

	public Transform createEnvelopedSignatureTransform() {
		EnvelopedSignatureTransformImpl transform = new EnvelopedSignatureTransformImpl();
		return transform;
	}

	public Transform createXSLTTransform(Element styleSheet) {
		XSLTransformImpl transform = new XSLTransformImpl();
		transform.setStylesheet(styleSheet);
		return transform;
	}

	public Transform createXPathTransform(String xPathExpression, Map namespaceDeclarations) {
		XPathTransformImpl transform = new XPathTransformImpl();
		transform.setXPathExpression(xPathExpression);
		transform.setNamespaceDelcarations(namespaceDeclarations);
		return transform;
	}

	public Transform createXPathFilter2Transform(List xPathFilters) {
		XPathFilter2TransformImpl transform = new XPathFilter2TransformImpl();
		transform.setFilters(xPathFilters);
		return transform;
	}

	public XPathFilter createXPathFilter(String filterType, String xPathExpression, Map namespaceDeclarations) {
		XPathFilterImpl xPathFilter = new XPathFilterImpl();
		xPathFilter.setFilterType(filterType);
		xPathFilter.setXPathExpression(xPathExpression);
		xPathFilter.setNamespaceDelcarations(namespaceDeclarations);
		return xPathFilter;
	}

	public CheckResult createCheckResult(int code, NodeList info) {
		CheckResultImpl checkResult = new CheckResultImpl();
		checkResult.setCode(code);
		checkResult.setInfo(info);
		return checkResult;
	}

	public SignerInfo createSignerInfo(X509Certificate signerCertificate, boolean qualifiedCertificate,
			boolean qcSourceTSL, boolean publicAuthority, String publicAuthorityID, boolean sscd, boolean sscdSourceTSL,
			String issuerCountryCode, Date signingTime, TslInfos tslInfos) {
		SignerInfoImpl signerInfo = new SignerInfoImpl();
		signerInfo.setSignerCertificate(signerCertificate);
		signerInfo.setQualifiedCertificate(qualifiedCertificate);
		signerInfo.setQCSourceTSL(qcSourceTSL);
		signerInfo.setPublicAuthority(publicAuthority);
		signerInfo.setPublicAuhtorityID(publicAuthorityID);
		signerInfo.setSSCD(sscd);
		signerInfo.setSSCDSourceTSL(sscdSourceTSL);
		signerInfo.setIssuerCountryCode(issuerCountryCode);
		signerInfo.setSigningTime(signingTime);
		signerInfo.setTslInfos(tslInfos);
		return signerInfo;
	}

	public X509IssuerSerial createX509IssuerSerial(String issuerName, BigInteger serialNumber) {
		X509IssuerSerialImpl x509IssuerSerial = new X509IssuerSerialImpl();
		x509IssuerSerial.setX509IssuerName(issuerName);
		x509IssuerSerial.setX509SerialNumber(serialNumber);
		return x509IssuerSerial;
	}

	@Override
	public VerifyXMLSignatureRequest createVerifyXMLSignatureRequest(Date dateTime,
			VerifySignatureInfo verifySignatureInfo, List supplementProfiles,
			SignatureManifestCheckParams signatureManifestParams, boolean returnHashInputData, String trustProfileID,
			boolean extendedValidation) {
		VerifyXMLSignatureRequestImpl verifyXMLSignatureRequest = new VerifyXMLSignatureRequestImpl();
		verifyXMLSignatureRequest.setDateTime(dateTime);
		verifyXMLSignatureRequest.setSignatureInfo(verifySignatureInfo);
		verifyXMLSignatureRequest.setSupplementProfiles(supplementProfiles);
		verifyXMLSignatureRequest.setSignatureManifestCheckParams(signatureManifestParams);
		verifyXMLSignatureRequest.setReturnHashInputData(returnHashInputData);
		verifyXMLSignatureRequest.setTrustProfileId(trustProfileID);
		verifyXMLSignatureRequest.setExtendedValidation(extendedValidation);
		return verifyXMLSignatureRequest;
	}

}