/**
    * This file Copyright (c) 2003-2013 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.generator;
  
  import static info.magnolia.module.rssaggregator.RSSAggregator.*;
  import static java.lang.String.format;
  
  import info.magnolia.cms.beans.config.ServerConfiguration;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.util.SessionUtil;
  import info.magnolia.module.data.DataConsts;
  import info.magnolia.module.data.DataModule;
  import info.magnolia.module.rssaggregator.util.ContentMapper;
  import info.magnolia.module.rssaggregator.util.MagnoliaTemplate;
  import info.magnolia.objectfactory.Components;
  
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.sun.syndication.feed.synd.SyndContent;
  import com.sun.syndication.feed.synd.SyndContentImpl;
  import com.sun.syndication.feed.synd.SyndEntry;
  import com.sun.syndication.feed.synd.SyndEntryImpl;
  import com.sun.syndication.feed.synd.SyndFeed;
  
  /**
   * Generates a {@link com.sun.syndication.feed.synd.SyndFeed} based on aggregate planet feeds defined via the RSS Aggregator Module.
   *
   * @author lfischer
   */
  public class PlanetFeedGenerator extends AbstractSyndFeedGenerator implements Cloneable {
  
      private static final ContentMapper<SyndEntry> MAPPER = new FeedEntryMapper();
  
      private static final Logger log = LoggerFactory.getLogger(PlanetFeedGenerator.class);
  
      private static final String FEED_TYPE_RSS = "rss_2.0";
      private static final String FEED_TYPE_ATOM = "atom_1.0";
  
      private MagnoliaTemplate magnoliaTemplate;
  
      private String feedPath;
  
      public PlanetFeedGenerator() {
          this.magnoliaTemplate = new MagnoliaTemplate();
      }
  
      public void setFeedPath(String feedPath) {
          this.feedPath = feedPath;
      }
  
      @Override
      public Feed generate() throws FeedGenerationException {
          String feedType = getFeedType();
  
          try {
              SyndFeed syndFeed = newSyndFeed();
              syndFeed.setFeedType(feedType);
              syndFeed.setEntries(loadFeedEntries());
              setFeedInfo(syndFeed);
  
              String xml = syndFeedToXml(syndFeed);
             return new Feed(xml, DEFAULT_CONTENT_TYPE, DEFAULT_ENCODING);
         } catch (Exception e) {
             String message = format("Failed to generate Feed using generator '%s'", getClass().getName());
             log.error(message, e);
             throw new FeedGenerationException(message, e);
         }
     }
 
     @Override
     public List<SyndEntry> loadFeedEntries() {
         String entriesQuery = format("/jcr:root%s/planetData[1]/*/* order by @pubDate descending", feedPath);
         return magnoliaTemplate.xpathQueryForList(DataModule.getRepository(), entriesQuery, DataConsts.MODULE_DATA_CONTENT_NODE_TYPE, MAPPER);
     }
 
     @Override
     public void setFeedInfo(SyndFeed feed) {
         // Ideally retrieve this from the aggregate node definition. However the RSS Aggregate creation dialog does not
         // provide for this information (yet).
         String link = Components.getComponent(ServerConfiguration.class).getDefaultBaseUrl();
         Node feedDescr = SessionUtil.getNode(DataModule.getRepository(), feedPath);
         feed.setTitle(StringUtils.defaultIfEmpty(PropertyUtil.getString(feedDescr, "title"), ""));
         feed.setLink(link);
         feed.setDescription(StringUtils.defaultIfEmpty(PropertyUtil.getString(feedDescr, "description"), ""));
     }
 
     @Override
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
 
     protected String getFeedType() {
         String feedType = "";
 
         if (StringUtils.endsWith(this.feedPath, "/rss")) {
             this.feedPath = StringUtils.substringBeforeLast(this.feedPath, "/rss");
             feedType = FEED_TYPE_RSS;
         } else {
             if (StringUtils.endsWith(this.feedPath, "/atom")) {
                 this.feedPath = StringUtils.substringBeforeLast(this.feedPath, "/atom");
                 feedType = FEED_TYPE_ATOM;
             }
         }
 
         if (StringUtils.isBlank(feedType)) {
             feedType = DEFAULT_FEEDTYPE;
         }
 
         return feedType;
     }
 
     private static class FeedEntryMapper implements ContentMapper<SyndEntry> {
 
         @Override
         public SyndEntry map(Node content) throws RepositoryException {
 
             SyndEntry entry = new SyndEntryImpl();
             entry.setAuthor(PropertyUtil.getString(content, "author"));
             entry.setTitle(PropertyUtil.getString(content, "title"));
             entry.setLink(PropertyUtil.getString(content, "link"));
             if (content.hasProperty("pubDate")) {
                 entry.setPublishedDate(PropertyUtil.getDate(content, "pubDate").getTime());
             }
             SyndContent description = new SyndContentImpl();
             //description.setType("text/html");
             description.setValue(PropertyUtil.getString(content, "description"));
             entry.setDescription(description);
 
             // if categories are needed, they should be integrated here
 
             return entry;
         }
     }
 }