package de.jcpis.analysestats.persistence.hibernate;

import de.jcpis.analysestats.helper.ConversionHelper;
import de.jcpis.analysestats.model.QueryParams;
import de.jcpis.analysestats.model.Sorting;
import de.jcpis.analysestats.model.db.Context;
import de.jcpis.analysestats.persistence.ContextDAO;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.Root;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

/**
 *
 * @author anthonyarents
 */
@Repository
public class ContextDAOImpl implements ContextDAO {

    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public void save(final Context obj) {
        sessionFactory.getCurrentSession().saveOrUpdate(obj);
    }

    @Override
    public void delete(final Context obj) {
        sessionFactory.getCurrentSession().delete(obj);
    }

    @Override
    public Context getById(final Integer id) {
        return sessionFactory.getCurrentSession().get(Context.class, id);
    }

    private void initializeDependencies(final List<Context> list) {
        for (Context obj : list) {
            initializeDependencies(obj);
        }
    }

    private void initializeDependencies(final Context obj) {
        if (obj != null) {
            Hibernate.initialize(obj.getServer());
        }
    }

    private void addFilters(final CriteriaBuilder builder, final Root<Context> root, final CriteriaQuery<?> criteriaQuery, final QueryParams queryParams) {
        final String name = ConversionHelper.toString(queryParams.getFilterValue("name"));

        if (!StringUtils.isEmpty(name)) {
            criteriaQuery.where(builder.like(root.<String>get("name"), name + "%"));
        }
    }

    private void addSorting(final CriteriaBuilder builder, final Root<Context> root, final CriteriaQuery<?> criteriaQuery, final QueryParams queryParams) {
        if (queryParams.getSort().getSortings().isEmpty()) {
            criteriaQuery.orderBy(builder.asc(root.get("name")));
        } else {
            final List<Order> orderList = new ArrayList<Order>();
            for (Sorting s : queryParams.getSort().getSortings()) {
                if ("ASC".equals(s.getDirection())) {
                    orderList.add(builder.asc(root.get(s.getProperty())));
                } else {
                    orderList.add(builder.desc(root.get(s.getProperty())));
                }
            }
            criteriaQuery.orderBy(orderList);
        }
    }

    @Override
    public List<Context> getAll(final QueryParams queryParams) {
        final Session session = sessionFactory.getCurrentSession();
        session.enableFilter("deletedObjectsFilter");

        final CriteriaBuilder builder = session.getCriteriaBuilder();
        final CriteriaQuery<Context> criteriaQuery = builder.createQuery(Context.class);
        final Root<Context> root = criteriaQuery.from(Context.class);
        criteriaQuery.select(root);

        addFilters(builder, root, criteriaQuery, queryParams);
        addSorting(builder, root, criteriaQuery, queryParams);

        final TypedQuery<Context> typedQuery = session.createQuery(criteriaQuery);
        typedQuery.setFirstResult(queryParams.getStart());
        if (queryParams.isLimitted()) {
            typedQuery.setMaxResults(queryParams.getLimit());
        }

        return typedQuery.getResultList();
    }

    @Override
    public Long getCount(final QueryParams queryParams) {
        final Session session = sessionFactory.getCurrentSession();
        session.enableFilter("deletedObjectsFilter");

        final CriteriaBuilder builder = session.getCriteriaBuilder();
        final CriteriaQuery<Long> criteriaQuery = builder.createQuery(Long.class);
        final Root<Context> root = criteriaQuery.from(Context.class);
        criteriaQuery.select(builder.count(root));

        addFilters(builder, root, criteriaQuery, queryParams);

        final TypedQuery<Long> typedQuery = session.createQuery(criteriaQuery);
        return typedQuery.getSingleResult();
    }

}