package eu.eudat.queryable.hibernatequeryablelist;


import eu.eudat.entities.DataEntity;
import eu.eudat.queryable.QueryableList;
import eu.eudat.queryable.exceptions.NotSingleResultException;
import eu.eudat.queryable.predicates.NestedQuerySinglePredicate;
import eu.eudat.queryable.predicates.OrderByPredicate;
import eu.eudat.queryable.predicates.SelectPredicate;
import eu.eudat.queryable.predicates.SinglePredicate;
import eu.eudat.queryable.types.FieldSelectionType;
import eu.eudat.queryable.types.SelectionField;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.*;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

public class QueryableHibernateList<T extends DataEntity> implements QueryableList<T> {

    private EntityManager manager;
    private CriteriaQuery<T> query;
    private Class<T> tClass;
    private Root<T> root;
    private Root<T> nestedQueryRoot;
    private Subquery<T> subquery;
    private List<SinglePredicate<T>> singlePredicates = new LinkedList<>();
    private List<NestedQuerySinglePredicate<T>> nestedPredicates = new LinkedList<>();

    private List<OrderByPredicate<T>> orderings = new LinkedList<>();
    private List<String> fields = new LinkedList<>();
    private Integer length;
    private Integer offset;
    private Set<String> hints;
    private String hint;

    public QueryableHibernateList(EntityManager manager, Class<T> tClass) {
        this.manager = manager;
        this.tClass = tClass;
    }

    public QueryableHibernateList<T> setManager(EntityManager manager) {
        this.manager = manager;
        return this;
    }

    public QueryableList<T> withHint(String hint) {
        this.hint = hint;
        return this;
    }

    public QueryableList<T> setHints(Set<String> hints) {
        this.hints = hints;
        return this;
    }

    @Override
    public QueryableList<T> withFields(List<String> fields) {
        this.fields = fields;
        return this;
    }

    private QueryableList<T> selectFields() {
        List<Selection> rootFields = fields.stream().map(field -> root.get(field)).collect(Collectors.toList());
        this.query.select(this.manager.getCriteriaBuilder().construct(tClass, rootFields.toArray(new Selection[rootFields.size()])));
        return this;
    }

    public QueryableHibernateList<T> setEntity(Class<T> type) {
        CriteriaBuilder builder = this.manager.getCriteriaBuilder();
        this.query = builder.createQuery(type);
        this.root = this.query.from(this.tClass);
        return this;
    }

    public void initiateQueryableList(Class<T> type) {
        CriteriaBuilder builder = this.manager.getCriteriaBuilder();
        this.query = builder.createQuery(type);
    }

    @Override
    public QueryableList<T> skip(Integer offset) {
        this.offset = offset;
        return this;
    }

    @Override
    public QueryableList<T> take(Integer length) {
        this.length = length;
        return this;
    }

    public QueryableList<T> where(SinglePredicate<T> predicate) {
        this.singlePredicates.add(predicate);
        return this;
    }

    public QueryableList<T> where(NestedQuerySinglePredicate<T> predicate) {
        this.nestedPredicates.add(predicate);
        return this;
    }

    public <R> List<R> select(SelectPredicate<T, R> predicate) {
        return this.toList().stream().map(item -> predicate.applySelection(item)).collect(Collectors.toList());
    }

    public <R> CompletableFuture<List<R>> selectAsync(SelectPredicate<T, R> predicate) {
        return this.toListAsync().thenApplyAsync(items -> items.stream().map(item -> predicate.applySelection(item)).collect(Collectors.toList()));
    }

    public QueryableList<T> distinct() {
        this.query.distinct(true);
        return this;
    }

    public QueryableList<T> orderBy(OrderByPredicate<T> predicate) {
        this.orderings.add(predicate);
        return this;
    }

