package com.ejie.ad74a.ws.client.dokusi.service;

import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.rmi.UnmarshalException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.bea.xml.XmlException;
import com.bea.xml.XmlOptions;
import com.ejie.ad74a.exceptions.ManagerErrors;
import com.ejie.ad74a.jms.util.MessageParser;
import com.ejie.ad74a.model.DocumentosTarea;
import com.ejie.ad74a.model.Expedientes;
import com.ejie.ad74a.util.comun.Utilidades;
import com.ejie.ad74a.util.comun.UtilidadesXML;
import com.ejie.ad74a.utilProperties.config.Config;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BAttributeListType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BAttributeType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BContentType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BDocumentIDType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BDocumentType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BFormatListType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BFormatType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BSignatureInfoListType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BSignatureInfoType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BSignatureListType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BSignatureType;
import com.ejie.ad74a.ws.client.dokusi.model.documentT65B.T65BStringListType;
import com.ejie.ad74a.ws.client.dokusi.model.papel0.Formato;
import com.ejie.ad74a.ws.client.dokusi.model.papel0.Metadato;
import com.ejie.dossierDokusi.xml.Root;
import com.ejie.t65.jaxb.beans.fsd.ConditionListDocument;
import com.ejie.t65.jaxb.beans.fsd.ContentDocument;
import com.ejie.t65.jaxb.beans.fsd.ContentListDocument;
import com.ejie.t65.jaxb.beans.fsd.DocumentDocument;
import com.ejie.t65.jaxb.beans.fsd.DocumentIDDocument;
import com.ejie.t65.jaxb.beans.fsd.DocumentIDListDocument;
import com.ejie.t65.jaxb.beans.fsd.DocumentListDocument;
import com.ejie.t65.jaxb.beans.fsd.FormatListDocument;
import com.ejie.t65.jaxb.beans.fsd.StringListDocument;
import com.ejie.t65.jaxb.beans.fsd.StringListListDocument;
import com.ejie.t65.jaxb.beans.fsd.T65AttributeListListType;
import com.ejie.t65.jaxb.beans.fsd.T65AttributeListType;
import com.ejie.t65.jaxb.beans.fsd.T65AttributeType;
import com.ejie.t65.jaxb.beans.fsd.T65ConditionListType;
import com.ejie.t65.jaxb.beans.fsd.T65ContentListType;
import com.ejie.t65.jaxb.beans.fsd.T65ContentType;
import com.ejie.t65.jaxb.beans.fsd.T65DocumentIDListType;
import com.ejie.t65.jaxb.beans.fsd.T65DocumentIDType;
import com.ejie.t65.jaxb.beans.fsd.T65DocumentListType;
import com.ejie.t65.jaxb.beans.fsd.T65DocumentType;
import com.ejie.t65.jaxb.beans.fsd.T65FormatListType;
import com.ejie.t65.jaxb.beans.fsd.T65FormatType;
import com.ejie.t65.jaxb.beans.fsd.T65StringListListType;
import com.ejie.t65.jaxb.beans.fsd.T65StringListType;

/**
 * Clase parseadora Dokusi DokusiXMLBeanParserConverter
 * 
 * @author
 * 
 */
public class DokusiXMLBeanParserConverter {

	private static final Logger logger = LoggerFactory.getLogger(DokusiXMLBeanParserConverter.class);

	// Namespace esperado por los xmlbeans de dokusi (T65BXmlBeans.jar).
	private static final String NAMESPACE_DOKUSI_XMLBEANS = "com/ejie/t65/jaxb/beans/fsd";

