/**
    * This file Copyright (c) 2015 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.resourceloader.layered;
  
  import static com.google.common.collect.Iterables.*;
  
  import info.magnolia.resourceloader.AbstractResourceOrigin;
  import info.magnolia.resourceloader.Resource;
  import info.magnolia.resourceloader.ResourceOrigin;
  import info.magnolia.resourceloader.ResourceOriginFactory;
  import info.magnolia.resourceloader.ResourceVisitor;
  import info.magnolia.resourceloader.util.Functions;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Reader;
  import java.nio.charset.Charset;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.List;
  import java.util.SortedSet;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.auto.factory.AutoFactory;
  import com.google.common.base.Function;
  import com.google.common.base.Predicate;
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableListMultimap;
  import com.google.common.collect.ImmutableSortedSet;
  import com.google.common.collect.Iterables;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Maps;
  import com.google.common.collect.Multimaps;
  import com.google.common.collect.SetMultimap;
  
  /**
   * An implementation of {@link ResourceOrigin} which aggregates
   * other instances of {@link ResourceOrigin}; resources located on the same path will
   * be served from the foremost ResourceOrigin, but resources that exist only on one path will always be served.
   */
  @AutoFactory(implementing = ResourceOriginFactory.class)
  public class LayeredResourceOrigin extends AbstractResourceOrigin<LayeredResource> {
  
      private static final Logger log = LoggerFactory.getLogger(LayeredResourceOrigin.class);
  
      private final List<ResourceOrigin> origins;
  
      // No injected arguments so far, which is fine. Just keeping a factory for consistency.
      LayeredResourceOrigin(String name, ResourceOrigin... origins) {
          super(name);
          this.origins = Arrays.asList(origins);
      }
  
      @Override
      public LayeredResource getRoot() {
          final List<Resource> roots = Lists.transform(origins, Functions.getRoot());
          return newLayeredResource(roots);
      }
  
      @Override
      public void watchForChanges(ResourceVisitor visitor) {
          for (ResourceOrigin origin : origins) {
              origin.watchForChanges(new RelayerResourceVisitor(this, visitor));
          }
      }
  
     @Override
     public LayeredResource getByPath(String path) {
         final Iterable<ResourceOrigin> matchingOrigins = filter(this.origins, Functions.hasPath(path));
         final List<Resource> matchingResources = Lists.newArrayList(transform(matchingOrigins, Functions.getByPath(path)));
         if (matchingResources.isEmpty()) {
             throw new ResourceNotFoundException(this, path);
         }
         return newLayeredResource(matchingResources);
     }
 
     @Override
     public boolean hasPath(String path) {
         return any(origins, Functions.hasPath(path));
     }
 
     @Override
     protected boolean isFile(LayeredResource resource) {
         return resource.getFirst().isFile();
     }
 
     @Override
     protected boolean isDirectory(LayeredResource resource) {
         return resource.getFirst().isDirectory();
     }
 
     @Override
     protected boolean isEditable(LayeredResource resource) {
         return resource.getFirst().isEditable();
     }
 
     @Override
     protected String getPath(LayeredResource resource) {
         return resource.getFirst().getPath();
     }
 
     @Override
     protected String getName(LayeredResource resource) {
         return resource.getFirst().getName();
     }
 
     @Override
     protected long getLastModified(LayeredResource resource) {
         return resource.getFirst().getLastModified();
     }
 
     @Override
     protected List<LayeredResource> listChildren(LayeredResource resource) {
         final Function<Resource, Collection<Resource>> delegatedFunction = new Function<Resource, Collection<Resource>>() {
             @Override
             public Collection<Resource> apply(Resource layer) {
                 return layer.listChildren();
             }
         };
         final List<Resource> layers = resource.getLayers();
         return Lists.newArrayList(aggregateSet(layers, delegatedFunction));
     }
 
     @Override
     protected LayeredResource getParent(LayeredResource resource) {
         // This would only get the parents from the layers in the given resource, but that parent might exist in other resources too
         // final List<Resource> parents = Lists.transform(resource.getLayers(), Functions.getParent());
 
         // So instead, we pick the parent of the first layer, and do a getByPath, which feels a bit underwhelming.
         Resource parent = resource.getFirst().getParent();
         return parent != null ? getByPath(parent.getPath()) : null;
     }
 
     @Override
     protected InputStream doOpenStream(LayeredResource resource) throws IOException {
         return resource.getFirst().openStream();
     }
 
     @Override
     protected Reader openReader(LayeredResource resource) throws IOException {
         return resource.getFirst().openReader();
     }
 
     /**
      * Overridden to throw an exception; since we override {@link #openReader(LayeredResource)},
      * this method used in {@link AbstractResourceOrigin#openReader(info.magnolia.resourceloader.AbstractResource)}
      * should never be called.
      */
     @Override
     protected Charset getCharsetFor(LayeredResource resource) {
         throw new IllegalStateException("This method should not be called");
     }
 
     /**
      * @param <S> the type of "source" object on which the function is applied. ResourceOrigin or Resource.
      */
     protected <S> SortedSet<LayeredResource> aggregateSet(List<S> sources, Function<S, Collection<Resource>> delegatedFunction) {
         // First, we build a map <String path, List<Resource> forEachOrigin>
         final ImmutableListMultimap.Builder<String, Resource> builder = ImmutableListMultimap.builder();
 
         // for (ResourceOrigin source : origins) {
         for (S source : sources) {
             final Collection<Resource> result = delegatedFunction.apply(source);
 
             // this work but why not sanitize and use uniqueIndex to ensure we don't have twice the same path ? but then we can't pass to builder without further wrapping
             // final ImmutableMultimap<String, Resource> map = Multimaps.index(paths, TO_PATH);
             // TODO order of values must be add-order
             final SetMultimap<String, Resource> map = Multimaps.forMap(Maps.uniqueIndex(result, Functions.getPath()));
             builder.putAll(map);
         }
         final ImmutableListMultimap<String, Resource> map = builder.build();
 
         // Then we transform that map back to a Collection of LayeredResources
         final ImmutableSortedSet.Builder<LayeredResource> listBuilder = ImmutableSortedSet.orderedBy(Functions.<LayeredResource>compareByHandle());
 
         for (String path : map.keySet()) {
             final ImmutableList<Resource> resources = map.get(path);
             listBuilder.add(newLayeredResource(resources));
         }
         return listBuilder.build();
     }
 
     protected LayeredResource newLayeredResource(List<Resource> resources) {
         // Sanity checks -- are all the resources on the same path and are they all dir/files ?
         final String path = resources.get(0).getPath();
         final boolean isDirectory = resources.get(0).isDirectory();
         if (!all(resources, Functions.pathEquals(path))) {
             throw new IllegalStateException("Given resources don't match path [" + path + "]: " + resources);
         }
         final Predicate<Resource> dirOrFilePredicate = isDirectory ? Functions.isDirectory() : Functions.isFile();
         if (!all(resources, dirOrFilePredicate)) {
             log.warn("Resources at {} are not all directory/file: {}", path, resources);
             resources = Lists.newArrayList(Iterables.filter(resources, dirOrFilePredicate));
         }
         return new LayeredResource(this, path, resources);
     }
 
 }