/*
    * Jour - java profiler and monitoring library
    *
    * Copyright (C) 2004 Jour team
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Library General Public
    * License as published by the Free Software Foundation; either
    * version 2 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Library General Public License for more details.
   *
   * You should have received a copy of the GNU Library General Public
   * License along with this library; if not, write to the
   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   * Boston, MA  02111-1307, USA.
   */
  package net.sf.jour.rt.view;
  
  import org.apache.log4j.Logger;
  
  import java.util.Hashtable;
  
  import net.sf.jour.filter.*;
  
  import net.sf.jour.rt.view.config.*;
  import net.sf.jour.rt.agent.ProfilerEvent;
  
  /***
   * TODO Add docs
   * Created on 30.07.2004
   *
   * Contributing Author(s):
   *
   *   Misha Lifschitz <mishalifschitz at users.sourceforge.net> (Inital implementation)
   *   Vlad Skarzhevskyy <vlads at users.sourceforge.net> (Inital implementation)
   *
   * @author vlads
   * @version $Revision: 1.3 $ ($Author: vlads $) $Date: 2004/12/06 02:31:42 $
   */
  public class ClassMatchFilter extends MatchListFilter {
  
  	protected static final Logger log = Logger.getLogger(ClassMatchFilter.class);
  	
      private class MethodsFilter extends MatchStringListFilter {
  		MatchStringListFilter methodsSignature;
  		
  		MethodsFilter() {
  			this.name = "Methods";
  			this.methodsSignature = new MatchStringListFilter();
  			this.methodsSignature.name = "signatureList";
  		}
  		
          public boolean readContext(Object o) {
              if (o instanceof SignatureType) {
                  addSignature((SignatureType) o);
                  return true;
              } else {
                  return super.readContext(o);
              }
          }
  		
          void addSignature(SignatureType sigDef) {
              if (sigDef.isEnabled()) {
  				this.methodsSignature.addInclude(sigDef.getNames(), false);
  				this.methodsSignature.readConfig(sigDef.getInclude());
  				this.methodsSignature.readConfig(sigDef.getExclude());
              }
          }
  		
          public void readConfig(MethodsType funcDef) {
  			super.addInclude(funcDef.getNames(), false);
  			super.readConfig(funcDef.getContent());
          }
          
          public boolean matchMethod(String methodName) {
              return super.match(methodName);
          }
  		
          public boolean match(String methodName, String signature) {
              return super.match(methodName)
                  && (this.methodsSignature.isEmpty()
                      || ((!this.methodsSignature.isEmpty()) && this.methodsSignature.match(signature)));
          }
  		
  		public int matchState(Object obj) {
  			if (obj instanceof ProfilerEvent) {
  				ProfilerEvent event = (ProfilerEvent)obj;
  				if (debug) {
  					ClassMatchFilter.log.debug("match methods"); 
  				}
  				if (this.match(event.getMethodName(), event.getMethodSignature())) {
  					return MATCH_YES;
  				} else {
  					return MATCH_NO;
  				}
 			} else {
 				return super.matchState(obj);
 			}
 		}
 		
 		public void debug() {
 			super.debug();
 			this.methodsSignature.debug();
 		}
     }
 		
 	private class ClassesFilter extends MatchStringListFilter {
 		MatchListFilter methods;
 		Hashtable cache;
 
 		public ClassesFilter() {
 			this.name = "Classes";
 			methods = new MatchListFilter();
 			methods.name = "MethodsList";
 			cache = new Hashtable();
 		}
 
 		/*
 		 * Cache answer by MethodID.
 		 * 
 		 * @see net.sf.jour.filter.MatchFilter#matchState(java.lang.Object)
 		 */
 		public int matchState(Object obj) {
 			if (obj instanceof ProfilerEvent) {
 				ProfilerEvent event = (ProfilerEvent)obj;
 				
 				Integer value = (Integer)cache.get(event.getMethodID());
 				int rc;
 				
                 if (value == null) {
                     rc = super.matchState(event.getClassName());
 
                     if (isMatch(rc) && (!methods.isEmpty())) {
                         rc = methods.matchState(event);
 						if (debug) {
 							ClassMatchFilter.log.debug("match class = true, match methods = " 
 							  + match2String(rc));
 						}
                     }
 					cache.put(event.getMethodID(), new Integer(rc));
                 } else {
                 	rc = value.intValue();
                     if (debug) {
                         ClassMatchFilter.log.debug("match class use cache = " + match2String(rc));
                     }
                 }
 				
 				return rc;
 				
 			} else {
 				return super.matchState(obj);
 			}
 		}
 		
 		public void debug() {
 			super.debug();
 			this.methods.debug();
 		}
 		
 		public void addMethods(MethodsType def) {
 			if (!def.isEnabled()) return;
 			MethodsFilter cf = new MethodsFilter();
 			cf.readConfig(def);
 			methods.addInclude(cf);
 		}
 
 		public boolean readContext(Object o) {
 			if (o instanceof MethodsType) {
 				addMethods((MethodsType) o);
 				return true;
 			} else {
 				return super.readContext(o);
 			}
 		}
 		
         public void readConfig(ClassesType classesDef) {
             super.addInclude(classesDef.getNames(), false);
 			super.readConfig(classesDef.getContent());
         }
 	}
 
 	/***
 	 *
 	 */
 	public ClassMatchFilter() {
 	}
 
 	public void addClasses(ClassesType classesDef) {
 		if (!classesDef.isEnabled()) return;
 		ClassesFilter cf = new ClassesFilter();
 		cf.readConfig(classesDef);
 		addInclude(cf);
 	}
 	
 	public boolean readContext(Object o) {
 		if (o instanceof Classes) {
 			addClasses((Classes)o);
 			return true;
 		} else {
 			return super.readContext(o);
 		}
 	}
 }