/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.oscal.lib.profile.resolver.alter;
   
   import java.util.Collection;
   import java.util.Collections;
  import java.util.EnumMap;
  import java.util.EnumSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.function.Function;
  import java.util.function.Supplier;
  
  import dev.metaschema.core.util.CollectionUtil;
  import dev.metaschema.core.util.ObjectUtils;
  import dev.metaschema.oscal.lib.model.Catalog;
  import dev.metaschema.oscal.lib.model.CatalogGroup;
  import dev.metaschema.oscal.lib.model.Control;
  import dev.metaschema.oscal.lib.model.ControlPart;
  import dev.metaschema.oscal.lib.model.Link;
  import dev.metaschema.oscal.lib.model.Parameter;
  import dev.metaschema.oscal.lib.model.Property;
  import dev.metaschema.oscal.lib.model.control.catalog.ICatalogVisitor;
  import dev.metaschema.oscal.lib.model.metadata.IProperty;
  import dev.metaschema.oscal.lib.profile.resolver.ProfileResolutionEvaluationException;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  
  public class RemoveVisitor implements ICatalogVisitor<Boolean, RemoveVisitor.Context> {
    public enum TargetType {
      PARAM("param", Parameter.class),
      PROP("prop", Property.class),
      LINK("link", Link.class),
      PART("part", ControlPart.class);
  
      @NonNull
      private static final Map<Class<?>, TargetType> CLASS_TO_TYPE;
      @NonNull
      private static final Map<String, TargetType> NAME_TO_TYPE;
      @NonNull
      private final String fieldName;
      @NonNull
      private final Class<?> clazz;
  
      static {
        {
          Map<Class<?>, TargetType> map = new ConcurrentHashMap<>();
          for (TargetType type : values()) {
            map.put(type.getClazz(), type);
          }
          CLASS_TO_TYPE = CollectionUtil.unmodifiableMap(map);
        }
  
        {
          Map<String, TargetType> map = new ConcurrentHashMap<>();
          for (TargetType type : values()) {
            map.put(type.fieldName(), type);
          }
          NAME_TO_TYPE = CollectionUtil.unmodifiableMap(map);
        }
      }
  
      /**
       * Get the target type associated with the provided {@code clazz}.
       *
       * @param clazz
       *          the class to identify the target type for
       * @return the associated target type or {@code null} if the class is not
       *         associated with a target type
       */
      @Nullable
      public static TargetType forClass(@NonNull Class<?> clazz) {
        Class<?> target = clazz;
        TargetType retval;
        // recurse over parent classes to find a match
        do {
          retval = CLASS_TO_TYPE.get(target);
        } while (retval == null && (target = target.getSuperclass()) != null);
        return retval;
      }
  
      /**
       * Get the target type associated with the provided field {@code name}.
       *
       * @param name
       *          the field name to identify the target type for
       * @return the associated target type or {@code null} if the name is not
       *         associated with a target type
       */
      @Nullable
      public static TargetType forFieldName(@Nullable String name) {
        return name == null ? null : NAME_TO_TYPE.get(name);
     }
 
     TargetType(@NonNull String fieldName, @NonNull Class<?> clazz) {
       this.fieldName = fieldName;
       this.clazz = clazz;
     }
 
     /**
      * Get the field name associated with the target type.
      *
      * @return the name
      */
     public String fieldName() {
       return fieldName;
     }
 
     /**
      * Get the bound class associated with the target type.
      *
      * @return the class
      */
     public Class<?> getClazz() {
       return clazz;
     }
 
   }
 
   @NonNull
   private static final RemoveVisitor INSTANCE = new RemoveVisitor();
 
   private static final Map<TargetType, Set<TargetType>> APPLICABLE_TARGETS;
 
   static {
     APPLICABLE_TARGETS = new EnumMap<>(TargetType.class);
     APPLICABLE_TARGETS.put(TargetType.PARAM, Set.of(TargetType.PROP, TargetType.LINK));
     APPLICABLE_TARGETS.put(TargetType.PART, Set.of(TargetType.PART, TargetType.PROP, TargetType.LINK));
   }
 
   private static Set<TargetType> getApplicableTypes(@NonNull TargetType type) {
     return APPLICABLE_TARGETS.getOrDefault(type, CollectionUtil.emptySet());
   }
 
   private static <T> boolean handle(
       @NonNull TargetType itemType,
       @NonNull Supplier<? extends Collection<T>> supplier,
       @Nullable Function<T, Boolean> handler,
       @NonNull Context context) {
 
     boolean handleChildren = !Collections.disjoint(context.getTargetItemTypes(), getApplicableTypes(itemType));
     boolean retval = false;
     if (context.isMatchingType(itemType)) {
       // if the item type is applicable, attempt to remove any items
       Iterator<T> iter = supplier.get().iterator();
       while (iter.hasNext()) {
         T item = iter.next();
 
         if (item == null || context.isApplicableTo(item)) {
           iter.remove();
           retval = true;
           // ignore removed items and their children
         } else if (handler != null && handleChildren) {
           // handle child items since they are applicable to the search criteria
           retval = retval || handler.apply(item);
         }
       }
     } else if (handleChildren && handler != null) {
       for (T item : supplier.get()) {
         if (item != null) {
           retval = retval || handler.apply(item);
         }
       }
     }
     return retval;
   }
 
   /**
    * Apply the remove directive.
    *
    * @param control
    *          the control target
    * @param objectName
    *          the name flag of a matching node to remove
    * @param objectClass
    *          the class flag of a matching node to remove
    * @param objectId
    *          the id flag of a matching node to remove
    * @param objectNamespace
    *          the namespace flag of a matching node to remove
    * @param itemType
    *          the type of a matching node to remove
    * @return {@code true} if the modification was made or {@code false} otherwise
    * @throws ProfileResolutionEvaluationException
    *           if a processing error occurred during profile resolution
    */
   public static boolean remove(
       @NonNull Control control,
       @Nullable String objectName,
       @Nullable String objectClass,
       @Nullable String objectId,
       @Nullable String objectNamespace,
       @Nullable TargetType itemType) {
     return INSTANCE.visitControl(
         control,
         new Context(objectName, objectClass, objectId, objectNamespace, itemType));
   }
 
   @Override
   public Boolean visitCatalog(Catalog catalog, Context context) {
     // not required
     throw new UnsupportedOperationException("not needed");
   }
 
   @Override
   public Boolean visitGroup(CatalogGroup group, Context context) {
     // not required
     throw new UnsupportedOperationException("not needed");
   }
 
   @NonNull
   private static <T> List<T> modifiableListOrEmpty(@Nullable List<T> list) {
     return list == null ? CollectionUtil.emptyList() : list;
   }
 
   @Override
   public Boolean visitControl(Control control, Context context) {
     assert context != null;
 
     // visit params
     boolean retval = handle(
         TargetType.PARAM,
         () -> modifiableListOrEmpty(control.getParams()),
         child -> visitParameter(ObjectUtils.notNull(child), context),
         context);
 
     // visit props
     retval = retval || handle(
         TargetType.PROP,
         () -> modifiableListOrEmpty(control.getProps()),
         null,
         context);
 
     // visit links
     retval = retval || handle(
         TargetType.LINK,
         () -> modifiableListOrEmpty(control.getLinks()),
         null,
         context);
 
     return retval || handle(
         TargetType.PART,
         () -> modifiableListOrEmpty(control.getParts()),
         child -> visitPart(child, context),
         context);
   }
 
   @Override
   public Boolean visitParameter(Parameter parameter, Context context) {
     assert context != null;
 
     // visit props
     boolean retval = handle(
         TargetType.PROP,
         () -> modifiableListOrEmpty(parameter.getProps()),
         null,
         context);
 
     return retval || handle(
         TargetType.LINK,
         () -> modifiableListOrEmpty(parameter.getLinks()),
         null,
         context);
   }
 
   /**
    * Visit the control part.
    *
    * @param part
    *          the bound part object
    * @param context
    *          the visitor context
    * @return {@code true} if the removal was applied or {@code false} otherwise
    */
   public boolean visitPart(ControlPart part, Context context) {
     assert context != null;
 
     // visit props
     boolean retval = handle(
         TargetType.PROP,
         () -> modifiableListOrEmpty(part.getProps()),
         null,
         context);
 
     // visit links
     retval = retval || handle(
         TargetType.LINK,
         () -> modifiableListOrEmpty(part.getLinks()),
         null,
         context);
 
     return retval || handle(
         TargetType.PART,
         () -> modifiableListOrEmpty(part.getParts()),
         child -> visitPart(child, context),
         context);
   }
 
   static final class Context {
     /**
      * Types with an "name" flag.
      */
     @NonNull
     private static final Set<TargetType> NAME_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.PART, TargetType.PROP));
     /**
      * Types with an "class" flag.
      */
     @NonNull
     private static final Set<TargetType> CLASS_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.PARAM, TargetType.PART, TargetType.PROP));
     /**
      * Types with an "id" flag.
      */
     @NonNull
     private static final Set<TargetType> ID_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.PARAM, TargetType.PART));
     /**
      * Types with an "ns" flag.
      */
     @NonNull
     private static final Set<TargetType> NAMESPACE_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.PART, TargetType.PROP));
 
     @Nullable
     private final String objectName;
     @Nullable
     private final String objectClass;
     @Nullable
     private final String objectId;
     @Nullable
     private final String objectNamespace;
     @NonNull
     private final Set<TargetType> targetItemTypes;
 
     private static boolean filterTypes(
         @NonNull Set<TargetType> effectiveTypes,
         @NonNull String criteria,
         @NonNull Set<TargetType> allowedTypes,
         @Nullable String value,
         @Nullable TargetType itemType) {
       boolean retval = false;
       if (value != null) {
         retval = effectiveTypes.retainAll(allowedTypes);
         if (itemType != null && !allowedTypes.contains(itemType)) {
           throw new ProfileResolutionEvaluationException(
               String.format("%s='%s' is not supported for items of type '%s'",
                   criteria,
                   value,
                   itemType.fieldName()));
         }
       }
       return retval;
     }
 
     private Context(
         @Nullable String objectName,
         @Nullable String objectClass,
         @Nullable String objectId,
         @Nullable String objectNamespace,
         @Nullable TargetType itemType) {
 
       // determine the set of effective item types to search for
       // this helps with short-circuit searching for parts of the graph that cannot
       // match
       @NonNull
       Set<TargetType> targetItemTypes = ObjectUtils.notNull(EnumSet.allOf(TargetType.class));
       filterTypes(targetItemTypes, "by-name", NAME_TYPES, objectName, itemType);
       filterTypes(targetItemTypes, "by-class", CLASS_TYPES, objectClass, itemType);
       filterTypes(targetItemTypes, "by-id", ID_TYPES, objectId, itemType);
       filterTypes(targetItemTypes, "by-ns", NAMESPACE_TYPES, objectNamespace, itemType);
 
       if (itemType != null) {
         targetItemTypes.retainAll(Set.of(itemType));
       }
 
       if (targetItemTypes.isEmpty()) {
         throw new ProfileResolutionEvaluationException("The filter matches no available item types");
       }
 
       this.objectName = objectName;
       this.objectClass = objectClass;
       this.objectId = objectId;
       this.objectNamespace = objectNamespace;
       this.targetItemTypes = CollectionUtil.unmodifiableSet(targetItemTypes);
     }
 
     @Nullable
     public String getObjectName() {
       return objectName;
     }
 
     @Nullable
     public String getObjectClass() {
       return objectClass;
     }
 
     @Nullable
     public String getObjectId() {
       return objectId;
     }
 
     @NonNull
     public Set<TargetType> getTargetItemTypes() {
       return targetItemTypes;
     }
 
     public boolean isMatchingType(@NonNull TargetType type) {
       return getTargetItemTypes().contains(type);
     }
 
     @Nullable
     public String getObjectNamespace() {
       return objectNamespace;
     }
 
     private static boolean checkValue(@Nullable String actual, @Nullable String expected) {
       return expected == null || expected.equals(actual);
     }
 
     public boolean isApplicableTo(@NonNull Object obj) {
       TargetType objectType = TargetType.forClass(obj.getClass());
 
       boolean retval = objectType != null && getTargetItemTypes().contains(objectType);
       if (retval) {
         assert objectType != null;
 
         // check other criteria
         String actualName = null;
         String actualClass = null;
         String actualId = null;
         String actualNamespace = null;
 
         switch (objectType) {
         case PARAM: {
           Parameter param = (Parameter) obj;
           actualClass = param.getClazz();
           actualId = param.getId();
           break;
         }
         case PROP: {
           Property prop = (Property) obj;
           actualName = prop.getName();
           actualClass = prop.getClazz();
           actualNamespace = IProperty.normalizeNamespace(prop.getNs()).toASCIIString();
           break;
         }
         case PART: {
           ControlPart part = (ControlPart) obj;
           actualName = part.getName();
           actualClass = part.getClazz();
           String partId = part.getId();
           if (partId != null) {
             actualId = partId;
           }
           actualNamespace = IProperty.normalizeNamespace(part.getNs()).toASCIIString();
           break;
         }
         case LINK:
           // do nothing
           break;
         default:
           throw new UnsupportedOperationException(objectType.name().toLowerCase(Locale.ROOT));
         }
 
         retval = checkValue(actualName, getObjectName())
             && checkValue(actualClass, getObjectClass())
             && checkValue(actualId, getObjectId())
             && checkValue(actualNamespace, getObjectNamespace());
       }
       return retval;
     }
   }
 }