/*
    * #%L
    * wcm.io
    * %%
    * Copyright (C) 2019 wcm.io
    * %%
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * #L%
   */
  package io.wcm.wcm.ui.granite.util;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.lang3.Strings;
  import org.apache.sling.api.SlingHttpServletRequest;
  import org.apache.sling.api.resource.ResourceResolver;
  import org.jetbrains.annotations.NotNull;
  import org.osgi.annotation.versioning.ProviderType;
  
  import com.adobe.granite.ui.components.ComponentHelper;
  import com.adobe.granite.ui.components.Config;
  import com.adobe.granite.ui.components.ExpressionHelper;
  import com.day.text.Text;
  
  /**
   * Helper class for path-based GraniteUI components to resolve the root path.
   *
   * <p>
   * Resolution order for root path detection:
   * </p>
   * <ul>
   * <li>Reads configured root path from <code>rootPath</code> property</li>
   * <li>Calls the provided root path detector implementation to detect root path from context</li>
   * <li>Reads fallback root path from <code>fallbackRootPath</code> property</li>
   * <li>Uses fallback root path provided for this instance</li>
   * <li>Fallback to "/"</li>
   * </ul>
   *
   * <p>
   * Additionally the root path is modified:
   * </p>
   * <ul>
   * <li>If an <code>appendPath</code> property is configured it is appended to the detected root path</li>
   * <li>Than it is checked if the root path is valid - if not the next-valid parent path is returned</li>
   * </ul>
   */
  @ProviderType
  public final class RootPathResolver {
  
    static final String PN_ROOT_PATH = "rootPath";
    static final String PN_APPEND_PATH = "appendPath";
    static final String PN_FALLBACK_PATH = "fallbackRootPath";
    static final String DEFAULT_FALLBACK_ROOT_PATH = "/";
  
    private final ComponentHelper cmp;
    private final Config cfg;
    private final ExpressionHelper ex;
    private final SlingHttpServletRequest request;
    private final ResourceResolver resourceResolver;
  
    private RootPathDetector rootPathDetector;
    private String fallbackRootPath = DEFAULT_FALLBACK_ROOT_PATH;
  
    /**
     * Creates a new RootPathResolver instance.
     * @param cmp Component helper
     * @param request Request
     */
    public RootPathResolver(@NotNull ComponentHelper cmp, @NotNull SlingHttpServletRequest request) {
      this.cmp = cmp;
      this.cfg = cmp.getConfig();
      this.ex = cmp.getExpressionHelper();
      this.request = request;
      this.resourceResolver = request.getResourceResolver();
    }
  
    /**
     * Sets the root path detector implementation to detect root path from context.
     * @param rootPathDetector For detecting root path from context
     */
    public void setRootPathDetector(@NotNull RootPathDetector rootPathDetector) {
      this.rootPathDetector = rootPathDetector;
    }
  
    /**
     * Sets the fallback root path to be used if none is configured.
     * @param fallbackRootPath Fallback root path that is used if none is configured
    */
   public void setFallbackRootPath(@NotNull String fallbackRootPath) {
     this.fallbackRootPath = fallbackRootPath;
   }
 
   /**
    * Get the resolved and validated root path.
    * @return Root path.
    */
   public @NotNull String get() {
     // get configured or detected or fallback root path
     String rootPath = getRootPath();
 
     // append path if configured
     rootPath = appendPath(rootPath);
 
     // resolve to existing path
     return getExistingPath(rootPath);
   }
 
   /**
    * Get map of override properties for super component based on the wcm.io Granite UI Extensions PathField.
    * @return Path properties
    */
   public Map<String, Object> getOverrideProperties() {
     Map<String, Object> props = new HashMap<>();
     props.put(PN_ROOT_PATH, get());
     props.put(PN_APPEND_PATH, "");
     props.put(PN_FALLBACK_PATH, "");
     return props;
   }
 
   /**
    * @return Configured or detected root path or fallback path
    */
   private @NotNull String getRootPath() {
 
     // check for configured root path
     String rootPath = ex.getString(cfg.get(PN_ROOT_PATH, String.class));
     if (StringUtils.isNotBlank(rootPath)) {
       return rootPath;
     }
 
     // call root path detector
     if (rootPathDetector != null) {
       rootPath = rootPathDetector.detectRootPath(cmp, request);
       if (rootPath != null && StringUtils.isNotBlank(rootPath)) {
         return rootPath;
       }
     }
 
     // check for configured fallback path
     rootPath = ex.getString(cfg.get(PN_FALLBACK_PATH, String.class));
     if (StringUtils.isNotBlank(rootPath)) {
       return rootPath;
     }
 
     // fallback to default fallback path
     return fallbackRootPath;
   }
 
   /**
    * Appends the "appendPath" if configured.
    * @param rootPath Root path
    * @return Path with appendix
    */
   private @NotNull String appendPath(@NotNull String rootPath) {
     String appendPath = ex.getString(cfg.get(PN_APPEND_PATH, String.class));
     if (StringUtils.isBlank(appendPath)) {
       return rootPath;
     }
     StringBuilder combinedPath = new StringBuilder(rootPath);
     if (!Strings.CS.startsWith(appendPath, "/")) {
       combinedPath.append("/");
     }
     combinedPath.append(appendPath);
     return combinedPath.toString();
   }
 
   /**
    * Make sure the root path exists. If it does not exist go up to parent hierarchy until it returns an
    * existing resource path.
    */
   @NotNull
   String getExistingPath(@NotNull String rootPath) {
     if (resourceResolver.getResource(rootPath) == null) {
       String parentPath = Text.getRelativeParent(rootPath, 1);
       if (StringUtils.isBlank(parentPath)) {
         return DEFAULT_FALLBACK_ROOT_PATH;
       }
       return getExistingPath(parentPath);
     }
     else {
       return rootPath;
     }
   }
 
 }