	// Metadatos genericos
	public static final String META_NOMBRE = "object_name";
	public static final String META_TITULO = "title";
	public static final String META_ASUNTO = "subject";
	public static final String META_ACL = "acl_name";
	public static final String META_PROPIETARIO = "owner_name";
	public static final String META_AUTOR = "authors";
	public static final String META_PROCEDIMIENTO = "ejgv_procedimiento";
	public static final String META_SERIE = "ejgv_serie";
	public static final String META_EXPEDIENTE = "ejgv_expediente";
	public static final String META_ID_FIRMANTE = "ejgv_id_firmantes";
	public static final String META_NOMBRE_FIRMANTE = "ejgv_nom_firmantes";
	public static final String META_ORIGEN = "ejgv_origen";
	public static final String META_ORIGEN_CIUDADANIA = "CIUDADANIA";
	public static final String META_ORIGEN_ADMINISTRACION = "ADMINISTRACION";
	public static final String META_ORIGEN_ORG_EXT = "ORGANISMO_EXTERNO";
	public static final String META_NATURALEZA = "ejgv_naturaleza";
	public static final String META_NATURALEZA_ELECTRONICO = "ELECTRONICO";

	/**
	 * Constructor
	 */
	private DokusiXMLBeanParserConverter() {
		super();
	}

	/**
	 * parseToStringContent
	 * 
	 * @param content T65ContentType
	 * @return retorno String
	 */
	public static String parseToStringContent(T65ContentType content) {

		ContentDocument docContent = ContentDocument.Factory.newInstance();
		if (content != null) {
			docContent.setContent(content);
			return docContent.xmlText(DokusiXMLBeanParserConverter.createXMLOptions());
		} else {
			return "";
		}
	}

	/**
	 * parseToStringContentList
	 * 
	 * @param contents T65ContentType
	 * @return retorno String
	 */
	public static String parseToStringContentList(T65ContentListType contents) {

		ContentListDocument docContentList = ContentListDocument.Factory.newInstance();
		if (contents != null) {
			docContentList.setContentList(contents);
			return docContentList.xmlText(DokusiXMLBeanParserConverter.createXMLOptions());
		} else {
			return "";
		}
	}

	/**
	 * createXMLOptions
	 * 
	 * @return retorno XmlOptions
	 */
	private static XmlOptions createXMLOptions() {
		XmlOptions xmlOptions = new XmlOptions();
		xmlOptions.setSavePrettyPrint();
		xmlOptions.setSavePrettyPrintIndent(4);
		return xmlOptions;
	}

	public static String parseToStringDocumentIDList(String[] oid) {
		DocumentIDListDocument result = DocumentIDListDocument.Factory.newInstance();
		T65DocumentIDListType documenIDListType = result.addNewDocumentIDList();
		for (String id : oid) {
			T65DocumentIDType tipoDocumentID = documenIDListType.addNewDocumentID();
			tipoDocumentID.setId(id);
		}

		return result.xmlText();
	}

	/**
	 * parseToStringDocumentID
	 * 
	 * @param oid String
	 * @return retorno String
	 */
	public static String parseToStringDocumentID(String oid) {
		DocumentIDDocument docDocumentID = DocumentIDDocument.Factory.newInstance();
		T65DocumentIDType tipoDocumentID = T65DocumentIDType.Factory.newInstance();
		tipoDocumentID.setId(oid);
		// tipoDocumentID.setVersion("1.0");
		docDocumentID.setDocumentID(tipoDocumentID);
		return docDocumentID.xmlText();
	}

	public static String generateT65BKeysForMuchDocs(int howMuch, String[] attributes) {
		StringListListDocument stringListDoc = StringListListDocument.Factory.newInstance();
		T65StringListListType stringsDoc = stringListDoc.addNewStringListList();

		for (int i = 0; i < howMuch; i++) {
			T65StringListType strings = stringsDoc.addNewStringList();
			for (int j = 0; j < attributes.length; j++) {
				strings.addElement(attributes[j]);
			}
		}
		return stringListDoc.xmlText();
	}

	public static T65DocumentListType parseToT65BDocumentList(String strXMLBean) {
		try {
			DocumentListDocument docDocumentList = DocumentListDocument.Factory.parse(strXMLBean, opcionesParseo());
			return docDocumentList.getDocumentList();
		} catch (XmlException e) {
			DokusiXMLBeanParserConverter.logger.error("Excepcion en parseToT65BDocumentList", e);
			return null;
		}
	}

