/**
    * This file Copyright (c) 2009-2018 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.link;
  
  import info.magnolia.cms.beans.config.URI2RepositoryManager;
  import info.magnolia.cms.i18n.I18nContentSupport;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.repository.RepositoryConstants;
  
  import java.io.UnsupportedEncodingException;
  import java.net.URLEncoder;
  import java.util.Calendar;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.jcr.Node;
  import javax.jcr.PathNotFoundException;
  import javax.jcr.Property;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.time.FastDateFormat;
  import org.apache.jackrabbit.spi.commons.conversion.MalformedPathException;
  import org.apache.jackrabbit.spi.commons.conversion.PathParser;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Utility methods for various operations necessary for link transformations and handling.
   * This is actually a Business Facade providing an entry point to the link transformations.
   * Hence it will be renamed to LinkManager (MAGNOLIA-4765) soon.
   */
  public class LinkUtil {
  
      private static final FastDateFormat FINGERPRINT_FORMAT = FastDateFormat.getInstance("yyyy-MM-dd-HH-mm-ss");
  
      /**
       * Pattern that matches external and mailto: links.
       */
      public static final Pattern EXTERNAL_LINK_PATTERN = Pattern.compile("^(\\w*://|mailto:|javascript:|tel:).*");
  
      public static final String DEFAULT_EXTENSION = "html";
  
      public static final String DEFAULT_REPOSITORY = RepositoryConstants.WEBSITE;
  
      /**
       * Pattern to find a link.
       */
      public static final Pattern LINK_OR_IMAGE_PATTERN = Pattern.compile(
              "(<(a|img|embed) " + // start <a or <img
                      "[^>]*" +  // some attributes
                      "(href|src)[ ]*=[ ]*\")" + // start href or src
                      "([^\"]*)" + // the link
                      "(\"" + // ending "
                      "[^>]*" + // any attributes
                      ">)"); // end the tag
  
      /**
       * Pattern to find a magnolia formatted uuid link.
       */
      public static Pattern UUID_PATTERN = Pattern.compile(
              "\\$\\{link:\\{uuid:\\{([^\\}]*)\\}," // the uuid of the node
                      + "repository:\\{([^\\}]*)\\},"
                      + "(workspace:\\{[^\\}]*\\},)?" // is not supported anymore
                      + "(path|handle):\\{([^\\}]*)\\}"        // fallback handle should not be used unless the uuid is invalid
                     + "(,nodeData:\\{([^\\}]*)\\}," // in case we point to a binary (node data has no uuid!)
                     + "extension:\\{([^\\}]*)\\})?" // the extension to be used in rendering
                     + "\\}\\}"  // the handle
                     + "(#([^\\?\"]*))?" // anchor
                     + "(\\?([^\"]*))?"); // parameters
 
     /**
      * Pattern to find a link.
      */
     public static final Pattern LINK_PATTERN = Pattern.compile(
             "(/[^\\.\"#\\?]*)" + // the handle
                     "(\\.([\\w[^#\\?]]+))?" + // extension (if any)
                     "(#([^\\?\"]*))?" + // anchor
                     "(\\?([^\"]*))?" // parameters
     );
 
     /**
      * Pattern to find a image.
      */
     public static final Pattern IMAGE_PATTERN = Pattern.compile(
             "(<img " + // start <img
                     "[^>]*" +  // some attributes
                     "src[ ]*=[ ]*\")" + // start src
                     "([^\"]*)" + // the link
                     "(\"" + // ending "
                     "[^>]*" + // any attributes
                     ">)"); // end the tag
 
     private static final Logger log = LoggerFactory.getLogger(LinkUtil.class);
 
 
     //-- conversions from UUID - singles
 
     /**
      * Transforms a uuid to a handle beginning with a /. This path is used to get the page from the repository.
      * The editor needs this kind of links.
      */
     public static String convertUUIDtoHandle(String uuid, String workspaceName) throws LinkException {
         return createLinkInstance(workspaceName, uuid).getPath();
     }
 
     /**
      * Transforms a uuid to an uri. It does not add the context path. In difference from {@link info.magnolia.link.Link#getPath()},
      * this method will apply all uri to repository mappings as well as i18n.
      */
     public static String convertUUIDtoURI(String uuid, String workspaceName) throws LinkException {
         return LinkTransformerManager.getInstance().getAbsolute(false).transform(createLinkInstance(workspaceName, uuid));
     }
 
     //-- conversions to UUID - bulk
 
     /**
      * Parses provided html and transforms all the links to the magnolia format. Used during storing.
      *
      * @param html html code with links to be converted
      * @return html with changed hrefs
      */
     public static String convertAbsoluteLinksToUUIDs(String html) {
         if (html == null) {
             return null;
         }
         // get all link tags
         Matcher matcher = LINK_OR_IMAGE_PATTERN.matcher(html);
         StringBuffer res = new StringBuffer();
         while (matcher.find()) {
             final String href = matcher.group(4);
             if (!isExternalLinkOrAnchor(href)) {
                 try {
                     Link link = parseLink(href);
                     String linkStr = toPattern(link);
                     linkStr = StringUtils.replace(linkStr, "\\", "\\\\");
                     linkStr = StringUtils.replace(linkStr, "$", "\\$");
                     matcher.appendReplacement(res, "$1" + linkStr + "$5");
                 } catch (LinkException e) {
                     // this is expected if the link is an absolute path to something else
                     // than content stored in the repository
                     matcher.appendReplacement(res, "$0");
                     log.debug("can't parse link", e);
                 }
             } else {
                 matcher.appendReplacement(res, "$0");
             }
         }
         matcher.appendTail(res);
         return res.toString();
     }
 
     //-- conversions from UUID - bulk
 
     /**
      * Converts provided html with links in UUID pattern format to any other kind of links based on provided link transformer.
      *
      * @param str Html with UUID links
      * @param transformer Link transformer
      * @return converted html with links as created by provided transformer.
      * @see LinkTransformerManager
      */
     public static String convertLinksFromUUIDPattern(String str, LinkTransformer transformer) throws LinkException {
         if (str == null) {
             return null;
         }
         StringBuffer res = new StringBuffer();
         // first replace all image links in UUID pattern format with fingerprinted link based on provided link transformer
         Matcher imageMatcher = IMAGE_PATTERN.matcher(str);
         while (imageMatcher.find()) {
             Matcher matcher = UUID_PATTERN.matcher(imageMatcher.group());
             String imageMatcherGroup = imageMatcher.group();
             while (matcher.find()) {
                 Link link = createLinkInstance(matcher.group(1), matcher.group(2), matcher.group(5), matcher.group(7), matcher.group(8), matcher.group(10), matcher.group(12));
                 String replacement = transformer.transform(link);
                 try {
                     replacement = addFingerprintToLink(replacement, NodeTypes.LastModified.getLastModified(MgnlContext.getJCRSession(matcher.group(2)).getNodeByIdentifier(matcher.group(1))));
                 } catch (RepositoryException e) {
                     try {
                         final Node node = MgnlContext.getJCRSession(matcher.group(2)).getNode(matcher.group(5) != null ? matcher.group(5) : "");
                         replacement = addFingerprintToLink(replacement, NodeTypes.LastModified.getLastModified(node));
                     } catch (RepositoryException e2) {
                         log.warn("Can't find node with uuid {} or handle {} in repository {}. Figerprint to link was't added.", matcher.group(1), matcher.group(5), matcher.group(2), e2);
                     }
                 }
                 // Replace "\" with "\\" and "$" with "\$" since Matcher.appendReplacement treats these characters specially
                 replacement = StringUtils.replace(replacement, "\\", "\\\\");
                 replacement = StringUtils.replace(replacement, "$", "\\$");
                 if (replacement != null) {
                     imageMatcherGroup = imageMatcherGroup.replace(matcher.group(), replacement);
                 }
             }
             imageMatcher.appendReplacement(res, imageMatcherGroup);
         }
         imageMatcher.appendTail(res);
 
         // second replace all other links in UUID pattern
         Matcher matcher = UUID_PATTERN.matcher(res);
         res = new StringBuffer();
         while (matcher.find()) {
             Link link = createLinkInstance(matcher.group(1), matcher.group(2), matcher.group(5), matcher.group(7), matcher.group(8), matcher.group(10), matcher.group(12));
             String replacement = transformer.transform(link);
             // Replace "\" with "\\" and "$" with "\$" since Matcher.appendReplacement treats these characters specially
             replacement = StringUtils.replace(replacement, "\\", "\\\\");
             replacement = StringUtils.replace(replacement, "$", "\\$");
             matcher.appendReplacement(res, replacement);
         }
         matcher.appendTail(res);
         return res.toString();
     }
 
     public static String convertLinksFromUUIDPattern(String str) throws LinkException {
         LinkTransformer transformer = LinkTransformerManager.getInstance().getBrowserLink(null);
         return convertLinksFromUUIDPattern(str, transformer);
     }
 
     /**
      * Determines if the given link is internal and relative.
      */
     public static boolean isInternalRelativeLink(String href) {
         // TODO : this could definitely be improved
         return !isExternalLinkOrAnchor(href) && !href.startsWith("/");
     }
 
     /**
      * Determines whether the given link is external link or anchor (i.e. returns true for all non translatable links).
      */
     public static boolean isExternalLinkOrAnchor(String href) {
         return LinkUtil.EXTERNAL_LINK_PATTERN.matcher(href).matches() || href.startsWith("#");
     }
 
     /**
      * Make a absolute path relative. It adds ../ until the root is reached
      *
      * @param absolutePath absolute path
      * @param url page to be relative to
      * @return relative path
      */
     public static String makePathRelative(String url, String absolutePath) {
         String fromPath = StringUtils.substringBeforeLast(url, "/");
         String toPath = StringUtils.substringBeforeLast(absolutePath, "/");
 
         // reference to parent folder
         if (StringUtils.equals(fromPath, toPath) && StringUtils.endsWith(absolutePath, "/")) {
             return ".";
         }
 
         String[] fromDirectories = StringUtils.split(fromPath, "/");
         String[] toDirectories = StringUtils.split(toPath, "/");
 
         int pos = 0;
         while (pos < fromDirectories.length && pos < toDirectories.length && fromDirectories[pos].equals(toDirectories[pos])) {
             pos++;
         }
 
         StringBuilder rel = new StringBuilder();
         for (int i = pos; i < fromDirectories.length; i++) {
             rel.append("../");
         }
 
         for (int i = pos; i < toDirectories.length; i++) {
             rel.append(toDirectories[i]).append("/");
         }
 
         rel.append(StringUtils.substringAfterLast(absolutePath, "/"));
 
         return rel.toString();
     }
 
     /**
      * Maps a path to a repository.
      *
      * @param path URI
      * @return repository denoted by the provided URI.
      */
     public static String mapPathToRepository(String path) {
         String workspaceName = getURI2RepositoryManager().getRepository(path);
         if (StringUtils.isEmpty(workspaceName)) {
             workspaceName = DEFAULT_REPOSITORY;
         }
         return workspaceName;
     }
 
     /**
      * Appends a parameter to the given url, using ?, or & if there are already
      * parameters in the given url. <strong>Warning:</strong> It does not
      * <strong>replace</strong> an existing parameter with the same name.
      */
     public static void addParameter(StringBuffer uri, String name, String value) {
         if (uri.indexOf("?") < 0) {
             uri.append('?');
         } else {
             uri.append('&');
         }
         uri.append(name).append('=');
         try {
             uri.append(URLEncoder.encode(value, "UTF-8"));
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException("It seems your system does not support UTF-8 !?", e);
         }
     }
 
     /**
      * Creates absolute link including context path for provided Property.
      *
      * @return Absolute link to the provided Property.
      */
     public static String createAbsoluteLink(Property property) throws LinkException {
         if (property == null) {
             return null;
         }
         return LinkTransformerManager.getInstance().getAbsolute().transform(createLinkInstance(property));
     }
 
     /**
      * Creates absolute link including context path to the provided content and performing all URI2Repository mappings and applying locales.
      *
      * @param uuid UUID of content to create link to.
      * @param workspaceName Name of the repository where content is located.
      * @return Absolute link to the provided content.
      * @see info.magnolia.cms.i18n.AbstractI18nContentSupport
      */
     public static String createAbsoluteLink(String workspaceName, String uuid) throws RepositoryException {
         Node jcrNode = MgnlContext.getJCRSession(workspaceName).getNodeByIdentifier(uuid);
         return createAbsoluteLink(jcrNode);
     }
 
     /**
      * Creates absolute link including context path to the provided node and performing all URI2Repository mappings and applying locales.
      *
      * @return Absolute link to the provided content.
      */
     public static String createAbsoluteLink(Node node) {
         if (node == null) {
             return null;
         }
         return LinkTransformerManager.getInstance().getAbsolute().transform(createLinkInstance(node));
     }
 
     /**
      * Creates a complete url to access given node from external systems applying all the URI2Repository mappings and locales.
      */
     public static String createExternalLink(Node node) {
         if (node == null) {
             return null;
         }
         return LinkTransformerManager.getInstance().getCompleteUrl().transform(createLinkInstance(node));
     }
 
     /**
      * Creates link guessing best possible link format from current site and provided node.
      *
      * @param node Node to create link for.
      * @return Absolute link to the provided Node.
      */
     public static String createLink(Node node) {
         if (node == null) {
             return null;
         }
         try {
             return LinkTransformerManager.getInstance().getBrowserLink(node.getPath()).transform(createLinkInstance(node));
         } catch (RepositoryException e) {
             log.debug(e.getMessage(), e);
         }
         return null;
     }
 
     /**
      * Creates link guessing best possible link format from current site and provided Property.
      *
      * @param property Property to create link for.
      * @return Absolute link to the provided Property.
      */
     public static String createLink(Property property) throws LinkException {
         if (property == null) {
             return null;
         }
         try {
             return LinkTransformerManager.getInstance().getBrowserLink(property.getParent().getPath()).transform(createLinkInstance(property));
         } catch (RepositoryException e) {
             throw new LinkException(e.getMessage(), e);
         }
     }
 
     /**
      * Creates link guessing best possible link format from current site and provided content.
      *
      * @param uuid UUID of content to create link to.
      * @param workspaceName Name of the repository where content is located.
      * @return Absolute link to the provided content.
      * @see info.magnolia.cms.i18n.AbstractI18nContentSupport
      */
     public static String createLink(String workspaceName, String uuid) throws RepositoryException {
         Node node = MgnlContext.getJCRSession(workspaceName).getNodeByIdentifier(uuid);
         return createLink(node);
     }
 
     /**
      * Creates Link to provided Node.
      *
      * @return Link to provided Node.
      */
     public static Link createLinkInstance(Node node) {
         return new Link(node);
     }
 
     public static Link createLinkInstance(Property property) throws LinkException {
         return new Link(property);
     }
 
     /**
      * Creates link to the content denoted by repository and uuid.
      *
      * @param workspaceName Parent repository of the content of interest.
      * @param uuid UUID of the content to create link to.
      * @return link to the content with provided UUID.
      */
     public static Link createLinkInstance(String workspaceName, String uuid) throws LinkException {
         try {
             return new Link(MgnlContext.getJCRSession(workspaceName).getNodeByIdentifier(uuid));
         } catch (RepositoryException e) {
             throw new LinkException("can't get node with uuid " + uuid + " and repository " + workspaceName);
         }
     }
 
     /**
      * Creates link to the content identified by the repository and path. Link will use specified extension and will also contain the anchor and parameters if specified.
      *
      * @param workspaceName Source repository for the content.
      * @param path Path to the content of interest.
      * @param extension Optional extension to be used in the link
      * @param anchor Optional link anchor.
      * @param parameters Optional link parameters.
      * @return Link pointing to the content denoted by repository and path including extension, anchor and parameters if such were provided.
      */
     public static Link createLinkInstance(String workspaceName, String path, String extension, String anchor, String parameters) throws LinkException {
         Node node = null;
         String fileName = null;
         String nodeDataName = null;
         Property property = null;
         try {
             Session session = MgnlContext.getJCRSession(workspaceName);
 
             boolean exists = false;
             try {
                 PathParser.checkFormat(path);
             } catch (MalformedPathException e) {
                 // we first check for path incl. the file name. While file name might not be necessarily part of the path, it might contain also non ascii chars. If that is the case, parsing exception will occur so we know that path with filename can't exist.
             }
             exists = session.itemExists(path) && !session.propertyExists(path);
             if (exists) {
                 node = session.getNode(path);
             }
             if (node == null) {
                 if (session.nodeExists(path)) {
                     node = session.getNode(path);
                 }
                 if (node != null && node.isNodeType(NodeTypes.Resource.NAME) && node.hasProperty("fileName")) {
                     fileName = node.getProperty("fileName").getString();
                 }
                 if (session.propertyExists(path)) {
                     nodeDataName = StringUtils.substringAfterLast(path, "/");
                     path = StringUtils.substringBeforeLast(path, "/");
                     property = node.getProperty(nodeDataName);
                 }
             }
             if (node == null) {
                 throw new LinkException("can't find node " + path + " in repository " + workspaceName);
             }
         } catch (RepositoryException e) {
             throw new LinkException("can't get node with path " + path + " from repository " + workspaceName);
         }
 
         Linkl#Link">Link link = new Link(node);
         link.setAnchor(anchor);
         link.setExtension(extension);
         link.setParameters(parameters);
         link.setFileName(fileName);
         link.setPropertyName(nodeDataName);
         link.setProperty(property);
         link.setPath(path);
         return link;
     }
 
     /**
      * Creates link based on provided parameters. Should the uuid be non existent or the fallback handle invalid, creates nonetheless an <em>"undefined"</em> {@link Link} object,
      * pointing to the non existing uuid so that broken link detection tools can find it.
      *
      * @param uuid UUID of the content
      * @param workspaceName Content repository name.
      * @param fallbackHandle Optional fallback content handle.
      * @param nodeDataName Content node data name for binary data.
      * @param extension Optional link extension.
      * @param anchor Optional link anchor.
      * @param parameters Optional link parameters.
      * @return Link pointing to the content denoted by uuid and repository. Link is created using all provided optional values if present.
      */
     public static Link createLinkInstance(String uuid, String workspaceName, String fallbackHandle, String nodeDataName, String extension, String anchor, String parameters) throws LinkException {
         final String defaultRepository = StringUtils.defaultIfEmpty(workspaceName, RepositoryConstants.WEBSITE);
         Link link;
         try {
             link = createLinkInstance(defaultRepository, uuid);
         } catch (LinkException e) {
             try {
                 final Node node = MgnlContext.getJCRSession(defaultRepository).getNode(fallbackHandle != null ? fallbackHandle : "");
                 link = createLinkInstance(node);
             } catch (PathNotFoundException pnfe) {
                 log.warn("Can't find node with uuid {} or handle {} in repository {}", uuid, fallbackHandle, defaultRepository);
                 link = new Link();
                 link.setUUID(uuid);
             } catch (RepositoryException re) {
                 log.warn("Can't find node with uuid {} or handle {} in repository {}", uuid, fallbackHandle, defaultRepository);
                 link = new Link();
                 link.setUUID(uuid);
             }
         }
         link.setFallbackPath(fallbackHandle);
         link.setPropertyName(nodeDataName);
         link.setExtension(extension);
         link.setAnchor(anchor);
         link.setParameters(parameters);
 
         return link;
     }
 
     /**
      * Parses UUID link pattern string and converts it into a Link object.
      *
      * @param uuidLink String containing reference to content as a UUID link pattern.
      * @return Link to content referenced in the provided text.
      */
     public static Link parseUUIDLink(String uuidLink) throws LinkException {
         Matcher matcher = UUID_PATTERN.matcher(uuidLink);
         if (matcher.matches()) {
             return createLinkInstance(matcher.group(1), matcher.group(2), matcher.group(5), matcher.group(7), matcher.group(8), matcher.group(10), matcher.group(12));
         }
         throw new LinkException("can't parse [ " + uuidLink + "]");
     }
 
     /**
      * Parses provided URI to the link.
      *
      * @param link URI representing path to piece of content
      * @return Link pointing to the content represented by provided URI
      */
     public static Link parseLink(String link) throws LinkException {
         // ignore context handle if existing
         link = StringUtils.removeStart(link, MgnlContext.getContextPath());
 
         Matcher matcher = LINK_PATTERN.matcher(link);
         if (matcher.matches()) {
             String orgHandle = matcher.group(1);
             orgHandle = Components.getComponent(I18nContentSupport.class).toRawURI(orgHandle);
             String workspaceName = getURI2RepositoryManager().getRepository(orgHandle);
             String handle = getURI2RepositoryManager().getHandle(orgHandle);
             return createLinkInstance(workspaceName, handle, matcher.group(3), matcher.group(5), matcher.group(7));
         }
         throw new LinkException("can't parse [ " + link + "]");
     }
 
     /**
      * Converts provided Link to an UUID link pattern.
      *
      * @param link Link to convert.
      * @return UUID link pattern representation of provided link.
      */
     public static String toPattern(Link link) {
         return "${link:{"
                 + "uuid:{" + link.getUUID() + "},"
                 + "repository:{" + link.getWorkspace() + "},"
                 + "path:{" + link.getPath() + "}," // original handle represented by the uuid
                 + "nodeData:{" + StringUtils.defaultString(link.getPropertyName()) + "}," // in case of binaries
                 + "extension:{" + StringUtils.defaultString(link.getExtension()) + "}" // the extension to use if no extension can be resolved otherwise
                 + "}}"
                 + (StringUtils.isNotEmpty(link.getAnchor()) ? "#" + link.getAnchor() : "")
                 + (StringUtils.isNotEmpty(link.getParameters()) ? "?" + link.getParameters() : "");
     }
 
     private static URI2RepositoryManager getURI2RepositoryManager() {
         return Components.getComponent(URI2RepositoryManager.class);
     }
 
     /**
      * Insert a finger-print into a link that is based on the last modified date.
      * This way we can use far future cache headers on images/assets, and simply change the filename for the
      * asset when the asset has changed and we want browsers & proxies to take up the new asset from the server.
      * Appends the date as a string directly before the file extension.
      *
      * @return The original link with the date based finger-print inserted, null if the passed link is null or the original link if lastModified is null.
      */
     public static String addFingerprintToLink(String link, Calendar lastModified) {
         if (StringUtils.isBlank(link)) {
             return null;
         }
         String fingerprintedLink = "";
         if (lastModified == null) {
             return link;
         }
 
         String fingerprint = FINGERPRINT_FORMAT.format(lastModified.getTime());
 
         // Determine where to place the fingerprint.
         int lastDot = link.lastIndexOf('.');
         int lastSlash = link.lastIndexOf('/');
 
         if (lastDot > lastSlash && lastDot != -1) {
             fingerprintedLink = link.substring(0, lastDot) + "." + fingerprint + link.substring(lastDot);
         } else {
             // No file extension - just add fingerprint at end.
             fingerprintedLink = link + "." + fingerprint;
         }
 
         return fingerprintedLink;
     }
 
     /**
      * Remove the extension and fingerPrint if present.
      * Example: (print-logo.2012-11-20-12-15-20.pdf --> print-logo)
      */
     public static String removeFingerprintAndExtensionFromLink(String originalPath) {
 
         String subPath = StringUtils.substringBeforeLast(originalPath, ".");
         // Get Finger print
         String fingerPrint = StringUtils.substringAfterLast(subPath, ".");
         if (fingerPrint != null && fingerPrint.matches("\\d{4}-\\d{2}-\\d{2}-\\d{2}-\\d{2}-\\d{2}")) {
             return StringUtils.substringBeforeLast(subPath, ".");
         } else {
             return subPath;
         }
     }
 }