package com.ejie.ab39a.seguridad;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

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

import com.ejie.ab39a.constantes.Constantes;
import com.ejie.ab39a.model.Entidades;
import com.ejie.ab39a.model.TecnicosEntidad;
import com.ejie.ab39a.utils.FeaHelper;
import com.ejie.ab39a.utils.UtilProperties;
import com.ejie.x38.security.PerimetralSecurityWrapper;
import com.ejie.x38.security.UserCredentials;

/**
 * Clase que almacena todos los datos necesarios del usuario conectado.
 * 
 *  
 * 
 */
public class UsuarioConectado extends UserCredentials {

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

	private static final long serialVersionUID = 1L;

	private enum TIPO_CARGA_CERTIFICADO {
		TIPO_CARGA_CERTIFICADO_JB(1), TIPO_CARGA_CERTIFICADO_PERSONA_ENTIDAD(2);

		TIPO_CARGA_CERTIFICADO(int tipo) {
			this.tipocarga = tipo;
		}

		/**
		 * 
		 * @return int tipocarga
		 */
		public int getValue() {
			return this.tipocarga;
		}

		// public boolean isEqual(TIPO_CARGA_CERTIFICADO )

		private int tipocarga = 0;

	};

	// ROLES de la aplicación
	public static final String ROL_TECNICO_HPS_1 = "AB39A-IN-0001";
	public static final String ROL_TECNICO_HPS_2 = "AB39A-IN-0002";

	private TecnicosEntidad tecnicosEntidad;
	// private boolean tecnicoEntidad;
	// private boolean tecnicoHps;
	private boolean rellenarDatosIncompletos;
	// datos de la fea
	private FeaDatosUsuarioJuegoBarcos datosJuegoBarcos;

	private boolean primeraVez = true;

	/**
	 * Saber si se ha logeado con Juego de Barcos
	 */

	private boolean juegoBarcos = false;

	/**
	 * indica si el usuario ha podido ser validado
	 */
	private boolean esValidado = true;

	/**
	 * lista de entidades devuelta por el RdR
	 */
	private List<Entidades> listaEntidadesRdr = null;
	private List<Entidades> listaEntidadesNoCompletas = null;

	private boolean esCertificadoEntidad = false;
	private boolean esCertificadoRepresentante = false;
	private boolean esCertificadoPersonalPublico = false;
	private boolean esAccesoDirecto = false;
	private boolean esTecnicoHPS = false;

	private String cifEntidad = null;

	/**
	 * Indica si hay que verificar el usuario contra el RdR
	 */
	private boolean esVerificarRdr = false;

	/**
	 * Method 'getNombre'
	 * 
	 * @return the nombre
	 */
	public String getNombre() {
		return this.getName();
	}

	/**
	 * Method 'getApellidos'
	 * 
	 * @return the apellidos
	 */
	public String getApellidos() {
		return this.getSurname();
	}

	/**
	 * Method 'getApellido1'
	 * 
	 * @return String apellido1
	 */
	public String getApellido1() {
		String ape = null;

		if (this.juegoBarcos && this.datosJuegoBarcos != null
				&& this.datosJuegoBarcos.getDatosPersonaJuegoBarcos() != null) {
			ape = this.datosJuegoBarcos.getDatosPersonaJuegoBarcos().getPrimerApellido();
		}

		return ape;
	}

	/**
	 * Method 'getApellido2'
	 * 
	 * @return String apellido2
	 */
	public String getApellido2() {
		String ape = null;

		if (this.juegoBarcos && this.datosJuegoBarcos != null
				&& this.datosJuegoBarcos.getDatosPersonaJuegoBarcos() != null) {
			ape = this.datosJuegoBarcos.getDatosPersonaJuegoBarcos().getSegundoApellido();
		}

		return ape;
	}

	/**
	 * Method 'getRazonSocialCert'.
	 * 
	 * @return String razonSocial
	 */
	public String getRazonSocialCert() {
		String razon = null;
		if (this.getTieneCertificado()) {
			razon = this.getSubjectCert("CN");
		}
		return razon;
	}

	/**
	 * Method 'getPolitica'
	 * 
	 * @return the politica
	 */
	public String getPolitica() {
		return this.getPolicy();
	}

	/**
	 * Method 'getTieneCertificado'
	 * 
	 * @return the tieneCertificado
	 */
	public Boolean getTieneCertificado() {
		return this.getIsCertificate();
	}