	public static T65DocumentType parseToT65BDocument(String strXMLBean) {
		try {
			DocumentDocument docDocument = DocumentDocument.Factory.parse(strXMLBean, opcionesParseo());
			return docDocument.getDocument();
		} catch (XmlException e) {
			DokusiXMLBeanParserConverter.logger.error("Excepcion en parseToT65BDocument", e);
			return null;
		}
	}

	/**
	 * Obtiene las opciones de parseo xml: Al actualizar jar T65BXmlBeans, ha
	 * cambiado namespace (antes no tenia namespace). El webservice Dokusi devuelve
	 * namespace vacio, pero los xmlbeans esperan un namespace no vacio por lo que
	 * dan error. Se parseará con estas opciones, reemplazando el namespace vacio,
	 * por el esperado en el "T65BXmlBeans.jar", para que así no haya error al
	 * parsear. El namespace esperado por los xmlbeans está definido en
	 * "NAMESPACE_DOKUSI_XMLBEANS".
	 * 
	 * @return XmlOptions
	 */
	public static XmlOptions opcionesParseo() {
		HashMap<String, String> map = new HashMap<String, String>();
		map.put("", NAMESPACE_DOKUSI_XMLBEANS);
		XmlOptions ret = new XmlOptions();
		ret.setLoadSubstituteNamespaces(map);
		return ret;
	}

	public static String crearXMLdocumentID(String oidDokusi) {

		T65DocumentIDListType t65BDocumentIDListType = T65DocumentIDListType.Factory.newInstance();
		T65DocumentIDType t65BDocumentIDType = t65BDocumentIDListType.addNewDocumentID();
		t65BDocumentIDType.setId(oidDokusi);

		return t65BDocumentIDListType.xmlText();
	}

	/**
	 * Transforma un xml resultado de la llamada al metodo de recuperar formatos de
	 * un documento en dokusi en un objeto Documento de nuestro modelo de negocio.
	 * 
	 * @param xml xml de respuesta eliminar
	 * @return Formato Formato
	 * 
	 * @throws XmlException XmlException
	 */
	public static Formato transformRecuperarFormatosDocumentosDokusi(String xml) throws XmlException {

		Map<String, String> namespaceMap = new HashMap<>();
		namespaceMap.put("", "com/ejie/t65/jaxb/beans/fsd");
		XmlOptions opts = new XmlOptions();
		opts.setLoadSubstituteNamespaces(namespaceMap);

		FormatListDocument formatListDocument = FormatListDocument.Factory.parse(xml, opts);
		T65FormatListType t65BFormatListType = formatListDocument.getFormatList();

		Formato formato = new Formato();

		if (t65BFormatListType != null && t65BFormatListType.getFormatArray().length > 0) {
			for (T65FormatType t65BFormatType : t65BFormatListType.getFormatArray()) {
				formato = new Formato();

				formato.setDescription(t65BFormatType.getDescription());
				formato.setExtension(t65BFormatType.getExtension());
				formato.setMimeType(t65BFormatType.getMimeType());
				formato.setName(t65BFormatType.getName());
				formato.setFullText(t65BFormatType.getFullText());
			}
		}

		return formato;
	}

