/**
    * 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.dam.templating.functions;
  
  import info.magnolia.dam.api.Asset;
  import info.magnolia.dam.api.AssetProvider;
  import info.magnolia.dam.api.AssetProviderRegistry;
  import info.magnolia.dam.api.AssetProviderRegistry.NoSuchAssetRendererException;
  import info.magnolia.dam.api.AssetQuery;
  import info.magnolia.dam.api.AssetRenderer;
  import info.magnolia.dam.api.AssetRendition;
  import info.magnolia.dam.api.Folder;
  import info.magnolia.dam.api.Item;
  import info.magnolia.dam.api.ItemKey;
  import info.magnolia.dam.api.PathAwareAssetProvider;
  import info.magnolia.dam.api.metadata.AssetMetadata;
  import info.magnolia.dam.api.metadata.DublinCore;
  import info.magnolia.dam.api.metadata.MagnoliaAssetMetadata;
  import info.magnolia.dam.jcr.JcrAsset;
  import info.magnolia.dam.jcr.JcrAssetProvider;
  import info.magnolia.dam.jcr.JcrFolder;
  import info.magnolia.jcr.wrapper.HTMLEscapingNodeWrapper;
  
  import java.beans.BeanInfo;
  import java.beans.Introspector;
  import java.beans.PropertyDescriptor;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import javax.inject.Inject;
  import javax.inject.Singleton;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Predicate;
  import com.google.common.collect.Iterators;
  import com.google.common.collect.Lists;
  import com.google.common.collect.UnmodifiableIterator;
  import com.google.common.net.MediaType;
  
  /**
   * Asset templating function exposed in FTL's as "damfn". This class exposed
   * useful methods for FTL's and Model Class.
   */
  @Singleton
  public class DamTemplatingFunctions {
  
      public static final String METADATA_KEY_ACCESS = "metadata";
      public static final String DAM_VERSION_1_PROVIDER_ID = "jcr";
  
      private static final Logger log = LoggerFactory.getLogger(DamTemplatingFunctions.class);
  
      private final AssetProviderRegistry providerRegistry;
  
      @Inject
      public DamTemplatingFunctions(AssetProviderRegistry providerRegistry) {
          this.providerRegistry = providerRegistry;
      }
  
     /**
      * @param itemKey {@link ItemKey#asString()}.
      * @return null if asset was not found.
      */
     public Asset getAsset(String itemKey) {
         Item item = getItem(itemKey, true);
         if (item != null) {
             return (Asset) item;
         }
         return null;
     }
 
     /**
      * @param providerId
      * @param assetPath relative path to the Asset.
      * @return null if asset was not found.
      * @throws IllegalArgumentException if the requested provider is not an implementation of {@link PathAwareAssetProvider}.
      */
     public Asset getAsset(String providerId, String assetPath) {
         Item item = getItem(providerId, assetPath, true);
         if (item != null) {
             return (Asset) item;
         }
         return null;
     }
 
     /**
      * @param providerId
      * @param assetPath absolute path to the Asset.
      * @return null if asset was not found.
      * @throws IllegalArgumentException if the requested provider is not an implementation of {@link PathAwareAssetProvider}.
      */
     public Asset getAssetForAbsolutePath(String providerId, String absoluteAssetPath) {
         AssetProvider provider = getProviderForId(providerId);
         if (provider != null) {
             String providerRootPath = provider.getRootFolder().getPath();
             if(!StringUtils.endsWith(providerRootPath, "/")) {
                 providerRootPath += "/";
             }
             String relativeAssetPath = StringUtils.removeStart(absoluteAssetPath, providerRootPath);
             log.debug("Convert absolute '{}' to relative '{}' path", absoluteAssetPath, relativeAssetPath);
             return getAsset(providerId, relativeAssetPath);
         }
         return null;
     }
 
     /**
      * @param itemKey {@link ItemKey#asString()}.
      * @return null if folder was not found.
      */
     public Folder getFolder(String itemKey) {
         Item item = getItem(itemKey, false);
         if (item != null) {
             return (Folder) item;
         }
         return null;
     }
 
     /**
      * @param providerId
      * @param folderPath relative path to the Folder.
      * @return null if folder was not found.
      * @throws IllegalArgumentException if the requested provider is not an implementation of {@link PathAwareAssetProvider}.
      */
     public Folder getFolder(String providerId, String folderPath) {
         Item item = getItem(providerId, folderPath, false);
         if (item != null) {
             return (Folder) item;
         }
         return null;
     }
 
     /**
      * Set {@link AssetQuery#includesFolders()} or {@link AssetQuery#includesAssets()} in order to restrict the returned Items.
      */
     public Iterator<Item> getItems(String providerId, AssetQuery assetQuery) {
         AssetProvider provider = getProviderForId(providerId);
         if (provider != null) {
             try {
                 return provider.list(assetQuery);
             } catch (Exception e) {
                 log.warn("Exception occurred for the following query '{}' and asset provider '{}' : {}", assetQuery.toString(), providerId, e.getMessage());
             }
         }
         return null;
     }
 
     /**
      * Based on the passed {@link MediaType} and {@link Asset}, get an appropriate {@link AssetRenderer}.
      * From the {@link AssetRenderer} get the {@link AssetRendition} for the given renditionName.
      */
     public AssetRendition getRendition(Asset asset, MediaType mediaType, String renditionName) {
         AssetRenderer renderer = null;
         try {
             renderer = providerRegistry.getRendererFor(asset, mediaType);
             if (renderer.canRender(asset, mediaType)) {
                 return renderer.render(asset, mediaType, renditionName);
             }
         } catch (NoSuchAssetRendererException nsare) {
             log.warn("No rendition found for the following assetId '{}', mediaType '{}' and renditionName '{}'. Exception: {} ", asset.getItemKey().asString(), mediaType.toString(), renditionName, nsare);
         }
         return null;
     }
 
     /**
      * @return {@link AssetRendition} based on the {@link MediaType} builded from the {@link Asset#getMimeType()}.
      */
     public AssetRendition getRendition(Asset asset, String renditionName) {
         return getRendition(asset, MediaType.parse(asset.getMimeType()), renditionName);
     }
 
     public AssetRendition getRendition(String itemKey, String renditionName) {
         Asset asset = getAsset(itemKey);
         if (asset == null) {
             log.warn("Trying to get asset with item key {} returned null.", itemKey);
             return null;
         }
         return getRendition(asset, MediaType.parse(asset.getMimeType()), renditionName);
     }
 
     public AssetRendition getRendition(String itemKey, MediaType mediaType, String renditionName) {
         return getRendition(getAsset(itemKey), mediaType, renditionName);
     }
 
     /**
      * @return {@link AssetProvider#provides(MediaType)} or false in case of any exceptions.
      */
     public boolean provides(String providerId, MediaType mediaType) {
         try {
             return providerRegistry.getProviderById(providerId).provides(mediaType);
         } catch (Exception e) {
             log.warn("Exception occurred for the following reason {}. False will be retruned. ", e.getMessage());
             return false;
         }
     }
 
     /**
      * Create a read only map containing: <br>
      * - All asset property names and values <br>
      * - a metadata child map containing all supported metadata property names and values.
      */
     public Map<String, Object> getAssetMap(Asset asset) {
         // TODO To Remove once AssetProvider support this art of call or when MGNLDAM-418 is resolved.
         Map<String, Class<? extends AssetMetadata>> supportedMetadata = new HashMap<String, Class<? extends AssetMetadata>>();
         supportedMetadata.put("mgnl", MagnoliaAssetMetadata.class);
         supportedMetadata.put("dc", DublinCore.class);
         // TODO find a better way to filer the non desired property
         List<String> rejectedGetter = Arrays.asList("getAssetProvider", "getMetadata", "getContentStream", "getParent", "getClass");
 
         // Set Asset Property
         Map<String, Object> rootMap = convertBeanToMap(asset, rejectedGetter);
         // Create the first level of metadata
         Map<String, Object> metaDatasMap = new HashMap<String, Object>();
         // Add all supported metadata's
         for (Entry<String, Class<? extends AssetMetadata>> entry : supportedMetadata.entrySet()) {
             AssetMetadata metaData = asset.getMetadata(entry.getValue());
             Map<String, Object> metaDataMap = convertBeanToMap(metaData, rejectedGetter);
             metaDatasMap.put(entry.getKey(), Collections.unmodifiableMap(metaDataMap));
         }
         rootMap.put(METADATA_KEY_ACCESS, Collections.unmodifiableMap(metaDatasMap));
 
         return Collections.unmodifiableMap(rootMap);
     }
 
     public Map<String, Object> getAssetMap(String itemKey) {
         return getAssetMap(getAsset(itemKey));
     }
 
     /**
      * @return The {@link Asset#getLink()} or null in case of exception or if Asset is not found.
      */
     public String getAssetLink(String assetKey) {
         Asset asset = getAsset(assetKey);
         if (asset != null) {
             return asset.getLink();
         }
         return null;
     }
 
     /**
      * @return The {@link AssetRendition#getLink()} or null in case of exception or if {@link Asset} or {@link AssetRendition} are not found.
      */
     public String getAssetLink(String itemKey, String renditionName) {
         AssetRendition rendition = getRendition(itemKey, renditionName);
         if (rendition != null) {
             return rendition.getLink();
         }
         return null;
     }
 
     /**
      * @return The {@link AssetRendition#getLink()} or null in case of exception or if {@link Asset} or {@link AssetRendition} are not found.
      */
     public String getAssetLink(Asset asset, MediaType mediaType, String renditionName) {
         AssetRendition rendition = getRendition(asset, mediaType, renditionName);
         if (rendition != null) {
             return rendition.getLink();
         }
         return null;
     }
 
     /**
      * @return {@link #getAssetMap(Asset)} for the {@link Asset} corresponding to the assetKey. Null in case of exception or if the {@link Asset} was not found.
      */
     public Map<String, Object> getAssetMapForAssetId(String assetKey) {
         Asset asset = getAsset(assetKey);
         if (asset != null) {
             return getAssetMap(asset);
         }
         return null;
     }
 
     // ==== Methods of the previous DamTemplatingFunctions API which are implemented for compatibility reason
 
     /**
      * Retrieve an Asset List based on a folder identifier ({@link ItemKey#asString()}).
      *
      * @return The Assets List found for this folder identifier, or an Empty
      * List if nothing found or in case of Exception.
      * @deprecated use {@link #getFolder(String)} and the {@link Folder#getChildren()}.
      */
     @Deprecated
     public List<Asset> getAssetsFromFolderId(String folderKey) {
         Folder folder = getFolder(folderKey);
         if (folder != null) {
             return Lists.newArrayList(onlyAssets(folder.getChildren()));
         }
         return new ArrayList<Asset>();
     }
 
     /**
      * @return {@link Asset} found under this path for the {@link info.magnolia.dam.jcr.DamConstants#DEFAULT_JCR_PROVIDER_ID} or null otherwise.
      * @deprecated use {@link #getAssetForAbsolutePath(String, String)}.
      */
     @Deprecated
     public Asset getAssetForPath(String assetPath) {
         return getAssetForAbsolutePath(DAM_VERSION_1_PROVIDER_ID, assetPath);
     }
 
     /**
      * @deprecated use {@link #getAsset(String)}.
      */
     @Deprecated
     public Asset getAssetForId(String assetIdentifier) {
         return getAsset(assetIdentifier);
     }
 
     /**
      * @return The specified {@link Asset} based on the rendition Name. <br>
      * In case of no rendition found, return the same Asset. <br>
      * Return null in case of exception.
      * @deprecated use {@link #getRendition(Asset, MediaType, String)}.
      */
     @Deprecated
     public Asset getAssetRendition(Asset asset, String renditionName) {
         AssetRendition assetRendition = getRendition(asset, renditionName);
         if (assetRendition != null) {
             return getAssetRendition(assetRendition);
         }
         return asset;
     }
 
     /**
      * @return The {@link Asset} based on the rendition Name and itemKey. <br>
      * In case of no rendition found, return the same Asset. <br>
      * Return null in case of exception.
      * @deprecated use {@link #getRendition(String, MediaType, String)}.
      */
     @Deprecated
     public Asset getAssetRenditionForAssetId(String itemKey, String renditionName) {
         AssetRendition assetRendition = getRendition(itemKey, renditionName);
         if (assetRendition != null) {
             return getAssetRendition(assetRendition);
         }
         return getAsset(itemKey);
     }
 
     /**
      * @return if the rendition is already an {@link Asset} instance, return the rendition as an {@link Asset}. Else call {@link AssetRendition#getAsset()}.
      */
     private Asset getAssetRendition(AssetRendition assetRendition) {
         if (assetRendition != null) {
             if (assetRendition instanceof Asset) {
                 return (Asset) assetRendition;
             }
             return assetRendition.getAsset();
         }
         return null;
     }
 
     /**
      * @return The {@link Asset#getLink()} or null in case of exception or if Asset is not found.
      * @deprecated use {@link #getAssetLink(String)}.
      */
     @Deprecated
     public String getAssetLinkForId(String assetKey) {
         return getAssetLink(assetKey);
     }
 
     /**
      * @return The {@link AssetRendition#getLink()} or null in case of exception or if Asset is not found.
      * @deprecated use {@link #getAssetLink(String, String)}.
      */
     @Deprecated
     public String getAssetLinkForId(String itemKey, String renditionName) {
         return getAssetLink(itemKey, renditionName);
     }
 
     /**
      * @return an Asset List found for this asset assetQuery and {@link info.magnolia.dam.jcr.DamConstants#DEFAULT_JCR_PROVIDER_ID} assetProvider, or an empty
      * list if nothing found or in case of Exception.
      * @deprecated use {@link #getItems(String, AssetQuery)}.
      */
     @Deprecated
     public List<Asset> getAssetsForFilter(AssetQuery assetQuery) {
         Iterator<Item> items = getItems(DAM_VERSION_1_PROVIDER_ID, assetQuery);
         if (items != null) {
             return Lists.newArrayList(onlyAssets(items));
         }
         return new ArrayList<Asset>();
     }
 
     @SuppressWarnings("unchecked")
     // can cast to <Asset> because non-Assets are removed
     private static UnmodifiableIterator<Asset> onlyAssets(Iterator<? extends Item> unfiltered) {
         return (UnmodifiableIterator<Asset>) Iterators.filter(unfiltered, new Predicate<Item>() {
             @Override
             public boolean apply(Item input) {
                 return input.isAsset();
             }
         });
     }
 
     /**
      * Convert all bean properties with getter's to a {@link Map}.
      *
      * @param rejectedGetter do not create a {@link Map} entry for getter's that are part of this list.
      */
     private Map<String, Object> convertBeanToMap(Object source, List<String> rejectedGetter) {
         Map<String, Object> map = new HashMap<String, Object>();
         try {
             BeanInfo info = Introspector.getBeanInfo(source.getClass());
             for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
                 Method reader = pd.getReadMethod();
                 if (reader != null && !rejectedGetter.contains(reader.getName()))
                     map.put(pd.getName(), reader.invoke(source));
             }
         } catch (Exception e) {
             log.warn("Could not populate the map with the bean property", e);
         }
         return map;
     }
 
     /**
      * @return the Item linked to the itemKey or null in any case of exception.
      */
     private Item getItem(String itemKey, boolean assetItem) {
         try {
             validateItemKey(itemKey);
             ItemKey key = ItemKey.from(itemKey);
             Item item = this.providerRegistry.getProviderFor(key).getItem(key);
 
             return determineItemToReturn(item, assetItem);
         } catch (Exception e) {
             log.warn("The following ItemKey '{}' generate exeptions when trying to retrieve the associated Item : {}", itemKey, e.getMessage());
         }
         return null;
     }
     /**
      * @return the item to be returned if it matches the requested type (folder or asset), else null. If the item is a JcrAsset or a JcrFolder it is wrapped in HTMLEscapingNodeWrapper in order to prevent XSS
      * (the elements in the folder being automatically wrapped upon calling its getNodes(..)).
      */
     private Item determineItemToReturn(Item item, boolean assetItem) {
         boolean isAsset = assetItem && item.isAsset();
         boolean isFolder = !assetItem && item.isFolder();
         boolean isJcrAsset = isAsset && (item instanceof JcrAsset && item.getAssetProvider() instanceof JcrAssetProvider);
         boolean isJcrFolder = isFolder && (item instanceof JcrFolder && item.getAssetProvider() instanceof JcrAssetProvider);
 
         if(isJcrAsset) {
             return new JcrAsset((JcrAssetProvider) item.getAssetProvider(), new HTMLEscapingNodeWrapper(((JcrAsset)item).getNode(), true));
 
         } else if(isJcrFolder) {
             return new JcrFolder((JcrAssetProvider) item.getAssetProvider(), new HTMLEscapingNodeWrapper(((JcrFolder)item).getNode(), true));
 
         } else if(isAsset || isFolder){
             return item;
         }
         log.warn("An '{}' was requested, but a '{}' was found", (assetItem ? "Asset" : "Folder"), (!assetItem ? "Asset" : "Folder"));
         return null;
     }
 
     /**
      * Validate ItemKey.
      *
      * @throws IllegalArgumentException if the itemKey is blank or not valid.
      */
     private void validateItemKey(String itemKey) {
         if (StringUtils.isBlank(itemKey)) {
             throw new IllegalArgumentException("ItemKey is null or blank.");
         }
         if (!ItemKey.isValid(itemKey)) {
             throw new IllegalArgumentException("ItemKey is not valide.");
         }
     }
 
     /**
      * @return the Item defined by the itemPath and providerId or null in any case of exception.
      * @throws IllegalArgumentException if the requested provider is not an implementation of {@link PathAwareAssetProvider}.
      */
     private Item getItem(String providerId, String itemPath, boolean assetItem) {
         AssetProvider provider = getProviderForId(providerId);
         if (provider != null) {
             // Check if the provider support path
             if (!(provider instanceof PathAwareAssetProvider)) {
                 throw new IllegalArgumentException("The provider '" + providerId + "' does not provide implementation for '" + PathAwareAssetProvider.class.getName() + "'. Retrieving an Item by path is not a supported operation ");
             }
             try {
                 Item item = ((PathAwareAssetProvider) provider).getItem(itemPath);
                 return determineItemToReturn(item, assetItem);
             } catch (Exception e) {
                 log.warn("The following itemPath '{}' for the provider '{}' generated exeptions when trying to retrieve the associated Asset : {}", itemPath, providerId, e.getMessage());
             }
         }
         return null;
     }
 
     /**
      * @return the registered provider or null in case of exception.
      */
     private AssetProvider getProviderForId(String providerId) {
         try {
             return this.providerRegistry.getProviderById(providerId);
         } catch (Exception e) {
             log.warn("Exception occurred during the retrieval of the desired Asset Provider", e);
             return null;
         }
     }
 
 }