	/***
	 * 
	 * 
	 * 
	 * JUEGO DE BARCOS
	 * 
	 * 
	 */

	/**
	 * Indica si el usuario se ha autenticado mediante juego de barcos
	 * 
	 * @return boolean true si juego de barcos
	 */
	public boolean isJuegoBarcos() {
		return this.juegoBarcos;

	}

	/**
	 * Indica si el usuario se ha autenticado mediante juego de barcos
	 * 
	 * @param juego
	 *            boolean indica si es juego de barcos
	 */
	public void setJuegoBarcos(boolean juego) {
		this.juegoBarcos = juego;
	}

	/**
	 * Devuelve los datos del juego de barcos
	 * 
	 * @return FeaDatosUsuarioJuegoBarcos datos del juego de barcos
	 */
	public FeaDatosUsuarioJuegoBarcos getDatosJuegoBarcos() {
		return this.datosJuegoBarcos;
	}

	/**
	 * Informa los datos del Juego de Barcos
	 * 
	 * @param datos
	 *            FeaDatosUsuarioJuegoBarcos datos del Juego de Barcos
	 */
	public void setDatosJuegoBarcos(FeaDatosUsuarioJuegoBarcos datos) {
		this.datosJuegoBarcos = datos;
	}

	/**
	 * 
	 * Devuelve el Numero de Referencia de la Tarjeta de Juego de Barcos
	 * 
	 * @return String numero referencia tarjeta juego barcos
	 */
	public String getNumeroReferenciaTarjetaJuegoBarcos() {
		String str = "";
		if (this.isJuegoBarcos() && this.getDatosJuegoBarcos() != null
				&& this.getDatosJuegoBarcos().getDatosTarjetaJuegoBarcos() != null) {

			str = this.getDatosJuegoBarcos().getDatosTarjetaJuegoBarcos().getNumeroRefJuegoBarcos();

		}

		return str;
	}

	/**
	 * Method 'getTecnicosEntidad'
	 * 
	 * @return the tecnicosEntidad
	 */
	public TecnicosEntidad getTecnicosEntidad() {
		return tecnicosEntidad;
	}

	/**
	 * Method 'setTecnicosEntidad'
	 * 
	 * @param tecnicosEntidad
	 *            the tecnicosEntidad to set
	 */
	public void setTecnicosEntidad(TecnicosEntidad tecnicosEntidad) {
		this.tecnicosEntidad = tecnicosEntidad;
	}

	/**
	 * Method 'isTecnicoEntidad'
	 * 
	 * @return the tecnicoEntidad
	 */
	public boolean isTecnicoEntidad() {
		return !this.esTecnicoHPS;
	}

	/**
	 * Method 'isTecnicoHps'
	 *
	 * @return the tecnicoHps
	 */
	public boolean isTecnicoHps() {

		return this.esTecnicoHPS;
	}

	/**
	 * @return the rellenarDatosIncompletos
	 */
	public boolean isRellenarDatosIncompletos() {
		return rellenarDatosIncompletos;
	}

	/**
	 * @param rellenarDatosIncompletos
	 *            the rellenarDatosIncompletos to set
	 */
	public void setRellenarDatosIncompletos(boolean rellenarDatosIncompletos) {
		this.rellenarDatosIncompletos = rellenarDatosIncompletos;
	}

	/**
	 * Method 'setTecnicoHps'
	 *
	 * @param tecnicoHps
	 *            the tecnicoHps to set
	 */
	private void setTecnicoHps(boolean tecnicoHps) {
		this.esTecnicoHPS = tecnicoHps;
	}

	/**
	 * Devuelve la entidad principal
	 * 
	 * @return Entidades entidad
	 */
	public Entidades getEntidadPrincipal() {
		Entidades ent = null;
		if (this.isTecnicoEntidad()) {
			ent = this.getTecnicosEntidad().getEntidadPrincipal();
		}
		return ent;

	}

	/**
	 * 
	 * @param entidad
	 *            Entidades
	 */
	public void setEntidadPrincipal(Entidades entidad) {
		if (this.getTecnicosEntidad() == null) {
			this.setTecnicosEntidad(new TecnicosEntidad());
		}
		this.getTecnicosEntidad().setEntidadPrincipal(entidad);
	}