	/**
	 * Método que crea el xml AttributeList
	 * 
	 * @param documento Documento
	 * 
	 * @return xmlAttributeList String
	 * @throws Exception Exception
	 */
	public static String crearXMLAttributeListRetramitar(
			com.ejie.ad74a.ws.client.dokusi.model.papel0.Documento documento) throws Exception {

		T65AttributeListListType t65BAttributeListListType = T65AttributeListListType.Factory.newInstance();

		T65AttributeListType listaAtributos = t65BAttributeListListType.addNewAttributeList();

		List<Metadato> metadatos = documento.getMetadatos();

		// Añadimos los metadatos al documento
		if (metadatos != null && metadatos.size() > 0) {
			for (Metadato metadato : metadatos) {
				T65AttributeType atributo = listaAtributos.addNewAttribute();

				atributo.setKey(metadato.getNombre());
				atributo.setValue(metadato.getValor());
			}
		}

		Properties prop = Config.loadProperties(com.ejie.ad74a.constantes.Constantes.CONFIG_PATH);
		T65AttributeType atributo = listaAtributos.addNewAttribute();
		atributo.setKey("ejgv_serie");
		atributo.setValue(prop.getProperty("documentum.serie.documental"));

		atributo = listaAtributos.addNewAttribute();
		atributo.setKey("acl_name");
		atributo.setValue(prop.getProperty("documentum.acl"));

		atributo = listaAtributos.addNewAttribute();
		atributo.setKey("ejgv_proc_infraestructura");
		atributo.setValue(documento.getProcedureID());

		atributo = listaAtributos.addNewAttribute();
		atributo.setKey("ejgv_procedimiento");
		atributo.setValue(prop.getProperty("documentum.procedimiento.documental"));

		atributo = listaAtributos.addNewAttribute();
		atributo.setKey("ejgv_expediente");
		atributo.setValue("TL_2023_000027");

		return UtilidadesXML.quitarNameSpacesString(t65BAttributeListListType);
	}

	/**
	 * Método que crea el xml ReturnedAttributeKeysList
	 * 
	 * @param metadatos List<Metadato>
	 * 
	 * @return xmlReturnedAttributeKeysList String
	 * @throws Exception Exception
	 */
	public static String crearXMLReturnedAttributeKeysList(List<Metadato> metadatos) throws Exception {
		StringListDocument listaAtributos = StringListDocument.Factory.newInstance();

		T65StringListType t65BStringListType = listaAtributos.addNewStringList();

		// Añadimos los metadatos al documento
		if (metadatos != null && metadatos.size() > 0) {
			for (Metadato metadato : metadatos) {

				t65BStringListType.addElement(metadato.getNombre());
			}
		}
		return UtilidadesXML.quitarNameSpacesString(listaAtributos);
	}

	/**
	 * M�todo que crea el xml content
	 * 
	 * @param name  del documento
	 * @param pifId pif
	 * @return saveTask String
	 */
	public static String crearXMLContentName(final String name, final String pifId) {
		T65ContentListType t65BContentListType = T65ContentListType.Factory.newInstance();
		T65ContentType t65BContentType = t65BContentListType.addNewContent();
		t65BContentType.addNewFormat().setName(name);

		t65BContentType.setPifId(pifId);
		return t65BContentListType.xmlText();
	}

	/**
	 * Transforma un xml resultado de la llamada al metodo de descargar documento de
	 * dokusi en un objeto Documento de nuestro modelo de negocio.
	 * 
	 * @param xml ListaIdsDocumentosDocumentum
	 * @return Documento documento
	 * 
	 * @throws XmlException XmlException
	 */
	public static com.ejie.ad74a.ws.client.dokusi.model.papel0.Documento transformDescargarDocumentoDokusi(String xml)
			throws XmlException {

		HashMap namespaceMap = new HashMap();
		namespaceMap.put("", "com/ejie/t65/jaxb/beans/fsd");
		XmlOptions opts = new XmlOptions();
		opts.setLoadSubstituteNamespaces(namespaceMap);

		DocumentDocument documentDocument = DocumentDocument.Factory.parse(xml, opts);
		T65DocumentType t65BDocumentType = documentDocument.getDocument();

		com.ejie.ad74a.ws.client.dokusi.model.papel0.Documento documento = new com.ejie.ad74a.ws.client.dokusi.model.papel0.Documento();

		documento.setPifId(t65BDocumentType.getContent().getPifId());

		documento.setExtension(t65BDocumentType.getContent().getFormat().getExtension());

		documento.setContentType(t65BDocumentType.getContent().getFormat().getMimeType());
		documento.setLength(t65BDocumentType.getContent().getLenght());

		StringBuffer nombreCompleto = new StringBuffer();

		T65AttributeListType t65BAttributeListType = t65BDocumentType.getAttributeList();
		List<Metadato> metadatos = new ArrayList<Metadato>();
		if (t65BAttributeListType != null && t65BAttributeListType.getAttributeArray().length > 0) {
			for (T65AttributeType t65BAttributeType : t65BAttributeListType.getAttributeArray()) {
				Metadato metadato = new Metadato();

				metadato.setNombre(t65BAttributeType.getKey());
				metadato.setValor(t65BAttributeType.getValue());

				if (t65BAttributeType.getKey() != null && t65BAttributeType.getKey().equals("object_name")) {
					nombreCompleto.append(t65BAttributeType.getValue());
				}
				metadatos.add(metadato);
			}
		}
		documento.setMetadatos(metadatos);
		nombreCompleto.append(".").append(documento.getExtension());
		documento.setNombre(nombreCompleto.toString());
		return documento;
	}

