package com.rjconsultores.ventaboletos.dao.hibernate;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.hibernate.SQLQuery;
import org.hibernate.SessionFactory;
import org.hibernate.type.BigDecimalType;
import org.hibernate.type.DateType;
import org.hibernate.type.IntegerType;
import org.hibernate.type.LongType;
import org.hibernate.type.StringType;
import org.hibernate.type.TimestampType;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;

import com.rjconsultores.ventaboletos.constantes.Constantes;
import com.rjconsultores.ventaboletos.dao.BusquedaDatosTicketDAO;
import com.rjconsultores.ventaboletos.entidad.Pacote;
import com.rjconsultores.ventaboletos.enums.SituacaoVendaPacote;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.ClientePacoteVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.EnderecoApanheVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.ItemAdicionalVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.PacoteVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.PagamentoVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.PassageiroVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.ServicoVO;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosClientePacoteResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosEnderecoApanheResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosItemAdicionalResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosPagamentoResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosPassageiroResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosServicoResultTransformer;
import com.rjconsultores.ventaboletos.vo.busquedapacotes.transformer.DatosTicketResultTransformer;

@Repository("busquedaDatosTicketDAO")
public class BusquedaDatosTicketHibernateDAO extends GenericHibernateDAO<Pacote, Integer> implements BusquedaDatosTicketDAO {

	private static Logger log = org.slf4j.LoggerFactory.getLogger(BusquedaDatosTicketHibernateDAO.class);
	private List<Long> vendapacoteIds;
	
	@Autowired
	public BusquedaDatosTicketHibernateDAO(@Qualifier("sessionFactory") SessionFactory factory) {
		setSessionFactory(factory);
	}
	
	@Override
	public List<PacoteVO> buscaDatosTickets(Date fecInicial, Date fecFinal, Date fecVentaInicial, Date fecVentaFinal) {
		vendapacoteIds = null;
		List<PacoteVO> pacotes = new ArrayList<PacoteVO>();
		
		try {
			pacotes = carregarDadosPacotes(fecInicial, fecFinal, fecVentaInicial, fecVentaFinal);
			if(!pacotes.isEmpty()) {
				carregarDadosPagamento(pacotes);
				carregarDadosServico(pacotes);
				carregarDadosPassageiros(pacotes);
				carregarDadosCliente(pacotes);
				carregarDadosEnderecoApanhe(pacotes);
				carregarDadosItemPacotes(pacotes);
			}
			
		} catch(Exception e) {			
			log.error(e.getMessage(), e);
			pacotes.clear();
		}
				
		return pacotes;
	}

	@SuppressWarnings("unchecked")
	private List<PacoteVO> carregarDadosPacotes(Date fecInicial, Date fecFinal, Date fecVentaInicial, Date fecVentaFinal) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT VP.VENDAPACOTE_ID, VP.DATAPACOTE, VP.DATAVENDA, VP.SUBTOTAL, VP.TOTAL, VP.DESCONTO, VP.NUMOPERACION, P.PACOTE_ID, ")
			  .append("P.NOMPACOTE, P.DESCPACOTE, E.NOMBEMPRESA, VP.SITUACAO, PV.NOMBPUNTOVENTA, VP.USUARIO_ID, ")	  
			  .append("COUNT(TVP.TARIFAVENDAPACOTE_ID) AS QTDEPASSAGEIRO, ")
			  .append("SUM(B.PRECIOPAGADO) AS TOTALTARIFA, ")
    		  .append("SUM(B.IMPORTETAXAEMBARQUE) AS TOTALTAXAEMBARQUE, ")
    		  .append("SUM(B.IMPORTEPEDAGIO) AS TOTALPEDAGIO, ")
    		  .append("SUM(B.IMPORTEOUTROS) AS TOTALOUTROS, ")
    		  .append("SUM(B.IMPORTESEGURO) AS TOTALSEGURO, ")
    		  .append("(SELECT COUNT(DISTINCT PFP.PACOTEFORMAPAGO_ID) FROM PACOTE_FORMAPAGO PFP WHERE PFP.VENDAPACOTE_ID = VP.VENDAPACOTE_ID) AS QTDEPACOTEFORMAPAGO ")
			  .append("FROM VENDA_PACOTE VP ")
			  .append("JOIN PACOTE P ON P.PACOTE_ID = VP.PACOTE_ID ")
			  .append("JOIN EMPRESA E ON E.EMPRESA_ID = P.EMPRESA_ID ")
			  .append("LEFT JOIN PUNTO_VENTA PV ON PV.PUNTOVENTA_ID = VP.PUNTOVENTA_ID ")
			  .append("LEFT JOIN TARIFA_VENDA_PACOTE TVP ON TVP.VENDAPACOTE_ID = VP.VENDAPACOTE_ID ")
			  .append("LEFT JOIN BOLETO B ON B.BOLETO_ID = TVP.BOLETO_ID ")
			  .append("WHERE (B.BOLETO_ID IS NULL OR B.INDSTATUSBOLETO = 'V') ")
			  .append("AND VP.DATAPACOTE BETWEEN :fecInicial AND :fecFinal ");
		