	/**
	 * 
	 * @param b
	 *            boolean
	 */
	public void setPrimeraVez(boolean b) {
		this.primeraVez = b;
	}

	/**
	 * 
	 * @return boolean
	 */
	public boolean isPrimeraVez() {
		return this.primeraVez;
	}

	/**
	 * Limpia la lista de Entidades del tecnico con aquellas que tiene en el RdR
	 * 
	 * 
	 * @throws Exception
	 *             e e
	 */
	public void verificarEntidadesTrabaja() throws Exception {
		this.verificarEntidadesTrabaja(this.getListaEntidadesRdr());
	}

	/**
	 * Limpia la lista de Entidades del tecnico con aquellas que tiene en el RdR
	 * 
	 * @param lista
	 *            List<Entidades> lista
	 * @throws Exception
	 *             exception e
	 */
	public void verificarEntidadesTrabaja(List<Entidades> lista) throws Exception {
		if (this.getTecnicosEntidad() == null || this.getTecnicosEntidad().getEntidadeses() == null
				|| this.getTecnicosEntidad().getEntidadeses().isEmpty()) {
			UsuarioConectado.logger.debug("UsuarioConectado: verificarEntidadesTrabaja - Tecnico no tiene entidades");
			return;
		}
		if (lista == null || lista.isEmpty()) {
			UsuarioConectado.logger
					.debug("UsuarioConectado: verificarEntidadesTrabaja - Entiadades RdR  ES NULO O VACIO");

			// si no tiene entidades en el RdR, se ponen todas a null
			if (this.getTecnicosEntidad() != null) {
				this.getTecnicosEntidad().setEntidadeses(null);
			}
			return;
		}
		List<Entidades> listaDev = new ArrayList<Entidades>();
		List<Entidades> listaEntidades = this.getTecnicosEntidad().getEntidadeses();
		Entidades.EntidadesCifComparator compara = new Entidades.EntidadesCifComparator();
		for (Entidades entidad : listaEntidades) {
			for (Entidades ent : lista) {
				if (compara.compare(entidad, ent) == 0 && Constantes.ALTA_LOGICA == entidad.getBaja().intValue()) {
					listaDev.add(entidad);
				}
			}
		}
		this.getTecnicosEntidad().setEntidadeses(listaDev);
		UsuarioConectado.logger.debug("UsuarioConectado: verificarEntidadesTrabaja - Saliendo");
	}

	/**
	 * Indica si se ha validado con el certificado de entidad
	 * 
	 * @return boolean true si se ha validado con certificado de entidad
	 */
	public boolean isCertificadoEntidad() {
		return this.esCertificadoEntidad;
	}

