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

import com.megatim.fdxcommons.dao.ifaces.abstracts.AbstractCrudDAO;
import com.megatim.fdxcommons.model.enumeration.TypeOperation;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.base.BaseEntity;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 *
 * @author ASUS
 * @param <T> : Entite reelle
 * @param <K> : Dto
 * @param <ID> : Classe de l'identifiant
 * @param <S> : entité de recherche
 */
public interface AbstractCrudManager<T extends Object, K, ID, S> {

    <R extends AbstractCrudDAO<T, ID, S>> R getDao();

    K mapToDto(T 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);
        }
        return getDao().save(entity);
    }

    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);
        }
        return getDao().save(refreshEntity);
    }

    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);
        }
    }

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

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

    void beforeUpdate(T refreshEntity, T entity, User conncectedUser);

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

    public default List<K> findWithPagination(int pageNumber, int pagesize, S searchEntity, User connectedUser) {
        return getDao().findWithPagination(pageNumber, pagesize, searchEntity)
                .stream()
                .map(t -> mapToDto(t))
                .collect(Collectors.toList());
    }

    public default List<K> getAll(S searchEntity, User connectedUser) {
        return getDao().getAll(searchEntity)
                .stream()
                .map(t -> mapToDto(t))
                .collect(Collectors.toList());
    }

    public default Long count(S searchEntity) {
        return getDao().count(searchEntity);
    }
}