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();
        }
    }
}