    public Long count() {
        CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
        CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
        Root<T> root = criteriaQuery.from(tClass);
        criteriaQuery.select(criteriaBuilder.count(root));
        criteriaQuery.where(this.generateWherePredicates(this.singlePredicates, root, this.nestedPredicates, this.nestedQueryRoot));
        return this.manager.createQuery(criteriaQuery).getSingleResult();
    }

    public CompletableFuture<Long> countAsync() {
        CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
        CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
        Root<T> root = criteriaQuery.from(tClass);
        criteriaQuery.select(criteriaBuilder.count(root));
        criteriaQuery.where(this.generateWherePredicates(this.singlePredicates, root, this.nestedPredicates, this.nestedQueryRoot));
        return CompletableFuture.supplyAsync(() -> this.manager.createQuery(criteriaQuery).getSingleResult());
    }


    private Predicate[] generateWherePredicates(List<SinglePredicate<T>> singlePredicates, Root<T> root, List<NestedQuerySinglePredicate<T>> nestedPredicates, Root<T> nestedQueryRoot) {
        List<Predicate> predicates = new LinkedList<>();
        predicates.addAll(Arrays.asList(this.generateSingleWherePredicates(singlePredicates, root)));
        predicates.addAll(Arrays.asList(this.generateNestedWherePredicates(nestedPredicates, root, nestedQueryRoot)));
        return predicates.toArray(new Predicate[predicates.size()]);
    }

    private Predicate[] generateSingleWherePredicates(List<SinglePredicate<T>> singlePredicates, Root<T> root) {
        List<Predicate> predicates = new LinkedList<>();
        for (SinglePredicate<T> singlePredicate : singlePredicates) {
            predicates.add(singlePredicate.applyPredicate(this.manager.getCriteriaBuilder(), root));
        }
        return predicates.toArray(new Predicate[predicates.size()]);
    }

    private Predicate[] generateNestedWherePredicates(List<NestedQuerySinglePredicate<T>> nestedPredicates, Root<T> root, Root<T> nestedQueryRoot) {
        List<Predicate> predicates = new LinkedList<>();
        for (NestedQuerySinglePredicate<T> singlePredicate : nestedPredicates) {
            predicates.add(singlePredicate.applyPredicate(this.manager.getCriteriaBuilder(), root, nestedQueryRoot));
        }
        return predicates.toArray(new Predicate[predicates.size()]);
    }

    private Order[] generateOrderPredicates(List<OrderByPredicate<T>> orderByPredicates, Root<T> root) {
        List<Order> predicates = new LinkedList<>();
        for (OrderByPredicate<T> orderPredicate : orderByPredicates) {
            predicates.add(orderPredicate.applyPredicate(this.manager.getCriteriaBuilder(), root));
        }
        return predicates.toArray(new Order[predicates.size()]);
    }