	/**
	 * 
	 * @param bvalor
	 *            boolean indica si es certificado de entidad
	 */
	private void setIsCertificadoEntidad(boolean bvalor) {
		this.esCertificadoEntidad = bvalor;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * com.ejie.x38.security.UserCredentials#afterCredentialsCreation(com.ejie.
	 * x38.security.PerimetralSecurityWrapper,
	 * javax.servlet.http.HttpServletRequest)
	 */
	@Override
	protected void afterCredentialsCreation(PerimetralSecurityWrapper perimetralSecurityWrapper,
			HttpServletRequest request) {
		super.afterCredentialsCreation(perimetralSecurityWrapper, request);

		// verificar si es tecnico hps
		boolean tienePerfil1 = false;
		boolean tienePerfil2 = false;
		Vector<String> profiles = this.getUserProfiles();
		for (String profile : profiles) {
			if (profile.equalsIgnoreCase(UsuarioConectado.ROL_TECNICO_HPS_1)) {
				tienePerfil1 = true;
			}
			if (profile.equalsIgnoreCase(UsuarioConectado.ROL_TECNICO_HPS_2)) {
				tienePerfil2 = true;
			}
		}

		this.setTecnicoHps(tienePerfil1 && tienePerfil2);

		try {

			if (!this.isTecnicoHps()) {

				this.setJuegoBarcos(Constantes.POLITICA_JUEGOBARCOS.equalsIgnoreCase(this.getPolicy()));
				if (this.isJuegoBarcos()) {
					UsuarioConectado.logger.debug("afterCredentialsCreation: Es Juego de barcos");
					this.cargarDatosFromTokenN38B64(request, this, TIPO_CARGA_CERTIFICADO.TIPO_CARGA_CERTIFICADO_JB);

					this.setIsCertificadoEntidad(false);
					this.setIsCertificadoRepresentante(false);
					this.setIsCertificadoAccesoDirecto(false);
					this.setIsCertificadoPersonalPublico(false);
					this.setEsVerificarRdr(false);
					return;

				}

				// Si es certificado de entidad
				boolean bDev = this.isTipoCertificadoBuscado(UtilProperties.Props.certificado_entidad.getValue());
				UsuarioConectado.logger.debug(
						"afterCredentialsCreation: isCertificadoEntidad - resultado:".concat(String.valueOf(bDev)));
				this.setIsCertificadoEntidad(bDev);

				// si es certificado de representante
				if (!bDev) {
					bDev = this.isTipoCertificadoBuscado(UtilProperties.Props.certificado_representante.getValue());

					UsuarioConectado.logger.debug("afterCredentialsCreation: isCertificadoRepresentante - resultado:"
							.concat(String.valueOf(bDev)));
					this.setIsCertificadoRepresentante(bDev);
				}

				// si es certificado de acceso directo
				bDev = this.isTipoCertificadoBuscado(UtilProperties.Props.certificados_acceso_directo.getValue());
				UsuarioConectado.logger.debug("afterCredentialsCreation: isCertificadoAccesoDirecto- resultado:"
						.concat(String.valueOf(bDev)));
				this.setIsCertificadoAccesoDirecto(bDev);

				// si es certificado de personal publico (gv o entidades
				// publicas)
				bDev = this.isTipoCertificadoBuscado(UtilProperties.Props.certificado_personal_publico.getValue());
				UsuarioConectado.logger.debug("afterCredentialsCreation: isCertificadoPersonalPublico- resultado:"
						.concat(String.valueOf(bDev)));
				this.setIsCertificadoPersonalPublico(bDev);

				this.setEsVerificarRdr(
						this.isTecnicoEntidad() && this.getIsCertificate() && !this.isCertificadoAccesoDirecto());

				UsuarioConectado.logger.debug("afterCredentialsCreation: cif de entidad - tratamiento especial:");
				this.realizarTratamientoEspecialCargaDatosCertificado(request, this);
				String cif = this.getCifEntidadFormCertificado();

				UsuarioConectado.logger.debug("afterCredentialsCreation: cif entidad del certificado publico- :"
						.concat(((cif == null) ? "" : cif)));

			}
		} catch (Exception e) {
			UsuarioConectado.logger.error("afterCredentialsCreation:ERROR:".concat(e.getMessage()), e);
			UsuarioConectado.logger.debug("afterCredentialsCreation:ERROR:".concat(e.getMessage()));
		}
	}

	/**
	 * Metodo que centraliza el tratamiento de la informacion proporcionada por
	 * el parametro n38b64thirdpartyassertion
	 * 
	 * @param request
	 *            HttpServletRequest request para obtener el token
	 * @param usuarioConectado
	 *            objeto usuario conectado
	 * @param tipoCarga
	 *            tipo de carga a realizar
	 */
	private void cargarDatosFromTokenN38B64(HttpServletRequest request, UsuarioConectado usuarioConectado,
			TIPO_CARGA_CERTIFICADO tipoCarga) throws Exception {

		try {

			UsuarioConectado.logger
					.debug("cargarDatosFromTokenN38B64:entrando: tipoCarga:".concat(tipoCarga.toString()));

			switch (tipoCarga) {
			case TIPO_CARGA_CERTIFICADO_JB:
				UsuarioConectado.logger.debug("cargarDatosFromTokenN38B64:entrando: por juego de barcos:");

				usuarioConectado.setDatosJuegoBarcos(FeaHelper.getDatosJuegoBarcosFromFea(request, usuarioConectado));
				// usuarioConectado.setJuegoBarcos(true);
				if (usuarioConectado.getDatosJuegoBarcos() != null
						&& usuarioConectado.getDatosJuegoBarcos().getDatosPersonaJuegoBarcos() != null) {

					FeaDatosPersona persona = usuarioConectado.getDatosJuegoBarcos().getDatosPersonaJuegoBarcos();
					usuarioConectado.setNif(persona.getDni());
				}

				break;

			case TIPO_CARGA_CERTIFICADO_PERSONA_ENTIDAD:
				UsuarioConectado.logger.debug("cargarDatosFromTokenN38B64: tratamiento persona con entidad");
				usuarioConectado.setDatosJuegoBarcos(FeaHelper.getDatosCertGVsFromFea(request, usuarioConectado));
				// usuarioConectado.setJuegoBarcos(true);
				if (usuarioConectado.getDatosJuegoBarcos() != null
						&& usuarioConectado.getDatosJuegoBarcos().getDatosPersonaJuegoBarcos() != null) {

					FeaDatosPersona persona = usuarioConectado.getDatosJuegoBarcos().getDatosPersonaJuegoBarcos();
					usuarioConectado.setNif(persona.getDni());
					usuarioConectado.setCifEntidadFormCertificado(persona.getCif());

				}
				break;

			default:
				UsuarioConectado.logger.debug("cargarDatosFromTokenN38B64: tipo de carga erronea");
				throw new Exception("cargarDatosFromTokenN38B64: tipo de carga erronea");
			}

			UsuarioConectado.logger.debug("cargarDatosFromTokenN38B64:saliendo");

		} catch (Exception e) {
			UsuarioConectado.logger.error("cargarDatosFromTokenN38B64:ERROR:".concat(e.getMessage()), e);
			UsuarioConectado.logger.debug("cargarDatosFromTokenN38B64:ERROR:".concat(e.getMessage()));
			throw e;
		}
	}

