package com.project.repo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public abstract class RefineableDao {
	private final Map<String,Refinement> allowedRefinements = new HashMap<String,Refinement>();

	protected enum RefineType{
		STRING,
		LIST,
		GREATER,
		LESSER,
	}

	public class Refinement{
		protected final String field;
		protected final RefineType enumType;

		public Refinement(final String field, final RefineType enumType){
			this.field = field;
			this.enumType = enumType;
		}

		public RefineType getEnum(){
			return enumType;
		}

		public String getField(){
			return field;
		}
	}

	/**
	 * Create refined query with unspecified root.
	 * @param refine
	 * @param cb
	 * @param query
	 * @param cls
	 * @return
	 */
	@SuppressWarnings("unchecked")
	protected <T> Predicate refineQuery(final Map<String,Object> refine, final CriteriaBuilder cb, final CriteriaQuery<T> query, final Class<T> cls){
		Root<T> root = null;
		for(Root<?> tempRoot : query.getRoots()){
			//Check if a root already exists for incoming class. Assume we're intending to refine that one.
			if(tempRoot.getJavaType().equals(cls)){
				root = (Root<T>)tempRoot;
				break;
			}
		}
		if(root == null){
			//Create new root.
			root = query.from(cls);
		}
		return this.refineQuery(refine, cb, query, root);
	}

	/**
	 * Create refined query with specified root.
	 * @param refine
	 * @param cb
	 * @param query
	 * @param root
	 * @return
	 */
	@SuppressWarnings("unchecked")
	protected <T> Predicate refineQuery(final Map<String,Object> refine, final CriteriaBuilder cb, final CriteriaQuery<T> query, final Root<?> root){
		Predicate predicate = cb.conjunction();
		for(String key : refine.keySet()){
			Object refineObj = refine.get(key);
			Object[] iterable;
			//Convert to an array of objects. Make sure it's iterable.
			if(allowedRefinements.get(key).getEnum() != RefineType.LIST && refineObj instanceof Collection){
				iterable = ((Collection<Object>)refineObj).toArray();
			}else if(refineObj instanceof Object[]){
				iterable = (Object[])refineObj;
			}else{
				iterable = new Object[]{refineObj};
			}
			for(Object obj : iterable){
				Refinement refinement = allowedRefinements.get(key);

				switch(allowedRefinements.get(key).getEnum()){
				case STRING:
					Expression<String> path = root.get(refinement.getField());
					//Lower case to make searching case insensitive.
					path = cb.lower(path);
					predicate = cb.and(predicate,cb.like(path, "%".concat(((String)obj).toLowerCase()).concat("%")));
					break;
				case LIST:
					String[] fields = refinement.getField().split("\\.");
					if(fields.length == 0){
						fields = new String[]{refinement.getField()};
					}
					Path<?> pathList = null;
					for(String field : fields){
						pathList = pathList == null ? root.get(field) : pathList.get(field);
					}
					predicate = cb.and(predicate,pathList.in(obj));
					break;
				case GREATER:
					Expression<Double> pathNum = root.get(refinement.getField());
					predicate = cb.and(predicate,cb.greaterThanOrEqualTo(pathNum, Double.parseDouble(obj.toString())));
					break;
				case LESSER:
					pathNum = root.get(refinement.getField());
					predicate = cb.and(predicate,cb.lessThanOrEqualTo(pathNum, Double.parseDouble(obj.toString())));
					break;
				}
			}
		}
		return predicate;
	}

	public Map<String, Refinement> getAllowedRefinements() {
		return allowedRefinements;
	}
}