/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  package org.eclipse.aether.internal.impl;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  import java.util.function.Function;
  
  import org.eclipse.aether.ConfigurationProperties;
  import org.eclipse.aether.Keys;
  import org.eclipse.aether.RepositorySystemSession;
  import org.eclipse.aether.util.ConfigUtils;
  
  /**
   * Helps to sort pluggable components by their priority.
   *
   * @param <T> The component type.
   */
  public final class PrioritizedComponents<T> {
      /**
       * Reuses or creates and caches (if session is equipped with cache, and it does not contain it yet)
       * prioritized components under certain key into session cache. Same session is used to configure prioritized
       * components, so priority sorted components during session are immutable and reusable (if {@code components}
       * component map is unchanged).
       * <p>
       * The {@code components} are expected to be Sisu injected {@link Map}-like dynamic component maps. There is a
       * simple "change detection" in place, as injected maps are dynamic, they are atomically expanded or contracted
       * as components are dynamically discovered or unloaded.
       *
       * @since 2.0.0
       */
      @SuppressWarnings("unchecked")
      public static <C> PrioritizedComponents<C> reuseOrCreate(
              RepositorySystemSession session,
              Class<C> discriminator,
              Map<String, C> components,
              Function<C, Float> priorityFunction) {
          boolean cached = ConfigUtils.getBoolean(
                  session, ConfigurationProperties.DEFAULT_CACHED_PRIORITIES, ConfigurationProperties.CACHED_PRIORITIES);
          if (cached && session.getCache() != null) {
              return (PrioritizedComponents<C>) session.getCache()
                      .computeIfAbsent(
                              session,
                              Keys.of(
                                      PrioritizedComponents.class,
                                      discriminator,
                                      "pc-" + Integer.toHexString(components.hashCode())),
                              () -> create(session, components, priorityFunction));
          } else {
              return create(session, components, priorityFunction);
          }
      }
  
      private static <C> PrioritizedComponents<C> create(
              RepositorySystemSession session, Map<String, C> components, Function<C, Float> priorityFunction) {
          PrioritizedComponents<C> newInstance = new PrioritizedComponents<>(session);
          components.values().forEach(c -> newInstance.add(c, priorityFunction.apply(c)));
          return newInstance;
      }
  
      private static final String FACTORY_SUFFIX = "Factory";
  
      private final Map<?, ?> configProps;
  
      private final boolean useInsertionOrder;
  
      private final List<PrioritizedComponent<T>> components;
  
      private int firstDisabled;
  
      PrioritizedComponents(RepositorySystemSession session) {
          this(session.getConfigProperties());
      }
  
      PrioritizedComponents(Map<?, ?> configurationProperties) {
          configProps = configurationProperties;
          useInsertionOrder = ConfigUtils.getBoolean(
                  configProps,
                  ConfigurationProperties.DEFAULT_IMPLICIT_PRIORITIES,
                  ConfigurationProperties.IMPLICIT_PRIORITIES);
          components = new ArrayList<>();
         firstDisabled = 0;
     }
 
     public void add(T component, float priority) {
         Class<?> type = getImplClass(component);
         int index = components.size();
         priority = useInsertionOrder ? -index : ConfigUtils.getFloat(configProps, priority, getConfigKeys(type));
         PrioritizedComponent<T> pc = new PrioritizedComponent<>(component, type, priority, index);
 
         if (!useInsertionOrder) {
             index = Collections.binarySearch(components, pc);
             if (index < 0) {
                 index = -index - 1;
             } else {
                 index++;
             }
         }
         components.add(index, pc);
 
         if (index <= firstDisabled && !pc.isDisabled()) {
             firstDisabled++;
         }
     }
 
     private static Class<?> getImplClass(Object component) {
         Class<?> type = component.getClass();
         // detect and ignore CGLIB-based proxy classes employed by Guice for AOP (cf. BytecodeGen.newEnhancer)
         int idx = type.getName().indexOf("$$");
         if (idx >= 0) {
             Class<?> base = type.getSuperclass();
             if (base != null && idx == base.getName().length() && type.getName().startsWith(base.getName())) {
                 type = base;
             }
         }
         return type;
     }
 
     static String[] getConfigKeys(Class<?> type) {
         List<String> keys = new ArrayList<>();
         keys.add(ConfigurationProperties.PREFIX_PRIORITY + type.getName());
         String sn = type.getSimpleName();
         keys.add(ConfigurationProperties.PREFIX_PRIORITY + sn);
         if (sn.endsWith(FACTORY_SUFFIX)) {
             keys.add(ConfigurationProperties.PREFIX_PRIORITY + sn.substring(0, sn.length() - FACTORY_SUFFIX.length()));
         }
         return keys.toArray(new String[0]);
     }
 
     public boolean isEmpty() {
         return components.isEmpty();
     }
 
     public List<PrioritizedComponent<T>> getAll() {
         return components;
     }
 
     public List<PrioritizedComponent<T>> getEnabled() {
         return components.subList(0, firstDisabled);
     }
 
     public void list(StringBuilder buffer) {
         int i = 0;
         for (PrioritizedComponent<?> component : components) {
             if (i++ > 0) {
                 buffer.append(", ");
             }
             buffer.append(component.getType().getSimpleName());
             if (component.isDisabled()) {
                 buffer.append(" (disabled)");
             }
         }
     }
 
     @Override
     public String toString() {
         return components.toString();
     }
 }