/**
    * 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.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.NodeTypes;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.util.SessionUtil;
  import info.magnolia.module.rssaggregator.RSSAggregatorConstants;
  import info.magnolia.module.rssaggregator.util.ContentMapper;
  import info.magnolia.module.rssaggregator.util.MagnoliaTemplate;
  import info.magnolia.objectfactory.Components;
  
  import java.util.Date;
  import java.util.List;
  
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.rometools.rome.feed.synd.SyndContent;
  import com.rometools.rome.feed.synd.SyndContentImpl;
  import com.rometools.rome.feed.synd.SyndEntry;
  import com.rometools.rome.feed.synd.SyndEntryImpl;
  import com.rometools.rome.feed.synd.SyndFeed;
  import com.rometools.rome.feed.synd.SyndLink;
  import com.rometools.rome.feed.synd.SyndLinkImpl;
  
  /**
   * Generates a {@link com.rometools.rome.feed.synd.SyndFeed} based on aggregate planet feeds defined via the RSS Aggregator Module.
   */
  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 static final String DEFAULT_DESCRIPTION = "Magnolia Planet feed post content";
  
      private MagnoliaTemplate magnoliaTemplate;
  
      private String feedPath;
      private static String feedType;
  
      public PlanetFeedGenerator() {
          this.magnoliaTemplate = new MagnoliaTemplate();
      }
  
      public void setFeedPath(String feedPath) {
          this.feedPath = feedPath;
      }
  
      @Override
      public Feed generate() throws FeedGenerationException {
          feedType = getFeedType();
  
          try {
              SyndFeed syndFeed = newSyndFeed();
              syndFeed.setFeedType(feedType);
             setFeedInfo(syndFeed);
             syndFeed.setEntries(loadFeedEntries());
 
             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(RSSAggregatorConstants.WORKSPACE, entriesQuery, NodeTypes.Content.NAME, MAPPER);
     }
 
     @Override
     @SuppressWarnings(value = "unchecked")
     public void setFeedInfo(SyndFeed feed) {
         // common attributes
         Node feedDescr = SessionUtil.getNode(RSSAggregatorConstants.WORKSPACE, feedPath);
         feed.setTitle(StringUtils.defaultIfEmpty(PropertyUtil.getString(feedDescr, "title"), ""));
         feed.setDescription(StringUtils.defaultIfEmpty(PropertyUtil.getString(feedDescr, "description"), DEFAULT_DESCRIPTION));
         String link = Components.getComponent(ServerConfiguration.class).getDefaultBaseUrl();
 
         // ATOM feed
         if (FEED_TYPE_ATOM.equals(feedType)) {
             if (!StringUtils.endsWith(link, "/")) {
                 link += "/";
             }
             feed.setUri(link);  // generates the ID, should end with an "/"
             feed.setPublishedDate(new Date());
 
             SyndLink selfLink = new SyndLinkImpl();
             selfLink.setRel("self");
             selfLink.setHref(link);
             selfLink.setType("application/atom+xml");
             feed.getLinks().add(selfLink);
         } else {
             // RSS feed
             feed.setLink(link);
         }
     }
 
     @Override
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
 
     /**
      * Determine the feed type.
      *
      * @return ATOM or RSS feed type
      */
     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();
 
             // common attributes
             entry.setTitle(PropertyUtil.getString(content, "title"));
             entry.setLink(PropertyUtil.getString(content, "link"));
             entry.setAuthor(PropertyUtil.getString(content, "author"));
             if (content.hasProperty("pubDate")) {
                 entry.setPublishedDate(PropertyUtil.getDate(content, "pubDate").getTime());
             } else {
                 entry.setPublishedDate(new Date());
             }
             SyndContent description = new SyndContentImpl();
 
             description.setType("text/html");
             description.setValue(PropertyUtil.getString(content, "description"));
             entry.setDescription(description);
 
             // ATOM feed
             if (FEED_TYPE_ATOM.equals(feedType)) {
                 entry.setUri(PropertyUtil.getString(content, "link")); // ID property of an entry
             }
 
             // if categories are needed, they should be integrated here
             return entry;
         }
     }
 }