package com.megatim.fdxconsultation.core.ifaces.abtracts;

import com.megatim.fdxcommons.model.enumeration.TypeOperation;
import com.megatim.fdxcommons.model.pojo.CriteriaEntityFromView;
import com.megatim.fdxcommons.model.pojo.OrderByDefinition;
import com.megatim.fdxconsultation.dao.ifaces.abstracts.CustomDAOWithCriteriaEntityIfaces;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.base.BaseEntity;
import java.util.Date;
import java.util.List;

/**
 *
 * @author ASUS
 * @param <T> : Entite reelle
 * @param <ID> : Classe de l'identifiant
 * @param <U> : entité qui représente un utilisateur
 */
public interface ManagerWithCriteriaEntityIFaces<T extends Object, ID, U> {

    <R extends CustomDAOWithCriteriaEntityIfaces<T, ID>> R getDao();

    default T save(T entity) {
        return getDao().save(entity);
    }

    default T add(T entity, User connectedUser) {
        beforeAdd(entity, connectedUser);

        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) entity;
            baseEntity.setDateCreation(new Date());
            baseEntity.setTypeOperation(TypeOperation.AJOUTER);
            baseEntity.setUtilisateurCreation(connectedUser != null ? connectedUser.getUserName() : null);
        }
        logAfterSave(entity, connectedUser);
        return getDao().save(entity);
    }

    default void delete(ID id, User connectedUser) {
        T entity = getDao().getById(id);
        beforeDelete(entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) entity;
            baseEntity.setDateSuppression(new Date());
            baseEntity.setUtilisateurSuppression(connectedUser != null ? connectedUser.getUserName() : null);
            baseEntity.setTypeOperation(TypeOperation.SUPPRIMER);
            getDao().save(entity);
        } else {
            getDao().delete(entity);
        }
        logAfterDelete(entity, connectedUser);
    }

    default void delete(User connectedUser, T entity) {
        beforeDelete(entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) entity;
            baseEntity.setDateSuppression(new Date());
            baseEntity.setUtilisateurSuppression(connectedUser != null ? connectedUser.getUserName() : null);
            baseEntity.setTypeOperation(TypeOperation.SUPPRIMER);
            getDao().delete(entity);
        } else {
            getDao().delete(entity);
        }
        logAfterDelete(entity, connectedUser);
    }

    public default T getById(ID id) {
        return getDao().getById(id);
    }

    default T update(ID id, T entity, User connectedUser) {
        T refreshEntity = getDao().getById(id);
        beforeUpdate(refreshEntity, entity, connectedUser);
        if (entity instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) refreshEntity;
            baseEntity.setDateDerniereModification(new Date());
            baseEntity.setUtilisateurModification(connectedUser != null ? connectedUser.getUserName() : null);
        }
        logAfterUpdate(entity, connectedUser);
        return getDao().save(refreshEntity);
    }

    public default List<T> findWithPagination(CriteriaEntityFromView criterion, List<String> fetchEagerFields, List<OrderByDefinition> orderByFields, Integer pageNumber, Integer pageSize) throws Exception {
        return getDao().findWithPagination(criterion, fetchEagerFields, orderByFields, pageNumber, pageSize);
    }

    public default List<T> findAll(CriteriaEntityFromView criterion, List<String> fetchEagerFields, List<OrderByDefinition> orderByFields) throws Exception {
        return (List<T>) getDao().findAll(criterion, fetchEagerFields, orderByFields);
    }

    public default Long count(CriteriaEntityFromView criterion) throws Exception {
        return getDao().count(criterion);
    }

    default void beforeAdd(T entity, User connectedUser) {
    }

    default void beforeDelete(T entity, User connectedUser) {
    }

    default void beforeUpdate(T refreshEntity, T entity, User connectedUser) {
    }
    
    public default void logAfterSave(T entity, User connectedUser){}

    public default void logAfterUpdate(T entity, User connectedUser){}

    public default void logAfterDelete(T entity, User connectedUser){}
    
}