	/**
	 * 
	 * @param request
	 *            HttpServletRequest
	 * @param usuarioConectado
	 *            UsuarioConectado
	 * @throws Exception
	 *             e
	 */
	private void realizarTratamientoEspecialCargaDatosCertificado(HttpServletRequest request,
			UsuarioConectado usuarioConectado) throws Exception {
		this.cargarDatosFromTokenN38B64(request, usuarioConectado,
				TIPO_CARGA_CERTIFICADO.TIPO_CARGA_CERTIFICADO_PERSONA_ENTIDAD);
	}

	/**
	 * 
	 * @return boolean indica si es certificado de representante
	 */
	public boolean isCertificadoRepresentante() {
		return this.esCertificadoRepresentante;
	}

	/**
	 * 
	 * @param bvalor
	 *            boolean indica si es certificado de representante
	 */
	private void setIsCertificadoRepresentante(boolean bvalor) {
		this.esCertificadoRepresentante = bvalor;
	}

	/**
	 * 
	 * @return boolean true si es uno de los certificados de acceso directo
	 */
	public boolean isCertificadoAccesoDirecto() {
		return this.esAccesoDirecto;
	}

	/**
	 * 
	 * @param bvalor
	 *            true si es un certificado de acceso directo
	 */
	private void setIsCertificadoAccesoDirecto(boolean bvalor) {
		this.esAccesoDirecto = bvalor;
	}

	/**
	 * @return the isCertificadoFuncionario
	 */
	public boolean isCertificadoPersonalPublico() {
		return this.esCertificadoPersonalPublico;
	}

	/**
	 * @param isCertificadoPersonalPublico
	 *            the isCertificadoPersonalPublico to set
	 */
	private void setIsCertificadoPersonalPublico(boolean isCertificadoPersonalPublico) {
		this.esCertificadoPersonalPublico = isCertificadoPersonalPublico;
	}

	/**
	 * 
	 * @param valorParametro
	 *            String valor del parametro buscado
	 * @return boolean true si el tipo de politica existe en el tipo de
	 *         certificado buscado
	 */
	private boolean isTipoCertificadoBuscado(String valorParametro) {
		if (!this.isTecnicoEntidad()) {
			UsuarioConectado.logger.debug("UsuarioConectado: isTipoCertificadoBuscado - No es Tecnico de Entidad");
			return false;
		}
		boolean bDev = false;
		if (this.getIsCertificate()) {
			UsuarioConectado.logger.debug("UsuarioConectado: isTipoCertificadoBuscado - Es Certificado");
			String politica = this.getPolitica();
			if (politica == null) {
				politica = "";
			}
			String politicaCertificadoEntidad = valorParametro;
			if (politicaCertificadoEntidad != null && politicaCertificadoEntidad.trim().length() > 0) {
				for (String cadena : politicaCertificadoEntidad.split(Constantes.SEPARADOR_COMA)) {
					if (cadena != null && cadena.trim().length() > 0 && cadena.equalsIgnoreCase(politica.trim())) {
						bDev = true;
						break;
					}
				}
			}
		}

		UsuarioConectado.logger
				.debug("UsuarioConectado: isTipoCertificadoBuscado - resultado:".concat(String.valueOf(bDev)));
		return bDev;
	}