		if(fecVentaInicial != null) {
			sQuery.append("AND VP.DATAVENDA >= :fecVentaInicial ");
		}
		if(fecVentaFinal != null) {
			sQuery.append("AND VP.DATAVENDA <= :fecVentaFinal ");
		}
		
		sQuery.append("GROUP BY VP.VENDAPACOTE_ID, VP.DATAPACOTE, VP.DATAVENDA, VP.SUBTOTAL, VP.TOTAL, ")
			  .append("VP.DESCONTO, VP.NUMOPERACION, P.PACOTE_ID, P.NOMPACOTE, P.DESCPACOTE, E.NOMBEMPRESA, VP.SITUACAO, PV.NOMBPUNTOVENTA, VP.USUARIO_ID ");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("DATAPACOTE", DateType.INSTANCE)
			 .addScalar("DATAVENDA", TimestampType.INSTANCE)
			 .addScalar("SUBTOTAL", BigDecimalType.INSTANCE)
			 .addScalar("TOTAL", BigDecimalType.INSTANCE)
			 .addScalar("DESCONTO", BigDecimalType.INSTANCE)
			 .addScalar("NUMOPERACION", StringType.INSTANCE)		
			 .addScalar("PACOTE_ID", LongType.INSTANCE)
			 .addScalar("NOMPACOTE", StringType.INSTANCE)
			 .addScalar("DESCPACOTE", StringType.INSTANCE)
			 .addScalar("NOMBEMPRESA", StringType.INSTANCE)
			 .addScalar("SITUACAO", IntegerType.INSTANCE)
			 .addScalar("NOMBPUNTOVENTA", StringType.INSTANCE)		
			 .addScalar("USUARIO_ID", IntegerType.INSTANCE)
			 .addScalar("QTDEPASSAGEIRO", IntegerType.INSTANCE)
			 .addScalar("TOTALTARIFA", BigDecimalType.INSTANCE)
			 .addScalar("TOTALTAXAEMBARQUE", BigDecimalType.INSTANCE)
			 .addScalar("TOTALPEDAGIO", BigDecimalType.INSTANCE)
			 .addScalar("TOTALOUTROS", BigDecimalType.INSTANCE)
			 .addScalar("TOTALSEGURO", BigDecimalType.INSTANCE)
			 .addScalar("QTDEPACOTEFORMAPAGO", IntegerType.INSTANCE);
		
		query.setResultTransformer(new DatosTicketResultTransformer());
		query.setParameter("fecInicial", fecInicial, DateType.INSTANCE)
			 .setParameter("fecFinal", fecFinal, DateType.INSTANCE);
		
		if(fecVentaInicial != null) {
			query.setParameter("fecVentaInicial", fecVentaInicial, TimestampType.INSTANCE);
		}
		if(fecVentaFinal != null) {
			query.setParameter("fecVentaFinal", fecVentaFinal, TimestampType.INSTANCE);
		}
		
