/**
    * This file Copyright (c) 2014 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.command;
  
  import static java.lang.String.format;
  import static java.lang.String.valueOf;
  import static org.apache.commons.lang.StringUtils.isEmpty;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.quartz.SchedulerException;
  
  import com.sun.syndication.feed.synd.SyndCategory;
  import com.sun.syndication.feed.synd.SyndContent;
  import com.sun.syndication.feed.synd.SyndEntry;
  import com.sun.syndication.feed.synd.SyndFeed;
  
  import info.magnolia.commands.MgnlCommand;
  import info.magnolia.context.Context;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.util.VersionUtil;
  import info.magnolia.module.ModuleRegistry;
  import info.magnolia.module.rssaggregator.RSSAggregator;
  import info.magnolia.module.rssaggregator.RSSAggregatorConstants;
  import info.magnolia.module.rssaggregator.RSSAggregatorNodeTypes;
  import info.magnolia.module.rssaggregator.RSSJob;
  import info.magnolia.module.rssaggregator.importhandler.AggregateFeed;
  import info.magnolia.module.rssaggregator.importhandler.AggregateFeedContentMapper;
  import info.magnolia.module.rssaggregator.importhandler.AggregateFilter;
  import info.magnolia.module.rssaggregator.importhandler.FeedChannel;
  import info.magnolia.module.rssaggregator.importhandler.FilterPredicate;
  import info.magnolia.module.rssaggregator.importhandler.FilterPredicateContentMapper;
  import info.magnolia.module.rssaggregator.importhandler.RSSFeedFetcher;
  import info.magnolia.module.rssaggregator.util.Assert;
  import info.magnolia.module.scheduler.SchedulerModule;
  import info.magnolia.objectfactory.Components;
  
  /**
   * Starts an update on specific RSS aggregator.
   *
   */
  public class LaunchSingleRSSCommand extends MgnlCommand {
  
      private RSSFeedFetcher fetcher;
  
      private FilterPredicateContentMapper filterPredicateMapper;
  
      private String name;
  
      public LaunchSingleRSSCommand(){}
  
      public LaunchSingleRSSCommand(RSSJob job){
          this.name = job.getName();
         this.fetcher = job.getFetcher();
     }
 
     private void init(){
         if(this.fetcher == null){
             this.fetcher = RSSAggregator.getInstance().getFetcher();
         }
         setFilterPredicateContentMapper(new FilterPredicateContentMapper());
     }
 
     @Override
     public boolean execute(Context context) throws Exception {
         init();
         Set<String> newContentUUIDs = new LinkedHashSet<String>();
         Node rss = getRSSNodeByFeedName(name);
         if(rss != null) {
             Set<AggregateFeed> fetchedAggregateFeeds = fetcher.fetchAggregateFeeds(getFeeds(rss));
             Set<String> newAggregateContentUUIDs = saveAggregates(fetchedAggregateFeeds, rss);
             newContentUUIDs.addAll(newAggregateContentUUIDs);
             rss.getSession().save();
         }
         return false;
     }
 
     private Node getRSSNodeByFeedName(String name) throws RepositoryException{
         try {
             return MgnlContext.getJCRSession(RSSAggregatorConstants.WORKSPACE).getNodeByIdentifier(name);
         } catch (RepositoryException e) {
             try {
                 log.debug("RSS with name " + name + "doesn't exist anymore");
                 SchedulerModule scheduler = (SchedulerModule) Components.getComponent(ModuleRegistry.class).getModuleInstance("scheduler");
                 scheduler.stopJob(name);
                 scheduler.removeJob(name);
             } catch (SchedulerException ex) {
             // If the node does not exist we try to remove it from scheduler to prevent future launches
             }
         }
         return null;
     }
 
     public Set<AggregateFeed> getFeeds(Node node) throws RepositoryException{
         AggregateFeedContentMapper aggregateFeedMapper = new AggregateFeedContentMapper();
         Set<AggregateFeed> aggregateFeeds = new HashSet<AggregateFeed>();
         AggregateFeed aggregateFeed = aggregateFeedMapper.map(node);
         aggregateFeeds.add(aggregateFeed);
         return aggregateFeeds;
     }
 
     protected Set<String> saveAggregates(Set<AggregateFeed> aggregateFeeds, Node parentNode) throws RepositoryException {
         Set<String> newAggregateContentUUIDs = new HashSet<String>();
         for (AggregateFeed aggregateFeed : aggregateFeeds) {
             Node aggregateNode = parentNode;
             Node dataNode = NodeUtil.createPath(aggregateNode, "data", NodeTypes.Content.NAME);
             newAggregateContentUUIDs.add(aggregateNode.getIdentifier());
             AggregateFilter aggregateFilter = loadAggregateFilter(aggregateNode);
             for (FeedChannel channel : aggregateFeed.getChannels()) {
                 if (channel.hasFeed()) {
                     saveFeedChannel(channel, aggregateFilter, dataNode);
                 }
             }
         }
         return newAggregateContentUUIDs;
     }
     
     protected Node loadSingleAggregateNode(Node parentNode, String aggregateNodeName) throws RepositoryException {
         NodeIterator nodeIterator = parentNode.getNodes(aggregateNodeName);
         Collection<Node> aggregateNodes = new ArrayList<Node>();
         while (nodeIterator.hasNext()) {
             Node currentNode = nodeIterator.nextNode();
             if (NodeUtil.isNodeType(currentNode, RSSAggregatorNodeTypes.RSSAggregator.NAME)) {
                 aggregateNodes.add(currentNode);
             }
         }
         int size = aggregateNodes.size();
         if (size > 1) {
             throw new IllegalStateException(format(
                     "Expected content node '%s' to have at most 1 child named '%s' of item type '%s', but found %s",
                     parentNode, aggregateNodeName, RSSAggregatorNodeTypes.RSSAggregator.NAME, size));
         }
         if (aggregateNodes.isEmpty()) {
             return null;
         }
         return aggregateNodes.iterator().next();
     }
 
     public AggregateFilter loadAggregateFilter(Node aggregateNode) throws RepositoryException {
         Node filtersNode = aggregateNode.hasNode("filters") ? aggregateNode.getNode("filters") : null;
         if (filtersNode == null) {
             return new AggregateFilter(Collections.<FilterPredicate>emptySet());
         }
         Set<FilterPredicate> filters = new HashSet<FilterPredicate>();
         List<Node> filterNodes = NodeUtil.asList(NodeUtil.getNodes(filtersNode, VersionUtil.getNodeTypeName(filtersNode)));
 
         for (Node n : filterNodes) {
             FilterPredicate filterPredicate = filterPredicateMapper.map(n);
             if (filterPredicate == null) {
                 continue;
             }
             filters.add(filterPredicate);
         }
         return new AggregateFilter(filters);
     }
 
     @SuppressWarnings("unchecked")
     protected Node saveFeedChannel(FeedChannel feedChannel, AggregateFilter aggregateFilter, Node dataNode) throws RepositoryException {
         Node channelNode = recreateFeedChannelNode(feedChannel, dataNode);
         List<SyndEntry> entries = feedChannel.getFeed().getEntries();
         int size = entries.size();
         for (int i = 0; i < size; i++) {
             SyndEntry entry = entries.get(i);
             String entryName = format("entry-%s", i);
             if (aggregateFilter.include(entry)) {
                 createFeedChannelEntryNode(entry, entryName, channelNode);
             }
         }
         return channelNode;
     }
 
     protected Node recreateFeedChannelNode(FeedChannel feedChannel, Node dataNode) throws RepositoryException {
         String channelName = feedChannel.getName();
         if (dataNode.hasNode(channelName)) {
             String absPath = dataNode.getNode(channelName).getPath();
             dataNode.getSession().removeItem(absPath);
         }
         Node channelNode = NodeUtil.createPath(dataNode, channelName, NodeTypes.Content.NAME);
 
         SyndFeed feed = feedChannel.getFeed();
         channelNode.setProperty("description", feed.getDescription()); // 'My Blog'
         channelNode.setProperty("link", feed.getLink()); // 'http://domain.com'
         channelNode.setProperty("rss", feedChannel.getUrl()); // 'http://domain.com/channel.rss'
         channelNode.setProperty("title", !isEmpty(feedChannel.getTitle()) ? feedChannel.getTitle() : feed.getTitle());
         channelNode.setProperty("type", feed.getFeedType()); // 'rss_2.0'
         return channelNode;
     }
 
     protected Node createFeedChannelEntryNode(SyndEntry entry, String nodeName, Node channelNode) throws RepositoryException {
         Node entryNode = NodeUtil.createPath(channelNode, nodeName, NodeTypes.Content.NAME);
         entryNode.setProperty("author", entry.getAuthor() == null ? "" : entry.getAuthor());
         entryNode.setProperty("channelTitle", PropertyUtil.getString(channelNode, "title"));
         final SyndContent description = entry.getDescription();
 
         String descriptionString;
         if (description != null && StringUtils.isNotBlank(description.getValue())) {
             descriptionString = description.getValue();
         } else {
             descriptionString = getEntryContent(entry);
         }
 
         entryNode.setProperty("description", descriptionString);
         entryNode.setProperty("content", getEntryContent(entry));
         entryNode.setProperty("link", entry.getLink());
         Date publishedDate = entry.getPublishedDate();
         if (publishedDate == null) {
             publishedDate = new Date();
         }
         entryNode.setProperty("pubDate", publishedDate.getTime());
         entryNode.setProperty("title", entry.getTitle());
 
         createCategoriesNode(entry, entryNode);
         return entryNode;
     }
 
     protected String getEntryContent(SyndEntry entry) {
         String entryContent = "";
 
         if (entry != null && entry.getContents().size() > 0) {
             @SuppressWarnings("unchecked")
             final List<SyndContent> contents = entry.getContents();
             for (SyndContent content : contents) {
                 if (StringUtils.equalsIgnoreCase("html", content.getType()) && StringUtils.isNotBlank(content.getType())) {
                     entryContent = content.getValue();
                     break;
                 }
             }
         }
         return entryContent;
     }
 
     protected Node createCategoriesNode(SyndEntry entry, Node entryNode) throws RepositoryException {
         Node categoriesNode = NodeUtil.createPath(entryNode, "categories", NodeTypes.Content.NAME);
         List<SyndCategory> categories = entry.getCategories();
         for (int i = 0; i < categories.size(); i++) {
             SyndCategory category = categories.get(i);
             String categoryIndex = valueOf(i);
             String categoryName = category.getName();
             categoriesNode.setProperty(categoryIndex, categoryName);
         }
         return categoriesNode;
     }
 
     protected FilterPredicateContentMapper setFilterPredicateContentMapper(FilterPredicateContentMapper filterPredicateMapper) {
         Assert.notNull(filterPredicateMapper, "'filterPredicateContentMapper' must not be null");
         this.filterPredicateMapper = filterPredicateMapper;
         return this.filterPredicateMapper;
     }
 
     public void setFetcher(RSSFeedFetcher fetcher){
         this.fetcher = fetcher;
     }
 
     public RSSFeedFetcher getFetcher(){
         return this.fetcher;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public String getName() {
         return this.name;
     }
 }