package net.sf.logdistiller;
   
   /*
    * 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.
   */
  
  import java.io.*;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.regex.Pattern;
  
  import org.jdom.Element;
  
  /**
   * Match of an attribute of a LogEvent. Match type can be either <code>contains</code>, <code>equals</code>,
   * <code>startsWith</code>, <code>endsWith</code> or <code>regexp</code>, and can be negated by preceding type with
   * <code>!</code>.
   */
  public class Match
      implements Serializable
  {
      private static final long serialVersionUID = -1809458932445222708L;
  
      private final String attribute;
  
      private final boolean not;
  
      private final Function function;
  
      private transient LogType.AttributeInfo attributeInfo;
  
      public Match( String attribute, String type, String reference )
      {
          this.attribute = attribute;
          this.not = type.startsWith( "!" );
          if ( not )
          {
              type = type.substring( 1 );
          }
          this.function = Match.Function.getInstance( type, reference );
      }
  
      public boolean match( LogEvent le )
      {
          // initialize attributeInfo if necessary
          if ( attributeInfo == null )
          {
              LogType.Description description = le.getFactory().getDescription();
              attributeInfo = description.getAttributeInfo( attribute );
          }
  
          String value = le.getValue( attributeInfo );
          boolean result = function.checkValue( value );
          return ( not ? !result : result );
      }
  
      public Element dump()
      {
          Element elmt = new Element( "match" );
          elmt.setAttribute( "attribute", attribute );
          elmt.setAttribute( "type", ( not ? "!" : "" ) + function.getId() );
          elmt.setText( function.reference );
          return elmt;
      }
  
      private static abstract class Function
          implements Serializable
      {
          private static final long serialVersionUID = 1072441995042764838L;
  
          public final static Map<String, Class<? extends Function>> FUNCTIONS;
          static
          {
              Map<String, Class<? extends Function>> map = new HashMap<String, Class<? extends Function>>();
              map.put( Contains.ID, Contains.class );
              map.put( Equals.ID, Equals.class );
              map.put( StartsWith.ID, StartsWith.class );
              map.put( EndsWith.ID, EndsWith.class );
              map.put( Regexp.ID, Regexp.class );
              FUNCTIONS = Collections.unmodifiableMap( map );
          }
  
          public static Function getInstance( String type, String reference )
          {
              Class<? extends Function> functionClass = FUNCTIONS.get( type );
              if ( functionClass == null )
              {
                  throw new IllegalArgumentException( "function type not supported '" + type + "'" );
             }
             try
             {
                 Function function = functionClass.newInstance();
                 function.setReference( reference );
                 return function;
             }
             catch ( IllegalAccessException iae )
             {
                 // can't happen
                 throw new RuntimeException( "an impossible condition has arrived...", iae );
             }
             catch ( InstantiationException ie )
             {
                 // can't happen
                 throw new RuntimeException( "an impossible condition has arrived...", ie );
             }
         }
 
         protected String reference;
 
         public void setReference( String reference )
         {
             this.reference = reference;
         }
 
         public abstract String getId();
 
         /**
          * check if the given value matches the reference.
          *
          * @param value String the value to compare to reference
          * @return boolean
          */
         public abstract boolean checkValue( String value );
     }
 
     protected static class Contains
         extends Function
     {
         private static final long serialVersionUID = 4613611844726287358L;
 
         public static final String ID = "contains";
 
         public String getId()
         {
             return ID;
         }
 
         public boolean checkValue( String value )
         {
             return ( value.indexOf( reference ) >= 0 );
         }
     }
 
     protected static class Equals
         extends Function
     {
         private static final long serialVersionUID = -6539918940865536415L;
 
         public static final String ID = "equals";
 
         public String getId()
         {
             return ID;
         }
 
         public boolean checkValue( String value )
         {
             return reference.equals( value );
         }
     }
 
     protected static class StartsWith
         extends Function
     {
         private static final long serialVersionUID = 5014914695776363132L;
 
         public static final String ID = "startsWith";
 
         public String getId()
         {
             return ID;
         }
 
         public boolean checkValue( String value )
         {
             return value.startsWith( reference );
         }
     }
 
     protected static class EndsWith
         extends Function
     {
         private static final long serialVersionUID = 1819477635452601804L;
 
         public static final String ID = "endsWith";
 
         public String getId()
         {
             return ID;
         }
 
         public boolean checkValue( String value )
         {
             return value.endsWith( reference );
         }
     }
 
     protected static class Regexp
         extends Function
     {
         private static final long serialVersionUID = -2067188055591690252L;
 
         public static final String ID = "regexp";
 
         public String getId()
         {
             return ID;
         }
 
         private transient Pattern pattern;
 
         public void setReference( String reference )
         {
             super.setReference( reference );
             updatePattern();
         }
 
         private void updatePattern()
         {
             pattern = Pattern.compile( reference );
         }
 
         private void readObject( ObjectInputStream in )
             throws IOException, ClassNotFoundException
         {
             in.defaultReadObject();
             updatePattern();
         }
 
         public boolean checkValue( String value )
         {
             return pattern.matcher( value ).find();
         }
     }
 }