/**
    * This file Copyright (c) 2013-2016 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.rssaggregator.importhandler;
  
  import info.magnolia.module.rssaggregator.util.Assert;
  
  import java.util.Set;
  
  import org.apache.commons.beanutils.MethodUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.rometools.rome.feed.synd.SyndEntry;
  
  /**
   * Filters entries based on the criteria specified in the RSS Aggregator dialog.
   */
  public class PlanetFilter {
  
      private static final Logger log = LoggerFactory.getLogger(PlanetFilter.class);
      private static final String METHOD_PREFIX = "get";
      private final Set<FilterPredicate> filters;
  
      public PlanetFilter(Set<FilterPredicate> filters) {
          Assert.notNull(filters, "'filters' must not be null");
          this.filters = filters;
      }
  
      public boolean include(SyndEntry entry) {
          boolean includeAnd = includeByCondition(entry, FilterPredicate.Condition.AND);
          boolean includeOr = includeByCondition(entry, FilterPredicate.Condition.OR);
          boolean includeNot = includeByCondition(entry, FilterPredicate.Condition.NOT);
  
          return includeAnd && includeOr && includeNot;
      }
  
      boolean includeByCondition(SyndEntry entry, FilterPredicate.Condition matchingCondition) {
          boolean include = false;
          boolean conditionFound = false;
  
          for (FilterPredicate filter : filters) {
              Object propertyValue = getPropertyValue(entry, filter.getProperty());
              FilterPredicate.Condition condition = filter.getCondition();
  
              if (propertyValue != null && condition.equals(matchingCondition)) {
                  boolean hit;
  
                  hit = matchSingleString(propertyValue.toString(), filter.getRegularExpression());
  
                  switch (condition) {
                  case AND:
                      if (hit && !conditionFound) {
                          include = true;
                      } else {
                          include &= hit;
                      }
                      conditionFound = true;
                      break;
                  case OR:
                      if (hit) {
                          include = true;
                      }
                      conditionFound = true;
                      break;
                  case NOT:
                      if (hit) {
                          include = false;
                     } else {
                         if (!conditionFound) {
                             include = true;
                         }
                     }
                     conditionFound = true;
                     break;
                 }
             }
         }
         if (!conditionFound) {
             include = true;
         }
         return include;
     }
 
     protected boolean matchSingleString(String propertyValue, String regularExpression) {
         // remove newline characters, otherwise regex will not work
         propertyValue = StringUtils.remove(propertyValue, "\n");
 
         return propertyValue.matches(regularExpression);
     }
 
     Object getPropertyValue(SyndEntry entry, String property) {
         Object propertyValue = StringUtils.EMPTY;
 
         String getterName = getCamelCaseProperty(property);
 
         try {
             propertyValue = MethodUtils.invokeExactMethod(entry, getterName, null);
         } catch (Exception e) {
             if (log.isWarnEnabled()) {
                 log.warn("Property {} can't be retrieved from the feed and will be treated as if it was empty during filtering", property);
             }
         }
 
         return propertyValue;
     }
 
     protected String getCamelCaseProperty(String prop) {
         if (StringUtils.isBlank(prop)) {
             return "";
         }
         return METHOD_PREFIX + StringUtils.upperCase(StringUtils.substring(prop, 0, 1)) +
                 StringUtils.lowerCase((StringUtils.substring(prop, 1, prop.length())));
     }
 }