package org.eparapher.core.signature;
   
   import javax.xml.crypto.dsig.CanonicalizationMethod;
   import javax.xml.crypto.dsig.DigestMethod;
   import javax.xml.crypto.dsig.SignatureMethod;
   import javax.xml.crypto.dsig.Transform;
   
   import org.eparapher.core.EParapherManager;
   import org.eparapher.core.tools.StringUtils;
  
  
  public class XMLSignatureParameters extends DefaultSignatureParameters {
  
  	public final static String[][] XMLHashAlgFamilies = { { "SHA 1",     DigestMethod.SHA1 },
  		  												  { "SHA 256",   DigestMethod.SHA256 },
  		  												  { "SHA 512",   DigestMethod.SHA512 },
  		  												  { "RIPEMD160", DigestMethod.RIPEMD160 } };
  
  	public final static String[][] XMLSigAlgFamilies = { { "RSA SHA 1",     SignatureMethod.RSA_SHA1 },
  		  												 { "DSA SHA 1",   SignatureMethod.DSA_SHA1 },
  		  												 { "HMAC SHA1",   SignatureMethod.HMAC_SHA1 } };
  	
  	public final static String[][] XMLTransformFamilies = { { "ENVELOPED", Transform.ENVELOPED },
  		  												    { "BASE64",    Transform.BASE64 },
  		  												    //{ "XSLT",      Transform.XSLT },
  		  												    { "XPATH",     Transform.XPATH },
  		  												    { "XPATH2",    Transform.XPATH2 } };
  	
  	public final static String[][] XMLCanonicalFamilies = { { "EXCLUSIVE", CanonicalizationMethod.EXCLUSIVE },
  		  												    { "EXCLUSIVE_WITH_COMMENTS",   CanonicalizationMethod.EXCLUSIVE_WITH_COMMENTS },
  		  												    { "INCLUSIVE", CanonicalizationMethod.INCLUSIVE },
  		  												    { "INCLUSIVE_WITH_COMMENTS",     CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS } };
  	
  	public final static String[][] XMLSigFormatFamilies = { { "Detached",     "Detached" },
  															{ "Enveloped",    "Enveloped" },
  															//{ "Enveloping",   "Enveloping" }
  														  };
  
  	public static final String[] XMLExtentions          = { "xml","htm","html","xhtml","xst",
  															"xslt","xsl","xbrl","shtml"};
  	
  	private String  digestAlg;
  	private String  signatureAlg;
  	
  	private String  transform;
  	private String  canonical;
  	
  	private String ObjectIds ;
  
  	private boolean detached;
  	private boolean enveloped;
  	private boolean enveloping;
  	
  	private boolean overwritesignedfile;
  	
  	private boolean dtdVerification;
  
  	
  	public XMLSignatureParameters() {
  
  		digestAlg          = DigestMethod.SHA512;
  		signatureAlg       = SignatureMethod.RSA_SHA1;
  		transform          = Transform.ENVELOPED;
  		canonical          = CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS;
  		detached           = false;
  		enveloped          = true;
  		enveloping         = false;
  		dtdVerification    = true;
  	}
  
  	public void setXMLSignatureParamsFromPreferences() {
  		
  		loadDefaultSignatureParameters();
  		
  		if (EParapherManager.getInstance().getSettings().getXMLSignatureFormat().equals(XMLSigFormatFamilies[0][1]))
  			detached        =  true;
  		else 
  			detached        =  false;
  		if (EParapherManager.getInstance().getSettings().getXMLSignatureFormat().equals(XMLSigFormatFamilies[1][1]))
  			enveloped       =  true;
  		else 
  			enveloped        =  false;
  		//TODO : reactivate XML envelopping signature here
  		//if (EPConfig.getXMLSignatureFormat().equals(XMLSigFormatFamilies[2][1]))
  			//enveloping      =  true;
  		//else 
  			enveloping        =  false;
  		
  		overwritesignedfile =  EParapherManager.getInstance().getSettings().isXMLSignatureReplaceFile();
  
  		digestAlg           =  EParapherManager.getInstance().getSettings().getXMLDigestAlgorithm();
  		signatureAlg        =  EParapherManager.getInstance().getSettings().getXMLSignatureAlgorithm();
  		
  		transform           =  EParapherManager.getInstance().getSettings().getXMLTransform();
  		canonical           =  EParapherManager.getInstance().getSettings().getXMLCanonical();
  		
  		ObjectIds           =  EParapherManager.getInstance().getSettings().getXMLObjectID();
  		
  		dtdVerification     = EParapherManager.getInstance().getSettings().isXMLDTDValidation();
 	}
 
 	public boolean isDetached() {
 		return detached;
 	}
 
 	public void setDetached() {
 		this.detached   = true;
 		this.enveloped  = false;
 		this.enveloping = false;
 	}
 
 	public boolean isEnveloped() {
 		return enveloped;
 	}
 
 	public void setEnveloped() {
 		this.detached   = false;
 		this.enveloped  = true;
 		this.enveloping = false;
 	}
 
 	public boolean isEnveloping() {
 		return enveloping;
 	}
 
 	public void setEnveloping() {
 		this.detached   = false;
 		this.enveloped  = false;
 		this.enveloping = true;
 	}
 
 	public String getDigestAlg() {
 		return digestAlg;
 	}
 
 	public void setDigestAlg(String digestAlg) {
 		this.digestAlg = digestAlg;
 	}
 
 	public String getTransform() {
 		return transform;
 	}
 
 	public void setTransform(String transform) {
 		this.transform = transform;
 	}
 
 	public String getCanonical() {
 		return canonical;
 	}
 
 	public void setCanonical(String canonical) {
 		this.canonical = canonical;
 	}
 
 	public String getObjectIds() {
 		return ObjectIds;
 	}
 
 	public void setObjectIds(String objectIds) {
 		ObjectIds = objectIds;
 	}
 
 	public int getTransformAsInt() {
 		return StringUtils.getPositionFromFamilies(transform,XMLTransformFamilies);
 	}
 
 	public int getCanonicalAsInt() {
 		return StringUtils.getPositionFromFamilies(canonical,XMLCanonicalFamilies);
 	}
 
 	public int getDigestAlgAsInt() {
 		return StringUtils.getPositionFromFamilies(digestAlg,XMLHashAlgFamilies);
 	}
 
 	public int getSignatureAlgAsInt() {
 		return StringUtils.getPositionFromFamilies(this.signatureAlg,XMLSigAlgFamilies);
 	}
 	
 	public void setFormat(int format) {
 		//int key = eParapherTools.getPositionFromFamilies(format,XMLSigFormatFamilies);
 		switch (format) {
 		case 0:
 			this.setDetached();
 			break;
 		case 1:
 			this.setEnveloped();
 			break;
 		case 2:
 			this.setEnveloping();
 			break;
 		default:
 			this.setEnveloped();
 			break;
 		}
 	}
 	
 	public int getFormatAsInt() {
 		if (detached)
 			return 0;
 		if (enveloped)
 			return 1;
 		if (enveloping)
 			return 2;
 
 		//log.warn("Could not define Default XML DSig Format!");
 		
 		return 1;
 	}
 
 	public String getSignatureAlg() {
 		return signatureAlg;
 	}
 
 	public void setSignatureAlg(String signatureAlg) {
 		this.signatureAlg = signatureAlg;
 	}
 
 	public boolean isOverwritesignedfile() {
 		return overwritesignedfile;
 	}
 
 	public void setOverwritesignedfile(boolean overwritesignedfile) {
 		this.overwritesignedfile = overwritesignedfile;
 	}
 
 	public void setDTDValidation(boolean dtdvalidation) {
 		dtdVerification = dtdvalidation;
 	}
 
 	public boolean isDTDValidation() {
 		return dtdVerification;
 	}
 
 }