    public List<T> toList() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (!this.orderings.isEmpty()) this.query.orderBy(this.generateOrderPredicates(this.orderings, this.root));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.offset != null) typedQuery.setFirstResult(this.offset);
        if (this.length != null) typedQuery.setMaxResults(this.length);
        if (this.hint != null && this.hints.contains(hint)) {
            List ids = typedQuery.getResultList().stream().map(item -> item.getKeys()).collect(Collectors.toList());
            if (ids != null && !ids.isEmpty()) typedQuery = queryWithHint(ids);
        }
        return typedQuery.getResultList();
    }

    public CompletableFuture<List<T>> toListAsync() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (!this.orderings.isEmpty()) this.query.orderBy(this.generateOrderPredicates(this.orderings, this.root));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.offset != null) typedQuery.setFirstResult(this.offset);
        if (this.length != null) typedQuery.setMaxResults(this.length);
        return CompletableFuture.supplyAsync(() -> {
            if (this.hint != null && this.hints.contains(hint)) {
                List ids = typedQuery.getResultList().stream().map(item -> item.getKeys()).collect(Collectors.toList());
                if (ids != null && !ids.isEmpty()) return queryWithHint(ids).getResultList();
            }
            return typedQuery.getResultList();
        });
    }

    public T getSingle() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.hint != null)
            typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
        return typedQuery.getSingleResult();
    }

    public CompletableFuture<T> getSingleAsync() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.hint != null)
            typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
        return CompletableFuture.supplyAsync(() -> typedQuery.getSingleResult());
    }

    public T getSingleOrDefault() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.hint != null)
            typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
        List<T> results = typedQuery.getResultList();
        if (results.size() == 0) return null;
        if (results.size() == 1) return results.get(0);
        else throw new NotSingleResultException("Query returned more than one items");
    }

    public CompletableFuture<T> getSingleOrDefaultAsync() {
        this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
        if (this.fields != null && !this.fields.isEmpty()) this.selectFields();
        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if (this.hint != null)
            typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
        return CompletableFuture.supplyAsync(() -> typedQuery.getResultList()).thenApply(list -> {
            if (list.size() == 0) return null;
            if (list.size() == 1) return list.get(0);
            else throw new NotSingleResultException("Query returned more than one items");
        });
    }

    private TypedQuery<T> queryWithHint(List ids) {
        CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
        CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(tClass);
        Root<T> criteriaRoot = criteriaQuery.from(this.tClass);
        criteriaQuery.where(criteriaRoot.get("id").in(ids));
        if (!this.orderings.isEmpty())
            criteriaQuery.orderBy(this.generateOrderPredicates(this.orderings, criteriaRoot));

        TypedQuery<T> typedQuery = this.manager.createQuery(criteriaQuery);
        typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
        return typedQuery;
    }

    @Override
    public Subquery<T> subQuery(SinglePredicate<T> predicate, List<SelectionField> fields) {
        Subquery<T> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(this.tClass);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
        subquery.select(this.nestedQueryRoot.get(fields.get(0).getField()));
        return subquery;
    }

    @Override
    public Subquery<T> subQuery(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields) {
        Subquery<T> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(this.tClass);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
        subquery.select(this.nestedQueryRoot.get(fields.get(0).getField()));
        return subquery;
    }

    @Override
    public Subquery<Long> subQueryCount(SinglePredicate<T> predicate, List<SelectionField> fields) {
        Subquery<Long> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(Long.class);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
        subquery.select(this.manager.getCriteriaBuilder().count(this.nestedQueryRoot.get(fields.get(0).getField())));
        return subquery;
    }

    @Override
    public Subquery<Long> subQueryCount(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields) {
        Subquery<Long> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(Long.class);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
        subquery.select(this.manager.getCriteriaBuilder().count(this.nestedQueryRoot.get(fields.get(0).getField())));
        return subquery;
    }

    @Override
    public <U extends Comparable> Subquery<U> subQueryMax(SinglePredicate<T> predicate, List<SelectionField> fields, Class<U> uClass) {
        Subquery<U> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(uClass);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
        if (fields.get(0).getType() == FieldSelectionType.FIELD)
            subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.<U>get(fields.get(0).getField())));
        else if (fields.get(0).getType() == FieldSelectionType.COMPOSITE_FIELD) {
            subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.get(fields.get(0).getField().split(":")[0]).<U>get(fields.get(0).getField().split(":")[1])));
        }
        return subquery;
    }

    @Override
    public <U extends Comparable> Subquery<U> subQueryMax(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields, Class<U> uClass) {
        Subquery<U> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(uClass);
        this.nestedQueryRoot = subquery.from(this.tClass);
        subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
        if (fields.get(0).getType() == FieldSelectionType.FIELD)
            subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.<U>get(fields.get(0).getField())));
        else if (fields.get(0).getType() == FieldSelectionType.COMPOSITE_FIELD) {
            subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.get(fields.get(0).getField().split(":")[0]).<U>get(fields.get(0).getField().split(":")[1])));
        }
        return subquery;
    }
}