		return query.list();
	}
	
	@SuppressWarnings("unchecked")
	private void carregarDadosPagamento(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT PFP.PACOTEFORMAPAGO_ID, PFP.VALOR, PFP.VENDAPACOTE_ID, FP.FORMAPAGO_ID, FP.DESCPAGO, CT.TIPOTARJETA, CT.NUMAUTORIZACION, CT.CANTPARCELAS, ")
			  .append("NC.NOTACREDITOVENDAPACOTE_ID, VPC.NUMOPERACION AS NUMOPERACAOPACOTECANCELAMENTO ")
			  .append("FROM PACOTE_FORMAPAGO PFP ")
			  .append("JOIN FORMA_PAGO FP ON FP.FORMAPAGO_ID = PFP.FORMAPAGO_ID ")
			  .append("LEFT JOIN CAJA_DIVERSOS CD ON CD.VENDAPACOTE_ID = PFP.VENDAPACOTE_ID ")
			  .append("LEFT JOIN CAJA_DIVERSOS_PAGO CDP ON CDP.CAJADIVERSOS_ID = CD.CAJADIVERSOS_ID ")
			  .append("LEFT JOIN CAJA_TARJETA CT ON CT.CAJATARJETA_ID = CDP.CAJATARJETA_ID ")
			  .append("LEFT JOIN NOTA_CREDITO_VENDA_PACOTE NC ON NC.VENDAPACOTEPAGAMENTO_ID = PFP.VENDAPACOTE_ID ")
			  .append("LEFT JOIN VENDA_PACOTE VPC ON NC.VENDAPACOTECANCELAMENTO_ID = VPC.VENDAPACOTE_ID ")
			  .append("WHERE PFP.VENDAPACOTE_ID IN (:vendapacoteIds) ")
			  .append("ORDER BY PFP.VENDAPACOTE_ID");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("PACOTEFORMAPAGO_ID", LongType.INSTANCE)
			 .addScalar("VALOR", BigDecimalType.INSTANCE)
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("FORMAPAGO_ID", IntegerType.INSTANCE)
			 .addScalar("DESCPAGO", StringType.INSTANCE)
			 .addScalar("TIPOTARJETA", StringType.INSTANCE)
			 .addScalar("NUMAUTORIZACION", StringType.INSTANCE)
			 .addScalar("CANTPARCELAS", IntegerType.INSTANCE)
			 .addScalar("NOTACREDITOVENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("NUMOPERACAOPACOTECANCELAMENTO", StringType.INSTANCE);
		
		query.setResultTransformer(new DatosPagamentoResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<PagamentoVO> pagamentos = query.list();
		for (PacoteVO pacote : pacotes) {
			int flag = -1;
			for (PagamentoVO pagamento : pagamentos) {
				if(pagamento.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					flag = 0;
					if(pacote.getFormaspagamento() == null) {
						pacote.setFormaspagamento(new ArrayList<PagamentoVO>());
					}

					if(isPacoteReserva(pacote) && isPagamentoPacoteReserva(pagamento) ||
					  (isPagamentoPacoteReserva(pagamento) && pacote.getQtdePacoteFormaspago() == 1) ||
					  (!isPacoteReserva(pacote) && !isPagamentoPacoteReserva(pagamento))) {
						pacote.getFormaspagamento().add(pagamento);
					}
				} else if(flag == 0){
					break;
				}
			}
		}
	}

	private boolean isPacoteReserva(PacoteVO pacote) {
		return  SituacaoVendaPacote.RESERVA.toString().equals(pacote.getStatus());
	}

	private boolean isPagamentoPacoteReserva(PagamentoVO pagamento) {
		return pagamento.getFormapagoId().equals(Constantes.FORMA_PAGO_RESERVA.intValue());
	}

	@SuppressWarnings("unchecked")
	private void carregarDadosServico(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT DISTINCT VP.VENDAPACOTE_ID, B.FECHORVIAJE, B.ORIGEN_ID, CONCAT(CONCAT(ORI.CVEPARADA,' - '),ORI.DESCPARADA) AS ORIGEM, CONCAT(CONCAT(DES.CVEPARADA,' - '),DES.DESCPARADA) AS DESTINO ")
			  .append("FROM VENDA_PACOTE VP ")
			  .append("JOIN PACOTE P ON P.PACOTE_ID = VP.PACOTE_ID ")
			  .append("JOIN TARIFA_VENDA_PACOTE TVP ON TVP.VENDAPACOTE_ID = VP.VENDAPACOTE_ID ")
			  .append("JOIN BOLETO B ON B.BOLETO_ID = TVP.BOLETO_ID ")
			  .append("JOIN PARADA ORI ON ORI.PARADA_ID = B.ORIGEN_ID ")
			  .append("JOIN PARADA DES ON DES.PARADA_ID = B.DESTINO_ID ")
			  .append("WHERE VP.VENDAPACOTE_ID IN (:vendapacoteIds) ");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("FECHORVIAJE", TimestampType.INSTANCE)
			 .addScalar("ORIGEN_ID", IntegerType.INSTANCE)
			 .addScalar("ORIGEM", StringType.INSTANCE)
			 .addScalar("DESTINO", StringType.INSTANCE);
		
		query.setResultTransformer(new DatosServicoResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<ServicoVO> servicos = query.list();
		for (PacoteVO pacote : pacotes) {
			for (ServicoVO servico : servicos) {
				if(servico.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					pacote.setServico(servico);
					break;
				}
			}
		}
	}

	@SuppressWarnings("unchecked")
	private void carregarDadosCliente(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT DISTINCT VP.VENDAPACOTE_ID, CP.RAZAO_SOCIAL, CP.CPF_CNPJ, CP.TIPO_PESSOA, CP.DESCEMAIL, CP.DESCTELEFONE, CP.DESCFAX, CP.CEP, CP.ENDERECO, CP.NUMERO, CP.COMPLEMENTO, CP.PAIS, CP.ESTADO, CP.CIDADE, CP.BAIRRO ")
			  .append("FROM CLIENTE_PACOTE CP ")
			  .append("JOIN VENDA_PACOTE VP ON CP.CLIENTEPACOTE_ID = VP.CLIENTEPACOTE_ID ")
			  .append("WHERE VP.VENDAPACOTE_ID IN (:vendapacoteIds) ");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("RAZAO_SOCIAL", StringType.INSTANCE)
			 .addScalar("CPF_CNPJ", StringType.INSTANCE)
			 .addScalar("TIPO_PESSOA", IntegerType.INSTANCE)
			 .addScalar("DESCEMAIL", StringType.INSTANCE)
			 .addScalar("DESCTELEFONE", StringType.INSTANCE)
			 .addScalar("DESCFAX", StringType.INSTANCE)
			 .addScalar("CEP", StringType.INSTANCE)
			 .addScalar("ENDERECO", StringType.INSTANCE)
			 .addScalar("NUMERO", StringType.INSTANCE)
			 .addScalar("COMPLEMENTO", StringType.INSTANCE)
			 .addScalar("PAIS", StringType.INSTANCE)
			 .addScalar("ESTADO", StringType.INSTANCE)
			 .addScalar("CIDADE", StringType.INSTANCE)
			 .addScalar("BAIRRO", StringType.INSTANCE);
		
		query.setResultTransformer(new DatosClientePacoteResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<ClientePacoteVO> clientesPacotes = query.list();
		for (PacoteVO pacote : pacotes) {
			for (ClientePacoteVO clientePacote : clientesPacotes) {
				if(clientePacote.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					pacote.setClientePacote(clientePacote);
				}
			}
		}
	}

	@SuppressWarnings("unchecked")
	private void carregarDadosPassageiros(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT DISTINCT VP.VENDAPACOTE_ID, TVP.TARIFAVENDAPACOTE_ID, TVP.NOMEPASSAGEIRO, CONCAT(CONCAT(TVP.TIPODOC,' - '), TVP.DOCUMENTO) AS DOCUMENTO, B.NUMASIENTO, C.CATEGORIA_ID, C.DESCCATEGORIA, B.BOLETO_ID ")
			  .append("FROM VENDA_PACOTE VP ")
			  .append("JOIN TARIFA_VENDA_PACOTE TVP ON TVP.VENDAPACOTE_ID = VP.VENDAPACOTE_ID ")
			  .append("LEFT JOIN BOLETO B ON B.BOLETO_ID = TVP.BOLETO_ID ")
			  .append("LEFT JOIN CATEGORIA C ON C.CATEGORIA_ID = B.CATEGORIA_ID ")
			  .append("WHERE VP.VENDAPACOTE_ID IN (:vendapacoteIds) ");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("BOLETO_ID", LongType.INSTANCE)
			 .addScalar("TARIFAVENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("NOMEPASSAGEIRO", StringType.INSTANCE)
			 .addScalar("DOCUMENTO", StringType.INSTANCE)
			 .addScalar("NUMASIENTO", StringType.INSTANCE)
			 .addScalar("CATEGORIA_ID", IntegerType.INSTANCE)
			 .addScalar("DESCCATEGORIA", StringType.INSTANCE);
		
		query.setResultTransformer(new DatosPassageiroResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<PassageiroVO> passageiros = query.list();
		for (PacoteVO pacote : pacotes) {
			for (PassageiroVO passageiro : passageiros) {
				if(passageiro.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					if(pacote.getPax() == null) {
						pacote.setPax(new ArrayList<PassageiroVO>());
					}
					pacote.getPax().add(passageiro);
				}
			}
		}		
	}

	@SuppressWarnings("unchecked")
	private void carregarDadosEnderecoApanhe(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT DISTINCT VP.VENDAPACOTE_ID, EA.LOCAL, EA.DESCHOTEL, EA.CEP, EA.ENDERECO, EA.NUMERO, EA.COMPLEMENTO, EA.CIDADE, EA.BAIRRO, EA.REFERENCIA ")
			  .append("FROM ENDERECO_APANHE EA ")
			  .append("JOIN VENDA_PACOTE VP ON EA.VENDAPACOTE_ID = VP.VENDAPACOTE_ID ")
			  .append("WHERE VP.VENDAPACOTE_ID IN (:vendapacoteIds) ")
			  .append("AND EA.ACTIVO = 1");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("LOCAL", IntegerType.INSTANCE)
			 .addScalar("CEP", StringType.INSTANCE)
			 .addScalar("ENDERECO", StringType.INSTANCE)
			 .addScalar("NUMERO", StringType.INSTANCE)
			 .addScalar("COMPLEMENTO", StringType.INSTANCE)
			 .addScalar("CIDADE", StringType.INSTANCE)
			 .addScalar("BAIRRO", StringType.INSTANCE)
			 .addScalar("REFERENCIA", StringType.INSTANCE);
		
		query.setResultTransformer(new DatosEnderecoApanheResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<EnderecoApanheVO> enderecosApanhe = query.list();
		for (PacoteVO pacote : pacotes) {
			for (EnderecoApanheVO enderecoApanhe : enderecosApanhe) {
				if(enderecoApanhe.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					pacote.setEnderecoApanhe(enderecoApanhe);
				}
			}
		}
	}
	
	private List<Long> getVendapacoteIds(List<PacoteVO> pacotes) {
		if(vendapacoteIds == null || vendapacoteIds.isEmpty()) {
			vendapacoteIds = new ArrayList<Long>();
			for (PacoteVO pacoteVO : pacotes) {
				vendapacoteIds.add(pacoteVO.getVendapacoteId());
			}
		}
		
		return vendapacoteIds;
	}
	
	@SuppressWarnings("unchecked")
	private void carregarDadosItemPacotes(List<PacoteVO> pacotes) {
		StringBuilder sQuery = new StringBuilder();
		sQuery.append("SELECT DISTINCT IA.DESCITEMADICIONAL, VP.VENDAPACOTE_ID, PI.ITEMADICIONAL_ID ")
			  .append("FROM ITEM_ADICIONAL IA ")
			  .append("JOIN PACOTE_ITEM PI ON IA.ITEMADICIONAL_ID = PI.ITEMADICIONAL_ID ")
			  .append("JOIN PACOTE P ON P.PACOTE_ID = PI.PACOTE_ID ")
			  .append("JOIN VENDA_PACOTE VP ON VP.PACOTE_ID = P.PACOTE_ID ")
			  .append("WHERE IA.ACTIVO = 1 ")
			  .append("AND VP.VENDAPACOTE_ID IN (:vendapacoteIds) ");
		
		SQLQuery query = getSession().createSQLQuery(sQuery.toString())
			 .addScalar("DESCITEMADICIONAL", StringType.INSTANCE)
			 .addScalar("VENDAPACOTE_ID", LongType.INSTANCE)
			 .addScalar("ITEMADICIONAL_ID", LongType.INSTANCE);
		
		query.setResultTransformer(new DatosItemAdicionalResultTransformer());
		query.setParameterList("vendapacoteIds", getVendapacoteIds(pacotes));
		
		List<ItemAdicionalVO> itens = query.list();
		for (PacoteVO pacote : pacotes) {
			for (ItemAdicionalVO itemAdicional : itens) {
				if(itemAdicional.getVendapacoteId().equals(pacote.getVendapacoteId())) {
					if(pacote.getItens() == null) {
						pacote.setItens(new ArrayList<ItemAdicionalVO>());
					}
					pacote.getItens().add(itemAdicional);
				}
			}
		}
	}

}