	/**
	 * 
	 * @param valorParametro
	 *            String valor del parametro buscado
	 * @return boolean true si el tipo de politica existe en el tipo de
	 *         certificado buscado
	 */
	public boolean esPoliticaCertificadoByFiltro(String valorParametro) {
		return this.isTipoCertificadoBuscado(valorParametro);
	}

	/**
	 * 
	 * @return boolean true si esta dado de baja
	 */
	public boolean isTecnicoBaja() {
		if (!this.isTecnicoEntidad()) {
			return false;
		}
		TecnicosEntidad tecnico = this.getTecnicosEntidad();
		return ((tecnico != null && tecnico.getBaja() != null)
				? (Constantes.BAJA_LOGICA == tecnico.getBaja().intValue()) : false);
	}

	/**
	 * 
	 * @return boolean true si tiene entidades de alta asociadas
	 */
	public boolean isTieneEntidadesAsociadas() {
		if (!this.isTecnicoEntidad()) {
			return false;
		}
		TecnicosEntidad tecnico = this.getTecnicosEntidad();
		if (tecnico == null) {
			UsuarioConectado.logger.debug("usuarioConectado.tieneEntidadesAsociadas: tecnico == null");
			return false;
		}
		List<Entidades> listaEnt = tecnico.getEntidadeses();
		if (listaEnt == null || listaEnt.isEmpty()) {
			UsuarioConectado.logger.debug("usuarioConectado.tieneEntidadesAsociadas: listaEntidades == null");
			return false;
		}
		boolean bdev = false;
		for (Entidades entidad : listaEnt) {
			if (Constantes.BAJA_LOGICA != entidad.getBaja().intValue()) {
				bdev = true;
				break;
			}
		}
		UsuarioConectado.logger.debug("usuarioConectado.tieneEntidadesAsociadas: saliendo:" + String.valueOf(bdev));
		return bdev;
	}

	/**
	 * @return the esValidado
	 */
	public boolean isEsValidado() {
		return this.esValidado;
	}

	/**
	 * @param esValidado
	 *            the esValidado to set
	 */
	public void setEsValidado(boolean esValidado) {
		this.esValidado = esValidado;
	}

	/**
	 * @return the listaEntidadesRdr
	 */
	public List<Entidades> getListaEntidadesRdr() {
		return listaEntidadesRdr;
	}

	/**
	 * @param listaEntidadesRdr
	 *            the listaEntidadesRdr to set
	 */
	public void setListaEntidadesRdr(List<Entidades> listaEntidadesRdr) {
		this.listaEntidadesRdr = listaEntidadesRdr;
	}

	/**
	 * @return the esVerificarRdr
	 */
	public boolean isEsVerificarRdr() {
		return this.esVerificarRdr;
	}

	/**
	 * @param esVerificarRdr
	 *            the esVerificarRdr to set
	 */
	private void setEsVerificarRdr(boolean esVerificarRdr) {
		this.esVerificarRdr = esVerificarRdr;
	}

	/**
	 * Devuelve el cif del certificado de entidad si su certificado tiene el CIF
	 * de entidad
	 * 
	 * @return String cif obtenido del certificado
	 */
	public String getCifEntidadFormCertificado() {
		return this.cifEntidad;
	}

	/**
	 * 
	 * @param cif
	 *            String cif obtenido del certificado
	 */
	public void setCifEntidadFormCertificado(String cif) {
		this.cifEntidad = cif;
	}

	/**
	 * Metodo que devuelve la lista de entidades que no tienen todos los datos
	 * necesarios
	 * 
	 * @return List<Entidades> lista de Entidades que no tienen todos los datos
	 *         necesarios
	 */
	public List<Entidades> getListaEntidadesNoCompletas() {
		return listaEntidadesNoCompletas;
	}

	/**
	 * Informa la lista de entidades no completas
	 * 
	 * @param listaEntidadesNoCompletas
	 *            List<Entidades> lista de entidades no completas
	 */
	public void setListaEntidadesNoCompletas(List<Entidades> listaEntidadesNoCompletas) {
		this.listaEntidadesNoCompletas = listaEntidadesNoCompletas;
	}

}