/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package gov.nist.secauto.oscal.lib.profile.resolver.alter;
   
   import gov.nist.secauto.metaschema.core.datatype.markup.MarkupLine;
   import gov.nist.secauto.metaschema.core.util.CollectionUtil;
  import gov.nist.secauto.metaschema.core.util.CustomCollectors;
  import gov.nist.secauto.metaschema.core.util.ObjectUtils;
  import gov.nist.secauto.oscal.lib.model.Catalog;
  import gov.nist.secauto.oscal.lib.model.CatalogGroup;
  import gov.nist.secauto.oscal.lib.model.Control;
  import gov.nist.secauto.oscal.lib.model.ControlPart;
  import gov.nist.secauto.oscal.lib.model.Link;
  import gov.nist.secauto.oscal.lib.model.Parameter;
  import gov.nist.secauto.oscal.lib.model.Property;
  import gov.nist.secauto.oscal.lib.model.control.catalog.ICatalogVisitor;
  import gov.nist.secauto.oscal.lib.profile.resolver.ProfileResolutionEvaluationException;
  
  import java.util.Collections;
  import java.util.EnumMap;
  import java.util.EnumSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.function.Consumer;
  import java.util.function.Function;
  import java.util.function.Supplier;
  
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  
  public class AddVisitor implements ICatalogVisitor<Boolean, AddVisitor.Context> {
    public enum TargetType {
      CONTROL("control", Control.class),
      PARAM("param", Parameter.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;
     }
   }
 
   public enum Position {
     BEFORE,
     AFTER,
     STARTING,
     ENDING;
 
     @NonNull
     private static final Map<String, Position> NAME_TO_POSITION;
 
     static {
       Map<String, Position> map = new ConcurrentHashMap<>();
       for (Position position : values()) {
         map.put(position.name().toLowerCase(Locale.ROOT), position);
       }
       NAME_TO_POSITION = CollectionUtil.unmodifiableMap(map);
     }
 
     /**
      * Get the position associated with the provided {@code name}.
      *
      * @param name
      *          the name to identify the position for
      * @return the associated position or {@code null} if the name is not associated
      *         with a position
      */
     @Nullable
     public static Position forName(@Nullable String name) {
       return name == null ? null : NAME_TO_POSITION.get(name);
     }
   }
 
   @NonNull
   private static final AddVisitor INSTANCE = new AddVisitor();
   private static final Map<TargetType, Set<TargetType>> APPLICABLE_TARGETS;
 
   static {
     APPLICABLE_TARGETS = new EnumMap<>(TargetType.class);
     APPLICABLE_TARGETS.put(TargetType.CONTROL, Set.of(TargetType.CONTROL, TargetType.PARAM, TargetType.PART));
     APPLICABLE_TARGETS.put(TargetType.PARAM, Set.of(TargetType.PARAM));
     APPLICABLE_TARGETS.put(TargetType.PART, Set.of(TargetType.PART));
   }
 
   private static Set<TargetType> getApplicableTypes(@NonNull TargetType type) {
     return APPLICABLE_TARGETS.getOrDefault(type, CollectionUtil.emptySet());
   }
 
   /**
    * Apply the add directive.
    *
    * @param control
    *          the control target
    * @param position
    *          the position to apply the content or {@code null}
    * @param byId
    *          the identifier of the target or {@code null}
    * @param title
    *          a title to set
    * @param params
    *          parameters to add
    * @param props
    *          properties to add
    * @param links
    *          links to add
    * @param parts
    *          parts to add
    * @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 add(
       @NonNull Control control,
       @Nullable Position position,
       @Nullable String byId,
       @Nullable MarkupLine title,
       @NonNull List<Parameter> params,
       @NonNull List<Property> props,
       @NonNull List<Link> links,
       @NonNull List<ControlPart> parts) {
     return INSTANCE.visitControl(
         control,
         new Context(
             control,
             position == null ? Position.ENDING : position,
             byId,
             title,
             params,
             props,
             links,
             parts));
   }
 
   @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");
   }
 
   /**
    * If the add applies to the current object, then apply the child objects.
    * <p>
    * An add applies if:
    * <ol>
    * <li>the {@code targetItem} supports all of the children</li>
    * <li>the context matches if:
    * <ul>
    * <li>the target item's id matches the "by-id"; or</li>
    * <li>the "by-id" is not defined and the target item is the control matching
    * the target context</li>
    * </ul>
    * </li>
    * </ol>
    *
    * @param <T>
    *          the type of the {@code targetItem}
    * @param targetItem
    *          the current target to process
    * @param titleConsumer
    *          a consumer to apply a title to or {@code null} if the object has no
    *          title field
    * @param paramsSupplier
    *          a supplier for the child {@link Parameter} collection
    * @param propsSupplier
    *          a supplier for the child {@link Property} collection
    * @param linksSupplier
    *          a supplier for the child {@link Link} collection
    * @param partsSupplier
    *          a supplier for the child {@link ControlPart} collection
    * @param context
    *          the add context
    * @return {@code true} if a modification was made or {@code false} otherwise
    */
   private static <T> boolean handleCurrent(
       @NonNull T targetItem,
       @Nullable Consumer<MarkupLine> titleConsumer,
       @Nullable Supplier<? extends List<Parameter>> paramsSupplier,
       @Nullable Supplier<? extends List<Property>> propsSupplier,
       @Nullable Supplier<? extends List<Link>> linksSupplier,
       @Nullable Supplier<? extends List<ControlPart>> partsSupplier,
       @NonNull Context context) {
     boolean retval = false;
     Position position = context.getPosition();
     if (context.appliesTo(targetItem) && !context.isSequenceTargeted(targetItem)) {
       // the target item is the target of the add
       MarkupLine newTitle = context.getTitle();
       if (newTitle != null) {
         assert titleConsumer != null;
         titleConsumer.accept(newTitle);
       }
 
       handleCollection(position, context.getParams(), paramsSupplier);
       handleCollection(position, context.getProps(), propsSupplier);
       handleCollection(position, context.getLinks(), linksSupplier);
       handleCollection(position, context.getParts(), partsSupplier);
       retval = true;
     }
     return retval;
   }
 
   private static <T> void handleCollection(
       @NonNull Position position,
       @NonNull List<T> newItems,
       @Nullable Supplier<? extends List<T>> originalCollectionSupplier) {
     if (originalCollectionSupplier != null) {
       List<T> oldItems = originalCollectionSupplier.get();
       if (!newItems.isEmpty()) {
         if (Position.STARTING.equals(position)) {
           oldItems.addAll(0, newItems);
         } else { // ENDING
           oldItems.addAll(newItems);
         }
       }
     }
   }
 
   // private static <T> void handleChild(
   // @NonNull TargetType itemType,
   // @NonNull Supplier<? extends List<T>> collectionSupplier,
   // @Nullable Consumer<T> handler,
   // @NonNull Context context) {
   // boolean handleChildren = !Collections.disjoint(context.getTargetItemTypes(),
   // getApplicableTypes(itemType));
   // if (handleChildren && handler != null) {
   // // if the child item type is applicable and there is a handler, iterate over
   // children
   // Iterator<T> iter = collectionSupplier.get().iterator();
   // while (iter.hasNext()) {
   // T item = iter.next();
   // if (item != null) {
   // handler.accept(item);
   // }
   // }
   // }
   // }
 
   private static <T> boolean handleChild(
       @NonNull TargetType itemType,
       @NonNull Supplier<? extends List<T>> originalCollectionSupplier,
       @NonNull Supplier<? extends List<T>> newItemsSupplier,
       @Nullable Function<T, Boolean> handler,
       @NonNull Context context) {
 
     // determine if this child type can match
     boolean isItemTypeMatch = context.isMatchingType(itemType);
 
     Set<TargetType> applicableTypes = getApplicableTypes(itemType);
     boolean descendChild = handler != null && !Collections.disjoint(context.getTargetItemTypes(), applicableTypes);
 
     boolean retval = false;
     if (isItemTypeMatch || descendChild) {
       // if the item type is applicable, attempt to match by id
       List<T> collection = originalCollectionSupplier.get();
       ListIterator<T> iter = collection.listIterator();
       boolean deferred = false;
       while (iter.hasNext()) {
         T item = ObjectUtils.requireNonNull(iter.next());
 
         if (isItemTypeMatch && context.appliesTo(item) && context.isSequenceTargeted(item)) {
           // if id match, inject the new items into the collection
           switch (context.getPosition()) {
           case AFTER: {
             newItemsSupplier.get().forEach(iter::add);
             retval = true;
             break;
           }
           case BEFORE: {
             iter.previous();
             List<T> adds = newItemsSupplier.get();
             adds.forEach(iter::add);
             item = iter.next();
             retval = true;
             break;
           }
           case STARTING:
           case ENDING:
             deferred = true;
             break;
           default:
             throw new UnsupportedOperationException(context.getPosition().name().toLowerCase(Locale.ROOT));
           }
         }
 
         if (descendChild) {
           assert handler != null;
 
           // handle child items since they are applicable to the search criteria
           retval = retval || handler.apply(item);
         }
       }
 
       if (deferred) {
         List<T> newItems = newItemsSupplier.get();
         if (Position.ENDING.equals(context.getPosition())) {
           collection.addAll(newItems);
           retval = true;
         } else if (Position.STARTING.equals(context.getPosition())) {
           collection.addAll(0, newItems);
           retval = true;
         }
       }
     }
     return retval;
   }
 
   @Override
   public Boolean visitControl(Control control, Context context) {
     assert context != null;
 
     if (control.getParams() == null) {
       control.setParams(new LinkedList<>());
     }
 
     if (control.getProps() == null) {
       control.setProps(new LinkedList<>());
     }
 
     if (control.getLinks() == null) {
       control.setLinks(new LinkedList<>());
     }
 
     if (control.getParts() == null) {
       control.setParts(new LinkedList<>());
     }
 
     boolean retval = handleCurrent(
         control,
         control::setTitle,
         control::getParams,
         control::getProps,
         control::getLinks,
         control::getParts,
         context);
 
     // visit params
     retval = retval || handleChild(
         TargetType.PARAM,
         control::getParams,
         context::getParams,
         child -> visitParameter(ObjectUtils.notNull(child), context),
         context);
 
     // visit parts
     retval = retval || handleChild(
         TargetType.PART,
         control::getParts,
         context::getParts,
         child -> visitPart(child, context),
         context);
 
     // visit control children
     for (Control childControl : CollectionUtil.listOrEmpty(control.getControls())) {
       Set<TargetType> applicableTypes = getApplicableTypes(TargetType.CONTROL);
       if (!Collections.disjoint(context.getTargetItemTypes(), applicableTypes)) {
         retval = retval || visitControl(ObjectUtils.requireNonNull(childControl), context);
       }
     }
     return retval;
   }
 
   @Override
   public Boolean visitParameter(Parameter parameter, Context context) {
     assert context != null;
     if (parameter.getProps() == null) {
       parameter.setProps(new LinkedList<>());
     }
 
     if (parameter.getLinks() == null) {
       parameter.setLinks(new LinkedList<>());
     }
 
     return handleCurrent(
         parameter,
         null,
         null,
         parameter::getProps,
         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;
     if (part.getProps() == null) {
       part.setProps(new LinkedList<>());
     }
 
     if (part.getLinks() == null) {
       part.setLinks(new LinkedList<>());
     }
 
     if (part.getParts() == null) {
       part.setParts(new LinkedList<>());
     }
 
     boolean retval = handleCurrent(
         part,
         null,
         null,
         part::getProps,
         part::getLinks,
         part::getParts,
         context);
 
     return retval || handleChild(
         TargetType.PART,
         part::getParts,
         context::getParts,
         child -> visitPart(child, context),
         context);
   }
 
   static final class Context {
     @NonNull
     private static final Set<TargetType> TITLE_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.CONTROL, TargetType.PART));
     @NonNull
     private static final Set<TargetType> PARAM_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.CONTROL, TargetType.PARAM));
     @NonNull
     private static final Set<TargetType> PROP_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.CONTROL, TargetType.PARAM, TargetType.PART));
     @NonNull
     private static final Set<TargetType> LINK_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.CONTROL, TargetType.PARAM, TargetType.PART));
     @NonNull
     private static final Set<TargetType> PART_TYPES = ObjectUtils.notNull(
         Set.of(TargetType.CONTROL, TargetType.PART));
 
     @NonNull
     private final Control control;
     @NonNull
     private final Position position;
     @Nullable
     private final String byId;
     @Nullable
     private final MarkupLine title;
     @NonNull
     private final List<Parameter> params;
     @NonNull
     private final List<Property> props;
     @NonNull
     private final List<Link> links;
     @NonNull
     private final List<ControlPart> parts;
     @NonNull
     private final Set<TargetType> targetItemTypes;
 
     public Context(
         @NonNull Control control,
         @NonNull Position position,
         @Nullable String byId,
         @Nullable MarkupLine title,
         @NonNull List<Parameter> params,
         @NonNull List<Property> props,
         @NonNull List<Link> links,
         @NonNull List<ControlPart> parts) {
 
       Set<TargetType> targetItemTypes = ObjectUtils.notNull(EnumSet.allOf(TargetType.class));
 
       List<String> additionObjects = new LinkedList<>();
 
       boolean sequenceTarget = true;
       if (title != null) {
         targetItemTypes.retainAll(TITLE_TYPES);
         additionObjects.add("title");
         sequenceTarget = false;
       }
 
       if (!params.isEmpty()) {
         targetItemTypes.retainAll(PARAM_TYPES);
         additionObjects.add("param");
       }
 
       if (!props.isEmpty()) {
         targetItemTypes.retainAll(PROP_TYPES);
         additionObjects.add("prop");
         sequenceTarget = false;
       }
 
       if (!links.isEmpty()) {
         targetItemTypes.retainAll(LINK_TYPES);
         additionObjects.add("link");
         sequenceTarget = false;
       }
 
       if (!parts.isEmpty()) {
         targetItemTypes.retainAll(PART_TYPES);
         additionObjects.add("part");
       }
 
       if (Position.BEFORE.equals(position) || Position.AFTER.equals(position)) {
         if (!sequenceTarget) {
           throw new ProfileResolutionEvaluationException(
               "When using position before or after, one collection of parameters or parts can be specified."
                   + " Other additions must not be used.");
         }
         if (sequenceTarget && !params.isEmpty() && parts.isEmpty()) {
           targetItemTypes.retainAll(Set.of(TargetType.PARAM));
         } else if (sequenceTarget && !parts.isEmpty() && params.isEmpty()) {
           targetItemTypes.retainAll(Set.of(TargetType.PART));
         } else {
           throw new ProfileResolutionEvaluationException(
               "When using position before or after, only one collection of parameters or parts can be specified.");
         }
       }
 
       if (targetItemTypes.isEmpty()) {
         throw new ProfileResolutionEvaluationException("No parent object supports the requested objects to add: " +
             additionObjects.stream().collect(CustomCollectors.joiningWithOxfordComma("or")));
       }
 
       this.control = control;
       this.position = position;
       this.byId = byId;
       this.title = title;
       this.params = params;
       this.props = props;
       this.links = links;
       this.parts = parts;
       this.targetItemTypes = CollectionUtil.unmodifiableSet(targetItemTypes);
     }
 
     public Control getControl() {
       return control;
     }
 
     @NonNull
     public Position getPosition() {
       return position;
     }
 
     @Nullable
     public String getById() {
       return byId;
     }
 
     @Nullable
     public MarkupLine getTitle() {
       return title;
     }
 
     @NonNull
     public List<Parameter> getParams() {
       return params;
     }
 
     @NonNull
     public List<Property> getProps() {
       return props;
     }
 
     @NonNull
     public List<Link> getLinks() {
       return links;
     }
 
     @NonNull
     public List<ControlPart> getParts() {
       return parts;
     }
 
     @NonNull
     public Set<TargetType> getTargetItemTypes() {
       return targetItemTypes;
     }
 
     public boolean isMatchingType(@NonNull TargetType type) {
       return getTargetItemTypes().contains(type);
     }
 
     public <T> boolean isSequenceTargeted(T targetItem) {
       TargetType objectType = TargetType.forClass(targetItem.getClass());
       return (Position.BEFORE.equals(position) || Position.AFTER.equals(position))
           && (TargetType.PARAM.equals(objectType) && isMatchingType(TargetType.PARAM)
               || TargetType.PART.equals(objectType) && isMatchingType(TargetType.PART));
     }
 
     /**
      * Determine if the provided {@code obj} is the target of the add.
      *
      * @param obj
      *          the current object
      * @return {@code true} if the current object applies or {@code false} otherwise
      */
     public boolean appliesTo(@NonNull Object obj) {
       TargetType objectType = TargetType.forClass(obj.getClass());
 
       boolean retval = objectType != null && isMatchingType(objectType);
       if (retval) {
         assert objectType != null;
 
         // check other criteria
         String actualId = null;
 
         switch (objectType) {
         case CONTROL: {
           Control control = (Control) obj;
           actualId = control.getId();
           break;
         }
         case PARAM: {
           Parameter param = (Parameter) obj;
           actualId = param.getId();
           break;
         }
         case PART: {
           ControlPart part = (ControlPart) obj;
           actualId = part.getId() == null ? null : part.getId();
           break;
         }
         default:
           throw new UnsupportedOperationException(objectType.fieldName());
         }
 
         String byId = getById();
         if (getById() == null && TargetType.CONTROL.equals(objectType)) {
           retval = getControl().equals(obj);
         } else {
           retval = byId != null && byId.equals(actualId);
         }
       }
       return retval;
     }
   }
 }