package es.caib.signatura.impl;
   
   import java.io.ByteArrayOutputStream;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.Serializable;
   import java.lang.reflect.Method;
   import java.security.cert.X509Certificate;
  import java.util.Date;
  
  import es.caib.signatura.api.ParsedCertificate;
  import es.caib.signatura.api.Signature;
  import es.caib.signatura.api.SignatureDataException;
  import es.caib.signatura.api.SignatureProviderException;
  import es.caib.signatura.api.SignatureTimestampException;
  import es.caib.signatura.api.SignatureVerifyException;
  import es.caib.signatura.api.Signer;
  import es.caib.signatura.impl.ClassLoaderFactory;
  import es.caib.signatura.impl.SignatureProviderInterface;
  
  /**
   * Implementación de la interfaz <code>SignatureData</code> para usar con la
   * entidad certificadora Tradisea
   * 
   * @author Jesús Reyes (3dígits)
   * @version 0.98
   * @see Signer
   * @see Signature
   * 
   */
  public class WebSignature implements Signature, Serializable {
  
  	protected byte[] signatureBytes = null; // array de bytes con la firma
  
  	private String contentType = null;
  
  	private static final long serialVersionUID = 1;
  
  	private transient SignatureProviderInterface impl = null;
  
  	private static final int INTERNET_EXPLORER = 1;
  	private static final int MOZILLA_FIREFOX = 2;
  	private int origin;
  
  	/**
  	 * Crea un objeto firma a partir de una firma web La firma web consta de
  	 * <Identificador del software>:<Tipo Mime>:<Firma BASE64>
  	 * 
  	 * El identificador del software puede ser FF o IE
  	 * 
  	 * @param firma
  	 *            Firma codificada
  	 * @throws IOException
  	 * 
  	 */
  	public WebSignature(String firma) throws SignatureDataException {
  		if (firma.startsWith("FF:"))
  			origin = MOZILLA_FIREFOX;
  		else if (firma.startsWith("IE:"))
  			origin = INTERNET_EXPLORER;
  		else
  			throw new SignatureDataException();
  
  		int len = firma.indexOf(":", 3);
  
  		try {
  			Class base64Class = ClassLoaderFactory.getFactory()
  					.getMasterClassLoader().loadClass(
  							"org.bouncycastle.util.encoders.Base64");
  			Method m = base64Class.getMethod("decode",
  					new Class[] { String.class });
  			signatureBytes = (byte[]) m.invoke(null, new Object[] { firma
  					.substring(len + 1) });
  			contentType = firma.substring(3, len);
  			init();
  		} catch (Exception e) {
  			throw new SignatureDataException(e);
  		}
  	}
  
  	public void setContentType(String contentType) {
  		this.contentType = contentType;
  	}
  
  	public void setPkcs7(byte pkcs7[]) {
  		signatureBytes = pkcs7;
  	}
  
  	private void init() throws IOException {
  		if (impl == null) {
  			try {
  				ClassLoader cl = ClassLoaderFactory.getFactory()
  						.getMasterClassLoader();
  				Class clazz = cl.loadClass(getInternalClassName());
  				impl = (SignatureProviderInterface) clazz.newInstance();
  			} catch (InstantiationException e) {
  				throw new RuntimeException(e);
  			} catch (IllegalAccessException e) {
 				throw new RuntimeException(e);
 			} catch (ClassNotFoundException e) {
 				throw new RuntimeException(e);
 			}
 		}
 		try {
 			impl.setContentType(contentType);
 			impl.setSignedData(signatureBytes);
 		} catch (Exception e) {
 			throw new IOException("Unable to parse signature");
 		}
 	}
 
 	/**
 	 * @return
 	 */
 	protected String getInternalClassName() {
 		if (origin == INTERNET_EXPLORER)
 			return "es.caib.signatura.provider.impl.common.CapicomSignatureImpl";
 		else if (origin == MOZILLA_FIREFOX)
 			return "es.caib.signatura.provider.impl.common.CMSSignatureImplv2";
 		else
 			throw new RuntimeException("Signature type unknown " + origin);
 	}
 
 	/**
 	 * Obtiene el nombre de la entidad certificadora usada en la firma
 	 * 
 	 * @return nombre de la entidad certificadora
 	 */
 	public String getCertCaName() {
 		return impl.getCertCaName();
 	}
 
 	/**
 	 * Obtiene el nombre del certificado usado en la firma
 	 * 
 	 * @return nombre del certificado (CommonName)
 	 */
 	public String getCertSubjectCommonName() {
 		return impl.getCertSubjectCommonName();
 	}
 
 	public String getCertSubjectAlternativeNames() {
 		return impl.getCertSubjectAlternativeNames();
 	}
 
 	public byte[] getPkcs7() {
 		return this.signatureBytes;
 	}
 
 	// Sobreescribimos el método readObject que deserializa el objeto para
 	// llamar posteriormente al método privado de inicialización del objetco
 	// cuyo cometido es extraer el certificado de usuario de la firma
 	private void readObject(java.io.ObjectInputStream in) throws IOException,
 			ClassNotFoundException {
 		in.defaultReadObject();
 		init();
 	}
 
 	public Date getDate() throws SignatureTimestampException {
 		return impl.getDate();
 	}
 
 	public boolean verify() throws SignatureVerifyException {
 		return impl.verify();
 	}
 
 	public String getContentType() {
 		return contentType;
 	}
 
 	public X509Certificate getCert() {
 		return impl.getCert();
 	}
 
 	public X509Certificate[] getCertificateChain() throws Exception {
 		return impl.getCertificateChain();
 	}
 
 	public ParsedCertificate getParsedCertificate() {
 		return impl.getParsedCertificate();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see es.caib.signatura.api.Signature#verify(java.io.InputStream)
 	 */
 
 	public boolean verify(InputStream contentStream)
 			throws SignatureProviderException, IOException,
 			SignatureVerifyException {
 		boolean isVerified = true;
 		try {
 			// verificación interna de la firma
 			isVerified = isVerified && impl.verify(contentStream);
 			// isVerified = isVerified && verifyWS();
 		} catch (SignatureVerifyException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new SignatureVerifyException(e);
 		}
 		return isVerified;
 	}
 
 	public boolean verifyAPosterioriTimestamp(InputStream contentStream)
 			throws SignatureProviderException, IOException,
 			SignatureVerifyException {
 		boolean isVerified = true;
 		try {
 			// verificación interna de la firma
 			isVerified = isVerified
 					&& impl.verifyAPosterioriTimestamp(contentStream);
 			// *
 			// * Se actualiza la firma por si el validador ha añadido
 			// * un sello de tiempo
 
 			if (isVerified) {
 				this.setPkcs7(impl.getPkcs7());
 			}
 
 		} catch (SignatureVerifyException e) {
 			throw e;
 		} catch (Exception e) {
 			throw new SignatureVerifyException(e);
 		}
 		return isVerified;
 	}
 	/*
 	 * private boolean WSResponseIsAVerifiedMessage(String result) throws
 	 * SignatureVerifyException { String content = new String(); try {
 	 * DocumentBuilderFactory documentBuilderFactory =
 	 * DocumentBuilderFactory.newInstance(); DocumentBuilder documentBuilder =
 	 * documentBuilderFactory.newDocumentBuilder(); Document document;
 	 * StringBufferInputStream inputStream = new
 	 * StringBufferInputStream(result); document =
 	 * documentBuilder.parse((InputStream)inputStream); //Element element =
 	 * document.getDocumentElement(); try{ NodeList nodeList =
 	 * document.getElementsByTagName("valido"); Node node = nodeList.item(0);
 	 * Element element = (Element) node; String tagName = element.getTagName();
 	 * Node textData = null; boolean stop = false; NodeList nodeDataList =
 	 * element.getChildNodes(); for(int i = 0;i < nodeDataList.getLength() &&
 	 * !stop;i++){ textData = nodeDataList.item(i); stop =
 	 * textData.getNodeType() == org.w3c.dom.Node.TEXT_NODE; } content =
 	 * ((org.w3c.dom.Text)textData).getData(); }catch(Exception e){ //* Para no
 	 * llevar a malos entendidos // * se da la firma como falsa // * return
 	 * false; } if(content == null){ throw new Exception("No content in 'valido'
 	 * TAG. Response message: " + result); } }catch(Exception e){ throw new
 	 * SignatureVerifyException(e); } return content.compareToIgnoreCase("true") ==
 	 * 0; }
 	 */
 }