/*
    *  Copyright 2010 Felix Roethenbacher
    *
    *  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 ch.syabru.nagios.broker.jmx;
  
  import java.util.regex.Pattern;
  import java.util.regex.PatternSyntaxException;
  
  import org.apache.commons.lang.Validate;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import ch.syabru.nagios.broker.ExternalCommand;
  import ch.syabru.nagios.broker.ExternalCommandFactory;
  import ch.syabru.nagios.broker.Matcher;
  import ch.syabru.nagios.broker.MatcherException;
  import ch.syabru.nagios.broker.Message;
  
  /**
   * JMX matcher implementation.
   *
   * @author Felix Roethenbacher
   *
   */
  public class JmxMatcher implements Matcher {
      private static final Logger logger =
          LoggerFactory.getLogger(JmxMatcher.class);
  
      private static final Pattern PATTERN_ANY = Pattern.compile(".*", Pattern.DOTALL);
  
      private Pattern classNamePattern = PATTERN_ANY;
      private Pattern messagePattern = PATTERN_ANY;
      private Pattern typePattern = PATTERN_ANY;
      private Pattern sourcePattern = PATTERN_ANY;
      private ExternalCommandFactory commandFactory;
  
      /**
       * C'tor.
       * @param classNameRegex Class name regular expression.
       * @param messageRegex Message regular expression.
       * @param typeRegex Type regular expression.
       * @param sourceRegex Source regular expression.
       * @param commandFactory Command factory.
       * @throws MatcherException XX
       */
      public JmxMatcher(String classNameRegex, String messageRegex,
              String typeRegex, String sourceRegex,
              ExternalCommandFactory commandFactory)
      throws MatcherException
      {
          Validate.notNull(commandFactory, "commandFactory must not be null");
          try {
              if (classNameRegex != null)
                  this.classNamePattern = Pattern.compile(classNameRegex);
              if (messageRegex != null)
                  this.messagePattern = Pattern.compile(messageRegex);
              if (typeRegex != null)
                  this.typePattern = Pattern.compile(typeRegex);
              if (sourceRegex != null)
                  this.sourcePattern = Pattern.compile(sourceRegex);
          } catch (PatternSyntaxException e) {
              throw new MatcherException("Error compiling matcher regex", e);
          }
          this.commandFactory = commandFactory;
      }
  
      @Override
      public ExternalCommand matches(Message message) {
          ExternalCommand matchingCommand = null;
          if (message instanceof JmxMessage) {
              JmxMessage jmxMsg = (JmxMessage) message;
              java.util.regex.Matcher classNameMatcher =
                  classNamePattern.matcher(jmxMsg.getClassName());
              String msgText = jmxMsg.getMessage() != null ?
                      jmxMsg.getMessage() : "";
              java.util.regex.Matcher messageMatcher =
                  messagePattern.matcher(msgText);
              java.util.regex.Matcher typeMatcher =
                  typePattern.matcher(jmxMsg.getType());
              java.util.regex.Matcher sourceMatcher =
                  sourcePattern.matcher(jmxMsg.getSource());
              if (classNameMatcher.matches() &&
                      messageMatcher.matches() &&
                      typeMatcher.matches() &&
                      sourceMatcher.matches())
              {
                  matchingCommand = commandFactory.createCommand();
                 logger.debug("Message matched [classNamePattern={}, " +
                         "messagePattern={}, typePattern={}, " +
                         "sourcePattern={}, " + "message={}]",
                         new Object[] { classNamePattern, messagePattern,
                         typePattern, sourcePattern, message });
             } else {
                 logger.debug("Message did not match [classNamePattern={}, " +
                         "messagePattern={}, typePattern={}, " +
                         "sourcePattern={}, message={}]", new Object[] {
                         classNamePattern, messagePattern, typePattern,
                         sourcePattern, message });
             }
         }
         return matchingCommand;
     }
 }