/*
    * 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.model;
  
  import java.util.List;
  import java.util.StringTokenizer;
  import java.util.Vector;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.persistence.Column;
  import javax.persistence.EntityManager;
  import javax.persistence.Id;
  import javax.persistence.MappedSuperclass;
  import javax.persistence.Query;
  import javax.persistence.Transient;
  import org.apache.juddi.config.AppConfig;
  import org.apache.juddi.config.Property;
  
  import org.apache.juddi.keygen.KeyGenerator;
  import org.apache.juddi.query.util.DynamicQuery;
  import org.apache.juddi.validation.ValidateUDDIKey;
  import org.uddi.v3_service.DispositionReportFaultMessage;
  
  /**
   * @author <a href="mailto:jfaath@apache.org">Jeff Faath</a>
   */
  @MappedSuperclass
  public class UddiEntityPublisher {
  	
          private transient static final Logger logger = Logger.getLogger(UddiEntityPublisher.class.getCanonicalName());
  	protected String authorizedName;
  	private List<String> keyGeneratorKeys = null;
  
  	public UddiEntityPublisher() {
  	}
  	
  	public UddiEntityPublisher(String authorizedName) {
  		this.authorizedName = authorizedName;
  	}
  	
  	@Id
  	@Column(name = "authorized_name", nullable = false, length = 255)
  	public String getAuthorizedName() {
  		return this.authorizedName;
  	}
  	public void setAuthorizedName(String authorizedName) {
  		this.authorizedName = authorizedName;
  	}
  	
  	@Transient
  	public List<String> getKeyGeneratorKeys() {
  		return keyGeneratorKeys;
  	}
  	public void setKeyGeneratorKeys(List<String> keyGeneratorKeys) {
  		this.keyGeneratorKeys = keyGeneratorKeys;
  	}
  
  	@SuppressWarnings("unchecked")
  	public void populateKeyGeneratorKeys(EntityManager em) {
  		DynamicQuery getKeysQuery = new DynamicQuery();
  		getKeysQuery.append("select t.entityKey from Tmodel t").pad().WHERE().pad();
  
  		DynamicQuery.Parameter pubParam = new DynamicQuery.Parameter("t.authorizedName", 
  				 getAuthorizedName(), 
  				 DynamicQuery.PREDICATE_EQUALS);
  
  		DynamicQuery.Parameter keyParam = new DynamicQuery.Parameter("UPPER(t.entityKey)", 
  				 (DynamicQuery.WILDCARD + KeyGenerator.KEYGENERATOR_SUFFIX).toUpperCase(), 
  				 DynamicQuery.PREDICATE_LIKE);
  		
  		
  		getKeysQuery.appendGroupedAnd(pubParam, keyParam);
  		Query qry = getKeysQuery.buildJPAQuery(em);
  		
  		keyGeneratorKeys = qry.getResultList();
  	}
  	
          /**
           * Determines if *this publisher owns a specific key
           * @param entity
           * @return true/false
           */
  	public boolean isOwner(UddiEntity entity){
             try {
                 AppConfig instance = AppConfig.getInstance();
 
                 if (entity != null) {
                     if (entity.getAuthorizedName().equals(getAuthorizedName())
                             && entity.getNodeId().equals((AppConfig.getConfiguration().getString(Property.JUDDI_NODE_ID)))) {
                         return true;
                     }
                 }
             } catch (Exception ex) {
                 logger.log(Level.WARNING, "Error caught determining node id! Defaulting to access denied", ex);
             }
             return false;
 	}
 
 	
 	public boolean isValidPublisherKey(EntityManager em, String key) {
 		if (key == null)
 			return false;
 		
 		if (keyGeneratorKeys == null)
 			populateKeyGeneratorKeys(em);
 		
 		if (! key.contains(KeyGenerator.PARTITION_SEPARATOR)) return true; //v2 style key
 		String keyPartition = key.substring(0, key.lastIndexOf(KeyGenerator.PARTITION_SEPARATOR));
 		
 		for (String keyGenKey : keyGeneratorKeys) {
 			String keyGenPartition = keyGenKey.substring(0, keyGenKey.lastIndexOf(KeyGenerator.PARTITION_SEPARATOR));
 			if (keyGenPartition.equalsIgnoreCase(keyPartition))
 				return true;
 		}
 		return false;
 	}
 	
 	/*
 	 * This method will check if the given key generator key is available for this publisher.  The idea is to make sure that the key generator
 	 * and all its sub-partitions are not already taken by another publisher.
 	 */
 	public boolean isKeyGeneratorAvailable(EntityManager em, String keygenKey) throws DispositionReportFaultMessage {
 
 		// First make sure the key is a valid UDDIv3 key per the specification's rules
 		ValidateUDDIKey.validateUDDIv3KeyGeneratorKey(keygenKey);
 		
 		String partition = keygenKey.toUpperCase().substring(0, keygenKey.lastIndexOf(KeyGenerator.PARTITION_SEPARATOR));
 		
 		StringTokenizer tokenizer = new StringTokenizer(partition, KeyGenerator.PARTITION_SEPARATOR);
 		int tokenCount = tokenizer.countTokens();
 		// Must have 2 or more tokens as the first is the uddi scheme and the second is the domain key.
 		if (tokenCount < 2)
 			return false;
 
 		String domainPartition = (String)tokenizer.nextElement() + KeyGenerator.PARTITION_SEPARATOR + (String)tokenizer.nextElement();
 		
 		// If three or more tokens then we need to make sure the current publisher has the parent partitions.  For example, you can't register the 
 		// uddi:domain:abc:123 key generator without having the uddi:domain and uddi:domain:abc key generators.  This implicitly checks if another
 		// publisher has any of these partitions since if they do, current publisher won't have them.
 		if (tokenCount > 2) {
 			Vector<DynamicQuery.Parameter> params = new Vector<DynamicQuery.Parameter>(0);
 
 			DynamicQuery.Parameter pubParam = new DynamicQuery.Parameter("t.authorizedName", 
 					 getAuthorizedName(), 
 					 DynamicQuery.PREDICATE_EQUALS);
 			
 			int requiredCount = 0;
 			params.add(new DynamicQuery.Parameter("UPPER(t.entityKey)", 
 					(domainPartition + KeyGenerator.PARTITION_SEPARATOR + KeyGenerator.KEYGENERATOR_SUFFIX).toUpperCase(), 
 					DynamicQuery.PREDICATE_EQUALS));
 			requiredCount++;
 			
 			String subPartition = domainPartition;
 			while (tokenizer.hasMoreElements()) {
 				// Don't need to add the last token as it is the proposed key generator.
 				if (tokenizer.countTokens() == 1)
 					break;
 
 				String nextToken = (String)tokenizer.nextElement();
 				subPartition = subPartition + KeyGenerator.PARTITION_SEPARATOR + nextToken;
 				DynamicQuery.Parameter param = new DynamicQuery.Parameter("UPPER(t.entityKey)", 
 						(subPartition + KeyGenerator.PARTITION_SEPARATOR + KeyGenerator.KEYGENERATOR_SUFFIX).toUpperCase(), 
 						DynamicQuery.PREDICATE_EQUALS);
 				params.add(param);
 				requiredCount++;
 			}
 			
 			DynamicQuery checkParentKeyQry = new DynamicQuery();
 			checkParentKeyQry.append("select COUNT(t.entityKey) from Tmodel t").pad();
 
 			checkParentKeyQry.WHERE().pad().appendGroupedAnd(pubParam);
 			checkParentKeyQry.AND().pad().appendGroupedOr(params.toArray(new DynamicQuery.Parameter[0]));
 			
 			Query qry = checkParentKeyQry.buildJPAQuery(em);			
 			Number resultCount = (Number)qry.getSingleResult();
 			if (resultCount.longValue() != requiredCount)
 				return false;
 		}
 		else {
 			// If only two tokens, then a domain key generator is being checked.  A domain key generator can only be registered if no other publishers
 			// own it.  For example, if trying to register the uddi:domain:abc:123 key then uddi:domain cannot be owned by another publisher.
 			DynamicQuery.Parameter notPubParam = new DynamicQuery.Parameter("t.authorizedName", 
 					 getAuthorizedName(), 
 					 DynamicQuery.PREDICATE_NOTEQUALS);
 
 			DynamicQuery.Parameter keyParam = new DynamicQuery.Parameter("UPPER(t.entityKey)", 
 					(domainPartition + KeyGenerator.PARTITION_SEPARATOR + KeyGenerator.KEYGENERATOR_SUFFIX).toUpperCase(), 
 					DynamicQuery.PREDICATE_EQUALS);
 			
 			DynamicQuery checkDomainKeyQry = new DynamicQuery();
 			checkDomainKeyQry.append("select t.entityKey from Tmodel t").pad();
 			
 			checkDomainKeyQry.WHERE().pad().appendGroupedAnd(notPubParam, keyParam);
 
 			Query qry = checkDomainKeyQry.buildJPAQuery(em);
 			List<?> obj = qry.getResultList();
 			// If there are results then another publisher has the domain key and therefore the key generator is unavailable
 			if (obj != null && obj.size() > 0)
 				return false;
 		}
 		
 		return true;
 	}
 
 }