/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.fdxconsultation.core.impl.remoteaction;

import com.bekosoftware.genericdaolayer.dao.ifaces.GenericDAO;
import com.bekosoftware.genericdaolayer.dao.tools.RestrictionsContainer;
import com.bekosoftware.genericmanagerlayer.core.impl.AbstractGenericManager;
import com.megatim.fdxcommons.core.ifaces.helper.DataInMemoryHandler;
import com.megatim.fdxcommons.model.dtos.remoteproduction.RemoteConfigurationDto;
import com.megatim.fdxcommons.model.enumeration.RemoteTypeAction;
import com.megatim.fdxcommons.model.enumeration.TypeOperation;
import com.megatim.fdxconsultation.model.remoteaction.RemoteConfiguration;
import com.megatim.fdxconsultation.core.ifaces.helper.RoutingChecker;
import com.megatim.fdxconsultation.core.ifaces.remoteaction.PlanificationManager;
import com.megatim.fdxconsultation.core.ifaces.remoteaction.RemoteConfigurationManager;
import com.megatim.fdxconsultation.dao.ifaces.abstracts.PaginationWithCriteriaEntityDAO;
import com.megatim.fdxconsultation.dao.ifaces.remoteaction.RemoteConfigurationDAO;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
import com.megatim.fdxconsultation.model.remoteaction.Planification;
import com.megatim.fdxconsultation.tools.context.AppCommonContext;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.ejb.EJB;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;
import javax.transaction.Transactional;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.cdi.CdiCamelContext;

/**
 *
 * @author ASUS
 */
@Dependent
public class RemoteConfigurationManagerImpl extends AbstractGenericManager<RemoteConfiguration, String> implements RemoteConfigurationManager {

    @EJB
    private RemoteConfigurationDAO dao;

    @Inject
    private PlanificationManager planificationManager;

    @Inject
    private CdiCamelContext camelContext;

    @Inject
    private MapStructMapper mapStructMapper;

    @Inject
    private RoutingChecker routingChecker;

    @Inject
    private DataInMemoryHandler dataInMemoryHandler;

    @Override
    public GenericDAO<RemoteConfiguration, String> getDao() {
        return dao;
    }

    @Override
    public String getEntityIdName() {
        return "codeTypeFichier";
    }

    @Override
    @Transactional
    public RemoteConfiguration saveAndSend(RemoteConfiguration entity, User connectedUser) {
        if (entity.getRemoteTypeAction().equals(RemoteTypeAction.AJOUTER)) {
            routingChecker.stopIfNotConsumer(entity.getCodeTypeFichier(), dataInMemoryHandler.getDataInMemory(), entity.getCodeParticipant());
        }
        if (entity.getRemoteTypeAction().equals(RemoteTypeAction.CONSULTER)) {
            routingChecker.stopIfNotProducer(entity.getCodeTypeFichier(), dataInMemoryHandler.getDataInMemory(), entity.getCodeParticipant());
        }
        RemoteConfiguration newEntity = add(entity, connectedUser);
        System.out.println("****************after save************* " + newEntity.getCodeTypeFichier());

        for (Planification p : newEntity.getPlanifications()) {
            p.setConfiguration(newEntity);
            planificationManager.update(p.getId(), p);
        }
        RemoteConfiguration finalEntity = find(getEntityIdName(), newEntity.getCodeTypeFichier());
        System.out.println("NB Planifications = " + finalEntity.getPlanifications().size());

        sendMessage(mapStructMapper.remoteConfigurationToRemoteConfigurationDto(finalEntity));

        return finalEntity;
    }

    @Override
    public RemoteConfiguration updateAndSend(String id, RemoteConfiguration entity, User connectedUser) {
        RemoteConfiguration newEntity = modify(id, entity, connectedUser);
        sendMessage(mapStructMapper.remoteConfigurationToRemoteConfigurationDto(newEntity));

        return newEntity;
    }

    @Override
    public void deleteAndSend(String id, User connectedUser) {
        RemoteConfiguration entity = find(getEntityIdName(), id);

        if (entity != null) {
            entity.setTypeOperation(TypeOperation.SUPPRIMER);
            delete(id);
            sendMessage(mapStructMapper.remoteConfigurationToRemoteConfigurationDto(entity));
        }
    }

    @Override
    public PaginationWithCriteriaEntityDAO<RemoteConfiguration, String> paginationWithCriteriaEntityDAO() {
        return dao;
    }

    @Override
    public void beforeAdd(RemoteConfiguration entity, User connectedUser) {
        Date dateAction = new Date();
        entity.setUtilisateurCreation(connectedUser.getUserName());
        entity.setDateCreation(dateAction);

        entity.getPlanifications().stream().forEach(p -> {
            p.setUtilisateurCreation(connectedUser.getUserName());
            p.setDateCreation(dateAction);
        });
    }

    @Override
    public void beforeRemove(RemoteConfiguration entity, User connectedUser) {
    }

    @Override
    public void beforeModify(RemoteConfiguration actualEntity, RemoteConfiguration requestEntity, User connectedUser) {
        Date dateAction = new Date();
        actualEntity.setUtilisateurModification(connectedUser.getUserName());
        actualEntity.setDateDerniereModification(dateAction);
        actualEntity.setUrl(requestEntity.getUrl());
        actualEntity.setRemoteTypeAction(requestEntity.getRemoteTypeAction());
        actualEntity.setPlanifications(requestEntity.getPlanifications());

        actualEntity.getPlanifications().stream().forEach(p -> {
            p.setUtilisateurModification(connectedUser.getUserName());
            p.setDateDerniereModification(dateAction);
        });
    }

    @Override
    public RemoteConfigurationDto mapToDto(RemoteConfiguration entity) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public RemoteConfigurationDto mapToDetailDto(RemoteConfiguration entity) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    @Override
    public RestrictionsContainer construireRequete(User searchEntity, TypeOperation typeOperation) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    private void sendMessage(RemoteConfigurationDto configDto) {
        ProducerTemplate producerTemplate = camelContext.createProducerTemplate();
        producerTemplate.sendBodyAndHeaders("direct:" + AppCommonContext.REMOTE_CONGIGURATION_DIRECT, configDto, headers());
    }

    private Map<String, Object> headers() {
        Map<String, Object> headers = new HashMap<>();
        headers.put("CamelRabbitmqDeliveryMode", 2);//pour permettre au message de rester dans la file même après redémarrage

        return headers;
    }
}