	public static T65DocumentType transformToDocumentType(String xml) throws XmlException {

		HashMap namespaceMap = new HashMap();
		namespaceMap.put("", "com/ejie/t65/jaxb/beans/fsd");
		XmlOptions opts = new XmlOptions();
		opts.setLoadSubstituteNamespaces(namespaceMap);

		DocumentDocument documentDocument = DocumentDocument.Factory.parse(xml, opts);
		T65DocumentType t65BDocumentType = documentDocument.getDocument();

		return t65BDocumentType;
	}

	public static T65BDocumentIDType construirT65BDocumentIDType(String id, String version) {
		T65BDocumentIDType obj = new T65BDocumentIDType();
		obj.setId(id);
		obj.setVersion(version);
		return obj;
	}

	/**
	 * A partir de un T65BDocumentIDType, devuelve su representaciÃ³n XML en un
	 * String
	 * 
	 * @param t65bDocumentIDType objeto de tipo T65BDocumentIDType
	 * @return String e
	 */
	public static String getT65BDocumentIDTypeAsString(T65BDocumentIDType t65bDocumentIDType) {
		String resultado = null;
		try {
			resultado = UtilidadesXML.marshalObjectWS(t65bDocumentIDType);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto t65bDocumentIDType", e);
		}
		return resultado;
	}

	/**
	 * A partir de un T65BStringListType, devuelve su representaciÃ³n XML en un
	 * String
	 * 
	 * @param t65bStringListType objeto de tipo T65BStringListType
	 * @return String e
	 */
	public static String getT65BStringListTypeAsString(T65BStringListType t65bStringListType) {
		String resultado = null;
		try {
			resultado = UtilidadesXML.marshalObjectWS(t65bStringListType);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto t65bStringListType", e);
		}
		return resultado;
	}

	/**
	 * Devuelve un objeto T65BDocumentIDType a partir de su representaciÃ³n XML en
	 * String.
	 * 
	 * response String T65BDocumentType
	 * 
	 * @param response the response
	 * @return the dokusi response as T 65 B format list type
	 * @throws Exception expcepciÃ³n al parsear la respuesta de Dokusi
	 */
	public static T65BFormatListType getDokusiResponseAsT65BFormatListType(String response) throws Exception {

		DokusiXMLBeanParserConverter.logger.info("getDokusiResponseAsT65BFormatListType");

		T65BFormatListType obj = null;
		try {
			obj = (T65BFormatListType) new MessageParser<T65BFormatListType>(
					T65BFormatListType.class.getPackage().getName()).parse(response);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto response como T65BFormatListType",
					e);
			ManagerErrors.manageException(e,
					" LOG NEGOCIO: getDokusiResponseAsT65BFormatListType --> Error en el parseo del objeto response como T65BFormatListType");

		}

