/**
    * This file Copyright (c) 2008-2012 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 static java.lang.String.format;
  
  import info.magnolia.module.rssaggregator.util.Assert;
  
  import java.util.Collection;
  import java.util.Set;
  
  import org.apache.commons.beanutils.MethodUtils;
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.sun.syndication.feed.synd.SyndEntry;
  
  /**
   * A set of {@link FilterPredicate filter predicates} defined for an {@link AggregateFeed}. Entries in a {@link
   * FeedChannel} must be {@link #include(SyndEntry) included} by this filter before they will actually be imported.
   *
   * @author had
   * @author Rob van der Linden Vooren
   */
  public class AggregateFilter {
  
      private Logger log = LoggerFactory.getLogger(AggregateFilter.class);
  
      private final Set<FilterPredicate> filters;
  
      public AggregateFilter(Set<FilterPredicate> filters) {
          Assert.notNull(filters, "'filters' must not be null");
          this.filters = filters;
      }
  
      public boolean include(SyndEntry entry) {
          boolean include = true;
          for (FilterPredicate filter : filters) {
              String property = filter.getProperty();
              String getterName = format("get%s", property);
              Object propertyValue = StringUtils.EMPTY;
              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);
                  }
              }
              String regularExpression = filter.getRegularExpression();
              FilterPredicate.Condition condition = filter.getCondition();
              if (propertyValue instanceof Collection) {
                  Collection<Object> propertyValues = (Collection<Object>) propertyValue;
                  boolean hit = getHit(propertyValues, regularExpression);
                  switch (condition) {
                      case AND:
                          include &= hit;
                          break;
                      case OR:
                          include |= hit;
                          break;
                      case NOT:
                          include &= !hit;
                          break;
                  }
              } else {
                  if (propertyValue != null) {
                      include = matchSingleString(include, propertyValue.toString(), regularExpression, condition);
                 } else {
                     include = false;
                 }
             }
         }
         return include;
     }
 
     //  Helper methods
 
     protected boolean getHit(Collection<Object> propertyValues, String regularExpression) {
         boolean hit = false;
         for (Object valueWrapper : propertyValues) {
             String single;
             try {
                 single = (String) MethodUtils.invokeExactMethod(valueWrapper, "getName", null);
             } catch (Exception e) {
                 single = valueWrapper.toString();
             }
             if (single.matches(regularExpression)) {
                 hit = true;
                 break;
             }
         }
         return hit;
     }
 
     protected boolean matchSingleString(boolean passed, String propValue, String regularExpression, FilterPredicate.Condition condition) {
         switch (condition) {
             case AND:
                 passed &= propValue.matches(regularExpression);
                 break;
             case OR:
                 passed |= propValue.matches(regularExpression);
                 break;
             case NOT:
                 passed &= !propValue.matches(regularExpression);
                 break;
         }
         return passed;
     }
 
     protected boolean contains(FilterPredicate filterPredicate) {
         return filters.contains(filterPredicate);
     }
 }