/*******************************************************************************
 * Copyright (c) 2001, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * IBM Corporation - initial API and implementation
 *******************************************************************************/
/*
 * Created on Nov 24, 2003
 * 
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package org.eclipse.jst.j2ee.model.internal.validation;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.logging.Level;

import org.eclipse.jem.util.logger.proxy.Logger;
import org.eclipse.wst.validation.internal.core.ValidationException;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;
import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
/**
 * @author vijayb
 * 
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public abstract class AbstractEJBValidator extends J2EEValidator {
	protected Map _validated = null;
	/**
	 *  
	 */
	public AbstractEJBValidator() {
		super();
		_validated = new HashMap();
	}
	
	private Map getValidatedMap(){
		if( _validated == null ){
			_validated = new HashMap();
		}
		return _validated;
	}
	
	protected void logMissingRule(IEJBValidationContext vc, Object ruleId) {
		Logger logger = vc.getMsgLogger();
		if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
			logger.write(Level.SEVERE, ruleId + " = null"); //$NON-NLS-1$
		}
		addInternalErrorMessage(vc);
	}
	protected void addInternalErrorMessage(IEJBValidationContext vc) {
			addInternalErrorMessage(vc, null);
	}
	
	protected void addInternalErrorMessage(IEJBValidationContext vc, Throwable exc) {
		IMessage mssg = vc.getMessage();
		mssg.setId(internalErrorMessage());
		vc.addMessage(mssg);
		if(exc != null) {
			Logger logger = vc.getMsgLogger();
			if (logger != null && logger.isLoggingLevel(Level.SEVERE)) {
				logger.write(Level.SEVERE, exc);
			}
		}
	}
	
	protected Map removeOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
			if(vc.getURIs() == null) {
				// Full validation
				vc.removeAllMessages(); // Remove messages from the EJBJar.
				vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), null}); // Remove messages from any EJB client JAR files or Java Utility JAR files.
				return null;
			}
			preRemoveOldMessages(vc,targets); // Get the list of targets to be validated, and remove messages from all of them.

			// Remove the messages from all of the changed files and their dependents.
			vc.loadModel(removeOldMessagesString(), new Object[]{vc.getReporter(), targets});
			return targets;
		}
	/**
	 * @param vc
	 * @param delta
	 * @param targets
	 */
	protected void preRemoveOldMessages(IEJBValidationContext vc,Map targets) throws ValidationException {
		//Default
	}
	/**
	 * @return
	 */
	protected String removeOldMessagesString() {
		return null;
	}
	/**
	* @return
	*/
	private String internalErrorMessage() {
			return null;
		}
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.wst.validation.internal.core.core.IValidator#validate(org.eclipse.wst.validation.internal.core.core.IHelper,
	 *      org.eclipse.wst.validation.internal.core.core.IReporter,
	 *      org.eclipse.wst.validation.internal.core.core.IFileDelta[])
	 */
	public void validate(IValidationContext helper, IReporter reporter) throws ValidationException {
		//Default
		super.validate(helper, reporter);
	}
	
    public void run(IValidationRule rule, Object targetParent, Object target) throws ValidationException {
    	if(isValidated(rule.getId(), targetParent, target)) {
    		// Whether or not this is a full or incremental run, don't revalidate this target
    		// if it has already been validated. (e.g. if a class is used by more than one bean,
    		// and say one bean is stateless and one is stateful, and everything else about the
    		// beans are identical, don't validate that class again.)
    		return;
    	}
    	
    	try {
    		rule.preValidate(getValidationContext(), targetParent, target);
    		rule.validate(getValidationContext(), targetParent, target);
    		rule.postValidate(getValidationContext(), targetParent, target);
    	}
    	catch(ValidationCancelledException exc) {
    		// Clean up the messages which are on the task list? Or is it nicer to leave them behind?
    	}
    	catch(ValidationException e) {
    		throw e;
    	}
    	catch(Throwable exc) {
    		addInternalErrorMessage(getValidationContext(), exc);
    	}
    	finally {
    		setValidated(rule.getId(), targetParent, target);
    		releaseRules(rule);
    	}
    }

    /**
     * @param rule
     */
    protected abstract void releaseRules(IValidationRule rule); 

    private IEJBValidationContext _vc = null;

    protected IEJBValidationContext getValidationContext() {
    	return _vc;
    }
    protected void setValidationContext(IEJBValidationContext vc) {
    	_vc = vc;
    }
	
	/**
	 *  This class is public only for the EJBHelper.
	 */
	public class TargetObject {
		private Object _parent = null;
		private Object _target = null;
		
		public TargetObject() {
			//Default
		}
		
		public Object getTargetParent() {
			return _parent;
		}
		
		public Object getTarget() {
			return _target;
		}
		
		public void setTargetParent(Object tp) {
			_parent = tp;
		}
		
		public void setTarget(Object t) {
			_target = t;
		}
		
		public int hashCode() {
			int parent = (getTargetParent() == null) ? 0 : getTargetParent().hashCode();
			int target = (getTarget() == null) ? 0 : getTarget().hashCode();
			return parent + target;
		}
		
		public boolean equals(Object o) {
			if(o == null) {
				return false;
			}
			
			if(this == o) {
				return true;
			}
			
			if(!(o instanceof TargetObject)) {
				return false;
			}
			
			Object thisParent = this.getTargetParent();
			Object oParent = ((TargetObject)o).getTargetParent();
			Object thisTarget = this.getTarget();
			Object oTarget = ((TargetObject)o).getTarget();
			
			if((thisParent == null) && (oParent == null)) {
				// check target
			}
			else if((thisParent != null) && (oParent != null)) {
				if(thisParent.equals(oParent)) {
					// check target
				}
				else {
					return false;
				}
			}
			else {
				return false;
			}
			
			if((thisTarget == null) && (oTarget == null)) {
				return true;
			}
			else if((thisTarget != null) && (oTarget != null)) {
				return (thisTarget.equals(oTarget));
			}
			else {
				return false;
			}
		}
	}


    public void setValidated(Object key, Object targetParent, Object target) {
    	Set done = null;
    	if(getValidatedMap().containsKey(key)) {
    		done = (Set)getValidatedMap().get(key);
    	}
    	else {
    		done = new HashSet();
    	}
    	
    	done.add(getTargetObjectPool().getTargetObject(targetParent, target));
    	getValidatedMap().put(key, done);
    }


	protected class TargetObjectPool {
		private int _growSize = 0;
		private Vector _pool = null;
		
		public TargetObjectPool(int initialSize) {
			_growSize = initialSize;
			_pool = new Vector(initialSize, _growSize);
			grow();
		}
		
		private void grow() {
			for(int i=0; i<_growSize; i++) {
				_pool.add(new TargetObject());
			}
		}
		
		public TargetObject getTargetObject(Object targetParent, Object target) {
			if(_pool.size() <= 0) {
				grow();
			}
			TargetObject obj = (TargetObject)_pool.remove(0);
			obj.setTargetParent(targetParent);
			obj.setTarget(target);
			return obj;
		}
		
		public void release(TargetObject obj) {
			obj.setTargetParent(null);
			obj.setTarget(null);
			_pool.add(obj);
		}
	}
	
	protected abstract TargetObjectPool getTargetObjectPool();

    public boolean isValidated(Object key, Object targetParent, Object target) {
    	if(!getValidatedMap().containsKey(key)) {
    		return false;
    	}
    
    
    	Set done = (Set)getValidatedMap().get(key);
    	TargetObject temp = getTargetObjectPool().getTargetObject(targetParent, target);
    	try {
    		if(done.contains(temp)) {
    			return true;
    		}
    		
    		return false;
    	}
    	finally {
    		getTargetObjectPool().release(temp);
    	}
    }
    public void cleanup(IReporter reporter) {
    	if( _validated != null ){
	    	Iterator iterator = _validated.keySet().iterator();
	    	while(iterator.hasNext()) {
	    		Set done = (Set)_validated.get(iterator.next());
	    		Iterator toIterator = done.iterator();
	    		while(toIterator.hasNext()) {
	    			TargetObject to = (TargetObject)toIterator.next();
	    			getTargetObjectPool().release(to);
	    		}
	    		done.clear();
	    	}
	    	_validated.clear();
	    	_validated = null;
    	}
    	setValidationContext(null);
    }

}