		return obj;
	}

	/**
	 * A partir de un T65BContentType, devuelve su representaciÃ³n XML en un String
	 * 
	 * @param t65bContentType objeto de tipo T65BContentType
	 * @return String e
	 */
	public static String getT65BContentTypeAsString(T65BContentType t65bContentType) {
		String resultado = null;
		try {
			resultado = UtilidadesXML.marshalObjectWS(t65bContentType);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto t65bContentType", e);
		}
		return resultado;
	}

	/**
	 * Devuelve un objeto T65BDocumentIDType a partir de su representaciÃ³n XML en
	 * String.
	 * 
	 * response String T65BDocumentType
	 * 
	 * @param response the response
	 * @return the dokusi response as T 65 B document type
	 * @throws Exception expcepciÃ³n al parsear la respuesta de Dokusi
	 */
	public static T65BDocumentType getDokusiResponseAsT65BDocumentType(String response) throws Exception {

		DokusiXMLBeanParserConverter.logger.info("getDokusiResponseAsT65BDocumentType");

		T65BDocumentType obj = null;
		try {
			obj = (T65BDocumentType) new MessageParser<T65BDocumentType>(
					T65BDocumentIDType.class.getPackage().getName()).parse(response);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto response como T65BDocumentType",
					e);
			ManagerErrors.manageException(e,
					"getDokusiResponseAsT65BDocumentType --> Error en el parseo del objeto response como T65BDocumentType");
		}

		return obj;
	}

	/**
	 * A partir de un T65BSignatureListType, devuelve su representaciÃ³n XML en un
	 * String
	 * 
	 * @param t65bSignatureListType objeto de tipo T65BSignatureListType
	 * @return String e
	 */
	public static String getT65BSignatureListTypeAsString(T65BSignatureListType t65bSignatureListType) {
		String resultado = null;
		try {
			resultado = UtilidadesXML.marshalObjectWS(t65bSignatureListType);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto t65bSignatureListType", e);
		}
		return resultado;
	}

	/**
	 * A partir de un T65BAttributeListType, devuelve su representaciÃ³n XML en un
	 * String
	 * 
	 * @param t65bAttributeListType objeto de tipo T65BAttributeListType
	 * @return String e
	 */
	public static String getT65BAttributeListTypeAsString(T65BAttributeListType t65bAttributeListType) {
		String resultado = null;
		try {
			resultado = UtilidadesXML.marshalObjectWS(t65bAttributeListType);
		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto t65bAttributeListType", e);
		}
		return resultado;
	}

	/**
	 * Crea un objeto T65BSignatureInfoType a partir de sus atributos
	 * 
	 * @param department     String
	 * @param entity         String
	 * @param responsability String
	 * @param signerID       String
	 * @param signerName     String
	 * @return T65BSignatureInfoType
	 */
	public static T65BSignatureInfoType construirT65BSignatureInfoType(String department, String entity,
			String responsability, String signerID, String signerName) {
		T65BSignatureInfoType obj = new T65BSignatureInfoType();
		obj.setDepartment(department);
		obj.setEntity(entity);
		obj.setResponsability(responsability);
		obj.setSignerID(signerID);
		obj.setSignerName(signerName);
		return obj;
	}

	/**
	 * Crea un objeto T65BSignatureType a partir de sus atributos
	 * 
	 * @param signedDocumentId      T65BDocumentIDType
	 * @param signature             String
	 * @param signatureInfo         T65BSignatureType
	 * @param date                  String
	 * @param type                  String
	 * @param isConservable         String ejgv_cons_firma_longevo
	 * @param documentIsRequiered   String ejgv_req_doc_firma_longevo
	 * @param signatureType         String
	 * @param signatureFormat       String
	 * @param signatureProfile      String
	 * @param timestampSerialNumber String
	 * @param format                T65BFormatType
	 * @return T65BSignatureType
	 */
	public static T65BSignatureType construirT65BSignatureType(T65BSignatureInfoType signatureInfo, String date,
			String type, String isConservable, String documentIsRequiered, String signatureType, String signatureFormat,
			String signatureProfile, String timestampSerialNumber, T65BFormatType format) {
		T65BSignatureType obj = new T65BSignatureType();

		T65BSignatureInfoListType t65bSignatureInfoListType = new T65BSignatureInfoListType();
		t65bSignatureInfoListType.getSignatureInfo().add(signatureInfo);
		obj.setSignatureInfoList(t65bSignatureInfoListType);

		obj.setFormat(format);
		obj.setType(type);

		obj.setDate(date);
		obj.setIsConservable(isConservable);
		obj.setDocumentIsRequiered(documentIsRequiered);
		obj.setSignatureType(signatureType);
		obj.setSignatureFormat(signatureFormat);
		obj.setSignatureProfile(signatureProfile);
		obj.setTimestampSerialNumber(timestampSerialNumber);

		return obj;

	}

	/**
	 * Crea un objeto T65BContentType a partir de sus atributos
	 * 
	 * @param doc ExpDocTramite
	 * @return T65BContentType
	 */
	public static T65BContentType construirT65BContentType(DocumentosTarea doc) {
		T65BContentType obj = new T65BContentType();
		obj.setContent(null);
		obj.setDocLocation(null);
		obj.setFormat(construirT65BFormatType(doc));
		obj.setLenght(null);
		obj.setPifId(doc.getRutapif18());
		return obj;
	}

	/**
	 * Crea un objeto T65BFormatType a partir de sus atributos
	 * 
	 * @param doc ExpDocTramite
	 * @return T65BFormatType
	 */
	public static T65BFormatType construirT65BFormatType(DocumentosTarea doc) {
		T65BFormatType obj = new T65BFormatType();
		obj.setDescription(null);

		// Cogemos ruta pif porque el fichero original puede ser .rtf pero en
		// pif puede ser un .doc
		obj.setExtension(obtenerExtensionFichero(doc.getRutapif18()));
		obj.setFullText(null);

		// obj.setName(doc.getNombreDoc18());

		return obj;
	}

	/**
	 * Devuelve la extensiÃ³n de un nombre de fichero buscando a partir del Ãºltimo
	 * carÃ¡cter punto "."
	 * 
	 * @param nombreFichero String
	 * @return String
	 */
	public static String obtenerExtensionFichero(String nombreFichero) {
		if (!Utilidades.esBlancoNulo(nombreFichero)) {
			int index = nombreFichero.lastIndexOf(".");
			if (index != -1) {
				return nombreFichero.substring(index + 1);
			}
		}
		return "";
	}

	/**
	 * Genera la lista de metadatos bÃ¡sicos de un documento
	 * 
	 * @param doc ExpDocTramite
	 * @return T65BAttributeListType
	 */
	public static T65BAttributeListType generarMetadatosBasicos(DocumentosTarea doc, Expedientes expediente) {
		Map<String, String> metadatos = new HashMap<String, String>();

		Properties prop = Config.loadProperties(com.ejie.ad74a.constantes.Constantes.CONFIG_PATH);

		metadatos.put(META_NOMBRE, doc.getNombreDoc18());
		metadatos.put(META_TITULO, doc.getNombreDoc18());
		metadatos.put(META_SERIE, prop.getProperty("documentum.serie.documental"));
		metadatos.put(META_ORIGEN, "ADMINISTRACION");
		metadatos.put(META_ACL, prop.getProperty("documentum.acl"));
		metadatos.put(META_PROCEDIMIENTO, prop.getProperty("documentum.procedimiento.documental"));
		metadatos.put(META_NATURALEZA, "ELECTRONICO");
		if (expediente != null) {
			metadatos.put(META_EXPEDIENTE, expediente.getFolderId00());
		}

		return construirT65BAttributeListType(metadatos);
	}

	/**
	 * Genera la lista de metadatos bÃ¡sicos de un documento
	 * 
	 * @param doc ExpDocTramite
	 * @return T65BAttributeListType
	 */
	public static T65BAttributeListType generarMetadatosFirma(String idFirmante, String nombreFirmante) {
		Map<String, String> metadatos = new HashMap<String, String>();

		metadatos.put(META_ID_FIRMANTE, idFirmante);
		metadatos.put(META_NOMBRE_FIRMANTE, nombreFirmante);

		return construirT65BAttributeListType(metadatos);
	}

	public static T65BAttributeListType generarMetadatosBasicosReTramitate(String expediente) {
		Map<String, String> metadatos = new HashMap<String, String>();
		metadatos.put("ejgv_expediente", expediente);

		return construirT65BAttributeListType(metadatos);
	}

	/**
	 * Crea un objeto T65BAttributeListType a partir de un mapa de metadatos
	 * 
	 * @param metadatos Map<String, String>
	 * @return T65BAttributeListType
	 */
	public static T65BAttributeListType construirT65BAttributeListType(Map<String, String> metadatos) {
		T65BAttributeListType t65bAttributeListType = new T65BAttributeListType();
		if (metadatos != null) {
			Set<String> keys = metadatos.keySet();
			Iterator<String> iterator = keys.iterator();
			while (iterator.hasNext()) {
				String key = iterator.next();
				String value = metadatos.get(key);
				T65BAttributeType t65bAttributeType = construirT65BAttributeType(key, value);
				t65bAttributeListType.getAttribute().add(t65bAttributeType);
			}
		}
		return t65bAttributeListType;
	}

	/**
	 * Crea un objeto T65BAttributeType a partir de sus atributos
	 * 
	 * @param key   String
	 * @param value String
	 * @return T65BAttributeType
	 */
	public static T65BAttributeType construirT65BAttributeType(String key, String value) {
		T65BAttributeType obj = new T65BAttributeType();
		obj.setKey(key);
		obj.setValue(value);
		return obj;
	}

	/**
	 * Devuelve un objeto T65BDocumentIDType a partir de su representaciÃ³n XML en
	 * String
	 * 
	 * @param response       String
	 * @param logTramitacion LogTramitacion
	 * 
	 * @return T65BDocumentIDType
	 * 
	 * @throws AB37AParseException expcepciÃ³n al parsear la respuesta de Dokusi
	 */
	public static T65BDocumentIDType getDokusiResponseAsT65BDocumentIDType(String response) throws Exception {

		T65BDocumentIDType obj = null;
		try {

			obj = (T65BDocumentIDType) UtilidadesXML.unmarshallerObject(response, T65BDocumentIDType.class);

		} catch (Exception e) {
			DokusiXMLBeanParserConverter.logger.error("Error en el parseo del objeto response como T65BDocumentIDType",
					e);
			ManagerErrors.manageException(e,
					"getDokusiResponseAsT65BDocumentIDType --> Error en el parseo del objeto response como T65BDocumentIDType");
		}

		return obj;
	}

	/**
	 * parseToStringStringList
	 * 
	 * @param listaCadenas T65StringListType
	 * @return retorno String
	 */
	public static String parseToStringStringList(T65StringListType listaCadenas) {
		StringListDocument docStringList = StringListDocument.Factory.newInstance();
		docStringList.setStringList(listaCadenas);
		return docStringList.xmlText(DokusiXMLBeanParserConverter.createXMLOptions());
	}

	public static String parseToStringCondition(T65ConditionListType listaCadenas) {
		ConditionListDocument docConditionList = ConditionListDocument.Factory.newInstance();
		docConditionList.setConditionList(listaCadenas);
		String xmlStringList = docConditionList.xmlText(DokusiXMLBeanParserConverter.createXMLOptions());
		// p43bClsLog.debug("xmlStringList: "+xmlStringList);
		return xmlStringList;
	}

	public static Root unmarshallDossierDokusiPResponse(String xml) throws UnmarshalException {
		JAXBContext jaxbContext;
		try {
			xml = xml.replaceAll("<root>", "<root xmlns=\"com/ejie/dossierDokusi/xml\">");
			xml = xml.replaceAll("<object ", "<object xmlns=\"com/ejie/dossierDokusi/xml\" ");
			jaxbContext = JAXBContext.newInstance(Root.class);

			Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
			return (Root) jaxbUnmarshaller.unmarshal(new ByteArrayInputStream(xml.getBytes("UTF-8")));
		} catch (JAXBException e) {
			throw new UnmarshalException("Error de JAXB al traducir el XML", e);
		} catch (UnsupportedEncodingException e) {
			throw new UnmarshalException("Error de codificacion al leer el XML", e);
		}
	}
}