/*
    * Copyright 2001-2008 The Apache Software Foundation.
    * 
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
    * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   */
  
  package org.apache.juddi.query;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.persistence.EntityManager;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.juddi.query.util.DynamicQuery;
  import org.apache.juddi.query.util.FindQualifiers;
  import org.uddi.api_v3.CategoryBag;
  import org.uddi.api_v3.KeyedReference;
  
  /**
   * Returns the list of "entity" keys possessing the keyedReferences passed in or the level below.
   * For findBusiness queries, this means keyedReferences on the businessEntity and service levels,
   * and for findService queries this means keyedReferences on the service and serviceBinding level.
   * 
   * Output is restricted by list of "entity" keys passed in.  If null, all entities are searched.
   * Output is produced by building the appropriate JPA query based on input and find qualifiers.
   * 
   * From the spec : 
   * 
   *  * From specification:
   * "combineCategoryBags:  this may only be used in the find_business and find_service calls.  In the case of 
   * find_business, this qualifier makes the categoryBag entries for the full businessEntity element behave as though all 
   * categoryBag elements found at the businessEntity level and in all contained or referenced businessService elements 
   * and bindingTemplate elements were combined.  Searching for a category will yield a positive match on a registered 
   * business if any of the categoryBag elements contained within the full businessEntity element (including the 
   * categoryBag elements within contained or referenced businessService elements or bindingTemplate elements) 
   * contains the filter criteria.  In the case of find_service, this qualifier makes the categoryBag entries 
   * for the full businessService element behave as though all categoryBag elements found at the businessService level 
   * and in all contained or referenced elements in the bindingTemplate elements were combined.  Searching for a category 
   * will yield a positive match on a registered service if any of the categoryBag elements contained within the 
   * full businessService element (including the categoryBag elements within contained or referenced bindingTemplate 
   * elements) contains the filter criteria. This find qualifier does not cause the keyedReferences in categoryBags 
   * to be combined with the keyedReferences in keyedReferenceGroups in categoryBags when performing the comparison.  
   * The keyedReferences are combined with each other, and the keyedReferenceGroups are combined with each other."
   * 
   * 
   * NOTES:
   * 1) Categories are grouped with a logical AND by default.
   * 2) Concerning when the categories are AND'd together - the only way this can be done with a single query was to create a self-join for 
   *    each category.  If there are a lot of categories, the performance could suffer.
   *    TODO:  Test performance with multiple AND'd categories.  If too slow, look to process this query in multiple steps.
   * 3) The "orLikeKeys" qualifier complicates matters.  The "like" keys are OR'd together and these groups of "like" keys are AND'd together.
   *    As with "andAllKeys", self-joins are created but only one for each group of "like" keys.  If none of the keyedReferences passed are alike then this
   *    will reduce to an "andAllKeys" query.  If all are alike, then this will query will exhibit the behavior of OR'ing all keys.
   * 
   * @author <a href="mailto:jfaath@apache.org">Jeff Faath</a>
   * @author <a href="mailto:tcunning@apache.org">Tom Cunningham</a>
   * @author <a href="mailto:kstam@apache.org">Kurt Stam</a>
   */
  public class FindEntityByCombinedCategoryQuery extends FindEntityByCategoryQuery {
  	
  	@SuppressWarnings("unused")
  	private final static Log log = LogFactory.getLog(FindEntityByCombinedCategoryQuery.class);
  	
  	protected String entityField2;
  	protected String entityNameChild2;
  	protected String entityAliasChild2;
  	
  	protected String entityField3;
  	protected String entityNameChild3;
  	protected String entityAliasChild3;
  	
  
  	public FindEntityByCombinedCategoryQuery(String entityName, String entityAlias, String keyName,
  			String entityField, String entityNameChild, String signaturePresent) {
  		super(entityName, entityAlias, keyName, entityField, entityNameChild, signaturePresent);
  	}
  	
  	public FindEntityByCombinedCategoryQuery(String entityName, String entityAlias, String keyName, 
  			String entityField, String entityNameChild,
  			String entityField2, String entityNameChild2, String entityField3, String entityNameChild3,
  			String signaturePresent) {
  		super(entityName, entityAlias, keyName, entityField, entityNameChild, signaturePresent);
 		
 		this.entityNameChild2 = entityNameChild2;
 		this.entityAliasChild2 = buildAlias(entityNameChild2);
 		this.entityField2 = entityField2;
 		if (entityNameChild3!=null) {
 			this.entityField3 = entityField3;
 			this.entityNameChild3 = entityNameChild3;
 			this.entityAliasChild3 = buildAlias(entityNameChild3);
 		}
 		this.signaturePresent = signaturePresent;
 		selectSQL = "";
 	}
 	
 	public String getEntityNameChild2() {
 		return entityNameChild2;
 	}
 	
 	public String getEntityAliasChild2() {
 		return entityAliasChild2;
 	}
 	
 	public String getEntityNameChild3() {
 		return entityNameChild3;
 	}
 	
 	public String getEntityAliasChild3() {
 		return entityAliasChild3;
 	}
 		
 	public List<Object> select(EntityManager em, FindQualifiers fq, CategoryBag categoryBag, 
 			List<Object> keysIn, DynamicQuery.Parameter... restrictions) {
 	        
         // If keysIn is not null and empty, then search is over.
 		if ((keysIn != null) && (keysIn.size() == 0))
 			return keysIn;
 		
 		if (categoryBag == null)
 			return keysIn;
 		
 		List<KeyedReference> keyRefsInCategories = categoryBag.getKeyedReference();
 		if (keyRefsInCategories == null || keyRefsInCategories.size() == 0)
 			return keysIn;
 		
 		Map<KeyedReference,Set<String>> map  = new HashMap<KeyedReference,Set<String>>();
 		//1. First match at the top level (i.e. categoryBag on business)
 		findEntityByCategoryQuery(map, em, fq, categoryBag, entityField, entityNameChild, keysIn, restrictions);
 		//2. Now match at the second level (i.e. categoryBag on services for businesses)
 		findEntityByCategoryQuery(map, em, fq, categoryBag, entityField2, entityNameChild2, keysIn, restrictions);
 		//3. Now match at the third level (i.e. categoryBag on binding for businesses)
 		//   This does only apply to businesses (not for services)
 		if (entityNameChild3!=null) {
 			findEntityByCategoryQuery(map, em, fq, categoryBag, entityField3, entityNameChild3, keysIn, restrictions);
 		}
 		
 		//Now build the results taking into account AND/OR/LIKE
 		Set<String> resultingEntityKeys = new HashSet<String>();
 		if (fq.isOrAllKeys()) {
 			//in this case get ALL businessKeys
 			for (KeyedReference keyRef: map.keySet()) {
 				resultingEntityKeys.addAll(map.get(keyRef));
 			}
 		} else if (fq.isOrLikeKeys()) {
 			// any keyedReference filters that come from the same namespace (e.g. have the same tModelKey value) 
 			// are OR’d together rather than AND’d
 			// 1. OR if we have keys with similar namespaces (keyValue)
 			Map<String,Set<String>> likeMap  = new HashMap<String,Set<String>>();
 			for (KeyedReference keyRef: map.keySet()) {
 				String keyValue = keyRef.getKeyValue();
 				if (likeMap.containsKey(keyValue)) {
 					likeMap.get(keyValue).addAll(map.get(keyRef));
 				} else {
 					likeMap.put(keyValue, map.get(keyRef));
 				}
 			}
 			// 2. Now AND the likeMap
 			boolean firstTime = true;
 			for (String keyValue: likeMap.keySet()) {
 				if (firstTime) {
 					resultingEntityKeys = map.get(keyValue);
 					firstTime = false;
 				} else {
                                         //FIXME this is wrong
 					resultingEntityKeys.retainAll(map.get(keyValue));
 				}
 			}
 		} else {
 			// AND keys by default, in this case each entity (business or service)
 			// needs to have ALL keys
 			boolean firstTime = true;
 			for (KeyedReference keyRef: map.keySet()) {
 				if (firstTime) {
 					resultingEntityKeys = map.get(keyRef);
 					firstTime = false;
 				} else {
 					resultingEntityKeys.retainAll(map.get(keyRef));
 				}
 			}
 		}
 		return new ArrayList<Object>(resultingEntityKeys);
 	}
 	/**
 	 * Finding the entities (businesses or services) that have a matching keyedReference in their
 	 * categoryBag.
 	 * 
 	 * @param map - result map of keyedReference and matching businesses
 	 * @param em
 	 * @param fq
 	 * @param categoryBag
 	 * @param entityField
 	 * @param entityNameChild
 	 * @param keysIn
 	 * @param restrictions
 	 */
 	private void findEntityByCategoryQuery(Map<KeyedReference,Set<String>> map, EntityManager em, 
 			FindQualifiers fq, CategoryBag categoryBag, String entityField, String entityNameChild, 
 			List<Object> keysIn, DynamicQuery.Parameter... restrictions) 
 	{
 		FindEntityByCategoryQuery findEntityByCategoryQuery = new FindEntityByCategoryQuery(
 				entityName, entityAlias, keyName, entityField, entityNameChild, signaturePresent);
 		for (KeyedReference keyedReference : categoryBag.getKeyedReference()) {
 			CategoryBag categoryBagWithOneKey = new CategoryBag();
 			categoryBagWithOneKey.getKeyedReference().add(keyedReference);
 			List<?> entityKeys =  findEntityByCategoryQuery.select(
 					em, fq, categoryBagWithOneKey, keysIn, restrictions);
 			@SuppressWarnings({ "unchecked", "rawtypes" })
 			Set<String> keySet = new HashSet(entityKeys);
 			if (map.containsKey(keyedReference)) {
 				map.get(keyedReference).addAll(keySet);
 			} else {
 				map.put(keyedReference, keySet);
 			}
 		}
 	}
 	
 }