/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.databind.codegen.config;
   
   import org.apache.logging.log4j.LogManager;
   import org.apache.logging.log4j.Logger;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.nio.file.Path;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.function.Function;
  
  import dev.metaschema.core.model.IAssemblyDefinition;
  import dev.metaschema.core.model.IFieldDefinition;
  import dev.metaschema.core.model.IModelDefinition;
  import dev.metaschema.core.model.IModule;
  import dev.metaschema.core.model.INamedInstance;
  import dev.metaschema.core.util.CollectionUtil;
  import dev.metaschema.core.util.ObjectUtils;
  import dev.metaschema.databind.IBindingContext;
  import dev.metaschema.databind.codegen.ClassUtils;
  import dev.metaschema.databind.config.binding.MetaschemaBindings;
  import dev.metaschema.databind.io.BindingException;
  import dev.metaschema.databind.io.Format;
  import dev.metaschema.databind.io.IDeserializer;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  
  /**
   * Default implementation of {@link IBindingConfiguration} that provides binding
   * configuration for Java class generation from Metaschema modules.
   * <p>
   * This implementation supports loading configuration from XML files and
   * provides namespace-to-package mappings and definition-specific binding
   * configurations.
   */
  public class DefaultBindingConfiguration implements IBindingConfiguration {
    private static final Logger LOGGER = LogManager.getLogger(DefaultBindingConfiguration.class);
  
    private final Map<String, String> namespaceToPackageNameMap = new ConcurrentHashMap<>();
    // metaschema location -> ModelType -> Definition name -> IBindingConfiguration
    private final Map<String, MetaschemaBindingConfiguration> moduleUrlToMetaschemaBindingConfigurationMap
        = new ConcurrentHashMap<>();
  
    @Override
    public String getPackageNameForModule(IModule module) {
      URI namespace = module.getXmlNamespace();
      return getPackageNameForNamespace(ObjectUtils.notNull(namespace.toASCIIString()));
    }
  
    /**
     * Retrieve the binding configuration for the provided {@code definition}.
     * <p>
     * This method first checks for a binding by the definition's name. If not found
     * and the definition is inline, it also checks for a binding by the
     * definition's path (using "/" separated ancestor names).
     *
     * @param definition
     *          the definition to get the config for
     * @return the binding configuration or {@code null} if there is not
     *         configuration
     */
    @Override
    @Nullable
    public IDefinitionBindingConfiguration getBindingConfigurationForDefinition(
        @NonNull IModelDefinition definition) {
      String moduleUri = ObjectUtils.notNull(definition.getContainingModule().getLocation().toASCIIString());
      String definitionName = definition.getName();
  
      MetaschemaBindingConfiguration metaschemaConfig = getMetaschemaBindingConfiguration(moduleUri);
  
      IDefinitionBindingConfiguration retval = null;
      if (metaschemaConfig != null) {
        switch (definition.getModelType()) {
        case ASSEMBLY:
          // First try by name
          retval = metaschemaConfig.getAssemblyDefinitionBindingConfig(definitionName);
          // If not found and inline, try by path
          if (retval == null && definition.isInline()) {
            String path = computeDefinitionPath(definition);
            retval = metaschemaConfig.getAssemblyDefinitionBindingConfig(path);
          }
          break;
        case FIELD:
          // First try by name
          retval = metaschemaConfig.getFieldDefinitionBindingConfig(definitionName);
          // If not found and inline, try by path
         if (retval == null && definition.isInline()) {
           String path = computeDefinitionPath(definition);
           retval = metaschemaConfig.getFieldDefinitionBindingConfig(path);
         }
         break;
       default:
         throw new UnsupportedOperationException(
             String.format("Unsupported definition type '%s'", definition.getModelType()));
       }
     }
     return retval;
   }
 
   /**
    * Compute the path for an inline definition.
    * <p>
    * The path is constructed by walking up the definition hierarchy and
    * concatenating ancestor definition names with "/" separators. For example, an
    * inline assembly "assembly" within "scope" within
    * "metaschema-module-constraints" would have path "scope/assembly".
    *
    * @param definition
    *          the definition to compute the path for
    * @return the computed path, or just the definition name if not inline
    */
   @NonNull
   private static String computeDefinitionPath(@NonNull IModelDefinition definition) {
     StringBuilder path = new StringBuilder();
     IModelDefinition current = definition;
 
     while (current.isInline()) {
       if (path.length() > 0) {
         path.insert(0, "/");
       }
       path.insert(0, current.getName());
 
       // Walk up to the parent definition
       INamedInstance inlineInstance = current.getInlineInstance();
       if (inlineInstance != null) {
         current = inlineInstance.getContainingDefinition();
       } else {
         break;
       }
     }
 
     return ObjectUtils.notNull(path.toString());
   }
 
   @Override
   public String getQualifiedBaseClassName(IModelDefinition definition) {
     IDefinitionBindingConfiguration config = getBindingConfigurationForDefinition(definition);
     return config == null
         ? null
         : config.getQualifiedBaseClassName();
   }
 
   @Override
   public String getClassName(IModelDefinition definition) {
     IDefinitionBindingConfiguration config = getBindingConfigurationForDefinition(definition);
 
     String retval = null;
     if (config != null) {
       retval = config.getClassName();
     }
 
     if (retval == null) {
       retval = ClassUtils.toClassName(definition.getName());
     }
     return retval;
   }
 
   @NonNull
   @Override
   public String getClassName(@NonNull IModule module) {
     // TODO: make this configurable
     return ClassUtils.toClassName(module.getShortName() + "Module");
   }
 
   @Override
   public List<String> getQualifiedSuperinterfaceClassNames(IModelDefinition definition) {
     IDefinitionBindingConfiguration config = getBindingConfigurationForDefinition(definition);
     return config == null
         ? CollectionUtil.emptyList()
         : config.getInterfacesToImplement();
   }
 
   /**
    * Get the property binding configuration for a specific property within a
    * definition.
    *
    * @param definition
    *          the containing definition
    * @param propertyName
    *          the name of the property
    * @return the property binding configuration, or {@code null} if none is
    *         configured
    */
   @Nullable
   public IPropertyBindingConfiguration getPropertyBindingConfiguration(
       @NonNull IModelDefinition definition,
       @NonNull String propertyName) {
     String moduleUri = ObjectUtils.notNull(definition.getContainingModule().getLocation().toASCIIString());
     String definitionName = definition.getName();
 
     MetaschemaBindingConfiguration metaschemaConfig = getMetaschemaBindingConfiguration(moduleUri);
     if (metaschemaConfig == null) {
       return null;
     }
 
     return metaschemaConfig.getPropertyBindingConfig(definitionName, propertyName);
   }
 
   /**
    * Binds an XML namespace, which is normally associated with one or more Module,
    * with a provided Java package name.
    *
    * @param namespace
    *          an XML namespace URI
    * @param packageName
    *          the package name to associate with the namespace
    * @throws IllegalStateException
    *           if the binding configuration is changing a previously changed
    *           namespace to package binding
    */
   public void addModelBindingConfig(String namespace, String packageName) {
     if (namespaceToPackageNameMap.containsKey(namespace)) {
       String oldPackageName = namespaceToPackageNameMap.get(namespace);
       if (!oldPackageName.equals(packageName)) {
         throw new IllegalStateException(
             String.format("Attempt to redefine existing package name '%s' to '%s' for namespace '%s'",
                 oldPackageName,
                 packageName,
                 namespace));
       } // else the same package name, so do nothing
     } else {
       namespaceToPackageNameMap.put(namespace, packageName);
     }
   }
 
   /**
    * Based on the current binding configuration, generate a Java package name for
    * the provided namespace. If the namespace is already mapped, such as through
    * the use of {@link #addModelBindingConfig(String, String)}, then the provided
    * package name will be used. If the namespace is not mapped, then the namespace
    * URI will be translated into a Java package name.
    *
    * @param namespace
    *          the namespace to generate a Java package name for
    * @return a Java package name
    */
   @NonNull
   protected String getPackageNameForNamespace(@NonNull String namespace) {
     String packageName = namespaceToPackageNameMap.get(namespace);
     if (packageName == null) {
       packageName = ClassUtils.toPackageName(namespace);
     }
     return packageName;
   }
 
   /**
    * Get the binding configuration for the provided Module.
    *
    * @param module
    *          the Module module
    * @return the configuration for the Module or {@code null} if there is no
    *         configuration
    */
   protected MetaschemaBindingConfiguration getMetaschemaBindingConfiguration(@NonNull IModule module) {
     String moduleUri = ObjectUtils.notNull(module.getLocation().toString());
     return getMetaschemaBindingConfiguration(moduleUri);
 
   }
 
   /**
    * Get the binding configuration for the Module modulke located at the provided
    * {@code moduleUri}.
    *
    * @param moduleUri
    *          the location of the Module module
    * @return the configuration for the Module module or {@code null} if there is
    *         no configuration
    */
   @Nullable
   protected MetaschemaBindingConfiguration getMetaschemaBindingConfiguration(@NonNull String moduleUri) {
     return moduleUrlToMetaschemaBindingConfigurationMap.get(moduleUri);
   }
 
   /**
    * Set the binding configuration for the Module module located at the provided
    * {@code moduleUri}.
    *
    * @param moduleUri
    *          the location of the Module module
    * @param config
    *          the Module binding configuration
    * @return the old configuration for the Module module or {@code null} if there
    *         was no previous configuration
    */
   public MetaschemaBindingConfiguration addMetaschemaBindingConfiguration(
       @NonNull String moduleUri,
       @NonNull MetaschemaBindingConfiguration config) {
     Objects.requireNonNull(moduleUri, "moduleUri");
     Objects.requireNonNull(config, "config");
     return moduleUrlToMetaschemaBindingConfigurationMap.put(moduleUri, config);
   }
 
   /**
    * Load the binding configuration from the provided {@code file}.
    *
    * @param file
    *          the configuration resource
    * @throws IOException
    *           if an error occurred while reading the {@code file}
    * @throws BindingException
    *           if an error occurred while processing the binding configuration
    */
   public void load(Path file) throws IOException, BindingException {
     URL resource = ObjectUtils.notNull(file.toAbsolutePath().normalize().toUri().toURL());
     load(resource);
   }
 
   /**
    * Load the binding configuration from the provided {@code file}.
    *
    * @param file
    *          the configuration resource
    * @throws IOException
    *           if an error occurred while reading the {@code file}
    * @throws BindingException
    *           if an error occurred while processing the binding configuration
    */
   public void load(File file) throws IOException, BindingException {
     load(file.toPath());
   }
 
   /**
    * Load the binding configuration from the provided {@code resource}.
    *
    * @param resource
    *          the configuration resource
    * @throws IOException
    *           if an error occurred while reading the {@code resource}
    * @throws BindingException
    *           if an error occurred while processing the binding configuration
    */
   public void load(@NonNull URL resource) throws IOException, BindingException {
     IBindingContext context = IBindingContext.newInstance();
     IDeserializer<MetaschemaBindings> deserializer = context.newDeserializer(Format.XML, MetaschemaBindings.class);
 
     MetaschemaBindings bindings;
     try {
       bindings = deserializer.deserialize(resource);
     } catch (IOException | URISyntaxException ex) {
       throw new IOException("Failed to parse binding configuration: " + resource, ex);
     }
 
     List<MetaschemaBindings.ModelBinding> modelBindings = bindings.getModelBindings();
     for (MetaschemaBindings.ModelBinding model : modelBindings) {
       processModelBindingConfig(model);
     }
 
     List<MetaschemaBindings.MetaschemaBinding> metaschemaBindings = bindings.getMetaschemaBindings();
     for (MetaschemaBindings.MetaschemaBinding metaschema : metaschemaBindings) {
       try {
         processMetaschemaBindingConfig(resource, metaschema);
       } catch (MalformedURLException | URISyntaxException ex) {
         throw new IOException(ex);
       }
     }
   }
 
   private void processModelBindingConfig(MetaschemaBindings.ModelBinding model) {
     String namespace = model.getNamespace().toString();
 
     MetaschemaBindings.ModelBinding.Java java = model.getJava();
     if (java != null) {
       String packageName = java.getUsePackageName();
       if (packageName != null) {
         addModelBindingConfig(namespace, packageName);
       }
     }
   }
 
   private void processMetaschemaBindingConfig(URL configResource, MetaschemaBindings.MetaschemaBinding metaschema)
       throws MalformedURLException, URISyntaxException, BindingException {
     String href = metaschema.getHref().toString();
     URL moduleUrl = new URL(configResource, href);
     String moduleUri = ObjectUtils.notNull(moduleUrl.toURI().normalize().toString());
 
     MetaschemaBindingConfiguration metaschemaConfig = getMetaschemaBindingConfiguration(moduleUri);
     if (metaschemaConfig == null) {
       metaschemaConfig = new MetaschemaBindingConfiguration();
       addMetaschemaBindingConfiguration(moduleUri, metaschemaConfig);
     }
 
     List<MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding> assemblyBindings
         = metaschema.getDefineAssemblyBindings();
     for (MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding assemblyBinding : assemblyBindings) {
       String name = assemblyBinding.getName();
       String target = assemblyBinding.getTarget();
 
       // Determine the lookup key - use name if provided, otherwise use target
       String lookupKey = name != null ? name : target;
       if (lookupKey != null) {
         IDefinitionBindingConfiguration config = metaschemaConfig.getAssemblyDefinitionBindingConfig(lookupKey);
         config = processDefinitionBindingConfiguration(config, assemblyBinding.getJava());
         metaschemaConfig.addAssemblyDefinitionBindingConfig(lookupKey, config);
 
         // Process property bindings for this assembly
         processAssemblyPropertyBindings(metaschemaConfig, lookupKey, assemblyBinding.getPropertyBindings());
 
         // Process choice group bindings for this assembly
         processChoiceGroupBindings(config, assemblyBinding.getChoiceGroupBindings());
       } else {
         LOGGER.warn("Assembly binding in metaschema '{}' has neither 'name' nor 'target' attribute; skipping",
             moduleUri);
       }
     }
 
     List<MetaschemaBindings.MetaschemaBinding.DefineFieldBinding> fieldBindings
         = metaschema.getDefineFieldBindings();
     for (MetaschemaBindings.MetaschemaBinding.DefineFieldBinding fieldBinding : fieldBindings) {
       String name = fieldBinding.getName();
       String target = fieldBinding.getTarget();
 
       // Determine the lookup key - use name if provided, otherwise use target
       String lookupKey = name != null ? name : target;
       if (lookupKey != null) {
         IDefinitionBindingConfiguration config = metaschemaConfig.getFieldDefinitionBindingConfig(lookupKey);
         config = processDefinitionBindingConfiguration(config, fieldBinding.getJava());
         metaschemaConfig.addFieldDefinitionBindingConfig(lookupKey, config);
 
         // Process property bindings for this field
         processFieldPropertyBindings(metaschemaConfig, lookupKey, fieldBinding.getPropertyBindings());
       } else {
         LOGGER.warn("Field binding in metaschema '{}' has neither 'name' nor 'target' attribute; skipping",
             moduleUri);
       }
     }
   }
 
   /**
    * Process property bindings from a definition binding element.
    * <p>
    * This generic helper method consolidates the common logic for processing
    * property bindings from both assembly and field definition bindings.
    *
    * @param <P>
    *          the property binding type
    * @param <J>
    *          the Java configuration type
    * @param metaschemaConfig
    *          the metaschema binding configuration to add property bindings to
    * @param definitionName
    *          the name of the containing definition
    * @param propertyBindings
    *          the list of property bindings to process
    * @param nameAccessor
    *          function to extract the property name from a binding
    * @param javaAccessor
    *          function to extract the Java config from a binding
    * @param collectionClassAccessor
    *          function to extract the collection class name from a Java config
    * @throws BindingException
    *           if the collection class is invalid or cannot be found
    */
   private static <P, J> void processPropertyBindings(
       @NonNull MetaschemaBindingConfiguration metaschemaConfig,
       @NonNull String definitionName,
       @Nullable List<P> propertyBindings,
       @NonNull Function<P, String> nameAccessor,
       @NonNull Function<P, J> javaAccessor,
       @NonNull Function<J, String> collectionClassAccessor) throws BindingException {
     if (propertyBindings == null) {
       return;
     }
 
     for (P propertyBinding : propertyBindings) {
       String propertyName = nameAccessor.apply(propertyBinding);
       if (propertyName == null) {
         continue;
       }
 
       J java = javaAccessor.apply(propertyBinding);
       if (java == null) {
         continue;
       }
 
       String collectionClassName = collectionClassAccessor.apply(java);
       if (collectionClassName != null) {
         // Validate the collection class
         validateCollectionClass(collectionClassName, definitionName, propertyName);
 
         IMutablePropertyBindingConfiguration config = new DefaultPropertyBindingConfiguration();
         config.setCollectionClassName(collectionClassName);
         metaschemaConfig.addPropertyBindingConfig(definitionName, propertyName, config);
       }
     }
   }
 
   /**
    * Validate that the specified collection class exists and implements a
    * supported collection interface (Collection or Map).
    *
    * @param collectionClassName
    *          the fully qualified class name to validate
    * @param definitionName
    *          the name of the containing definition (for error messages)
    * @param propertyName
    *          the name of the property (for error messages)
    * @throws BindingException
    *           if the class cannot be found or does not implement a supported
    *           collection interface
    */
   private static void validateCollectionClass(
       @NonNull String collectionClassName,
       @NonNull String definitionName,
       @NonNull String propertyName) throws BindingException {
     Class<?> collectionClass;
     try {
       collectionClass = Class.forName(collectionClassName);
     } catch (ClassNotFoundException ex) {
       throw new BindingException(String.format(
           "Collection class '%s' for property '%s' in definition '%s' could not be found",
           collectionClassName, propertyName, definitionName), ex);
     }
 
     // Check if the class implements Collection or Map
     if (!Collection.class.isAssignableFrom(collectionClass) && !Map.class.isAssignableFrom(collectionClass)) {
       throw new BindingException(String.format(
           "Collection class '%s' for property '%s' in definition '%s' must implement "
               + "java.util.Collection or java.util.Map",
           collectionClassName, propertyName, definitionName));
     }
   }
 
   /**
    * Process property bindings from a define-assembly-binding element.
    *
    * @param metaschemaConfig
    *          the metaschema binding configuration to add property bindings to
    * @param definitionName
    *          the name of the containing definition
    * @param propertyBindings
    *          the list of property bindings to process
    * @throws BindingException
    *           if the collection class is invalid or cannot be found
    */
   private static void processAssemblyPropertyBindings(
       @NonNull MetaschemaBindingConfiguration metaschemaConfig,
       @NonNull String definitionName,
       @Nullable List<MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding> propertyBindings)
       throws BindingException {
     processPropertyBindings(
         metaschemaConfig,
         definitionName,
         propertyBindings,
         MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding::getName,
         MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding::getJava,
         MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding.Java::getCollectionClass);
   }
 
   /**
    * Process property bindings from a define-field-binding element.
    *
    * @param metaschemaConfig
    *          the metaschema binding configuration to add property bindings to
    * @param definitionName
    *          the name of the containing definition
    * @param propertyBindings
    *          the list of property bindings to process
    * @throws BindingException
    *           if the collection class is invalid or cannot be found
    */
   private static void processFieldPropertyBindings(
       @NonNull MetaschemaBindingConfiguration metaschemaConfig,
       @NonNull String definitionName,
       @Nullable List<MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding> propertyBindings)
       throws BindingException {
     processPropertyBindings(
         metaschemaConfig,
         definitionName,
         propertyBindings,
         MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding::getName,
         MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding::getJava,
         MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding.Java::getCollectionClass);
   }
 
   /**
    * Process choice group bindings from a define-assembly-binding element.
    *
    * @param config
    *          the definition binding configuration to add choice group bindings to
    * @param choiceGroupBindings
    *          the list of choice group bindings to process
    */
   private static void processChoiceGroupBindings(
       @NonNull IDefinitionBindingConfiguration config,
       @Nullable List<
           MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding> choiceGroupBindings) {
     if (choiceGroupBindings == null || !(config instanceof DefaultDefinitionBindingConfiguration)) {
       return;
     }
 
     DefaultDefinitionBindingConfiguration mutableConfig = (DefaultDefinitionBindingConfiguration) config;
     for (MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding choiceGroupBinding : choiceGroupBindings) {
       String groupAsName = choiceGroupBinding.getName();
       IChoiceGroupBindingConfiguration choiceGroupConfig
           = new DefaultChoiceGroupBindingConfiguration(choiceGroupBinding);
       mutableConfig.addChoiceGroupBinding(groupAsName, choiceGroupConfig);
     }
   }
 
   @NonNull
   private static IMutableDefinitionBindingConfiguration processDefinitionBindingConfiguration(
       @Nullable IDefinitionBindingConfiguration oldConfig,
       @Nullable MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.Java java) {
     IMutableDefinitionBindingConfiguration config = oldConfig == null
         ? new DefaultDefinitionBindingConfiguration()
         : new DefaultDefinitionBindingConfiguration(oldConfig);
 
     if (java != null) {
       String className = java.getUseClassName();
       if (className != null) {
         config.setClassName(ObjectUtils.notNull(className));
       }
 
       String baseClass = java.getExtendBaseClass();
       if (baseClass != null) {
         config.setQualifiedBaseClassName(ObjectUtils.notNull(baseClass));
       }
 
       List<String> interfaces = java.getImplementInterfaces();
       for (String interfaceName : interfaces) {
         config.addInterfaceToImplement(Objects.requireNonNull(interfaceName,
             "interface name cannot be null in implement-interfaces configuration"));
       }
     }
     return config;
   }
 
   @NonNull
   private static IMutableDefinitionBindingConfiguration processDefinitionBindingConfiguration(
       @Nullable IDefinitionBindingConfiguration oldConfig,
       @Nullable MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.Java java) {
     IMutableDefinitionBindingConfiguration config = oldConfig == null
         ? new DefaultDefinitionBindingConfiguration()
         : new DefaultDefinitionBindingConfiguration(oldConfig);
 
     if (java != null) {
       String className = java.getUseClassName();
       if (className != null) {
         config.setClassName(ObjectUtils.notNull(className));
       }
 
       String baseClass = java.getExtendBaseClass();
       if (baseClass != null) {
         config.setQualifiedBaseClassName(ObjectUtils.notNull(baseClass));
       }
 
       List<String> interfaces = java.getImplementInterfaces();
       for (String interfaceName : interfaces) {
         config.addInterfaceToImplement(Objects.requireNonNull(interfaceName,
             "interface name cannot be null in implement-interfaces configuration"));
       }
     }
     return config;
   }
 
   /**
    * Holds binding configurations for a specific Metaschema module.
    * <p>
    * This class maintains mappings from definition names to their binding
    * configurations for both assembly and field definitions.
    */
   public static final class MetaschemaBindingConfiguration {
     private final Map<String, IDefinitionBindingConfiguration> assemblyBindingConfigs = new ConcurrentHashMap<>();
     private final Map<String, IDefinitionBindingConfiguration> fieldBindingConfigs = new ConcurrentHashMap<>();
     // Map structure: definition name -> property name -> property binding config
     private final Map<String, Map<String, IPropertyBindingConfiguration>> propertyBindingConfigs
         = new ConcurrentHashMap<>();
 
     private MetaschemaBindingConfiguration() {
     }
 
     /**
      * Get the binding configuration for the {@link IAssemblyDefinition} with the
      * provided {@code name}.
      *
      * @param name
      *          the definition name
      * @return the definition's binding configuration or {@code null} if no
      *         configuration is provided
      */
     @Nullable
     public IDefinitionBindingConfiguration getAssemblyDefinitionBindingConfig(@NonNull String name) {
       return assemblyBindingConfigs.get(name);
     }
 
     /**
      * Get the binding configuration for the {@link IFieldDefinition} with the
      * provided {@code name}.
      *
      * @param name
      *          the definition name
      * @return the definition's binding configuration or {@code null} if no
      *         configuration is provided
      */
     @Nullable
     public IDefinitionBindingConfiguration getFieldDefinitionBindingConfig(@NonNull String name) {
       return fieldBindingConfigs.get(name);
     }
 
     /**
      * Set the binding configuration for the {@link IAssemblyDefinition} with the
      * provided {@code name}.
      *
      * @param name
      *          the definition name
      * @param config
      *          the new binding configuration for the definition
      * @return the definition's old binding configuration or {@code null} if no
      *         configuration was previously provided
      */
     @Nullable
     public IDefinitionBindingConfiguration addAssemblyDefinitionBindingConfig(@NonNull String name,
         @NonNull IDefinitionBindingConfiguration config) {
       return assemblyBindingConfigs.put(name, config);
     }
 
     /**
      * Set the binding configuration for the {@link IFieldDefinition} with the
      * provided {@code name}.
      *
      * @param name
      *          the definition name
      * @param config
      *          the new binding configuration for the definition
      * @return the definition's old binding configuration or {@code null} if no
      *         configuration was previously provided
      */
     @Nullable
     public IDefinitionBindingConfiguration addFieldDefinitionBindingConfig(@NonNull String name,
         @NonNull IDefinitionBindingConfiguration config) {
       return fieldBindingConfigs.put(name, config);
     }
 
     /**
      * Get the property binding configuration for a specific property within a
      * definition.
      *
      * @param definitionName
      *          the name of the containing definition
      * @param propertyName
      *          the name of the property
      * @return the property binding configuration, or {@code null} if none is
      *         configured
      */
     @Nullable
     public IPropertyBindingConfiguration getPropertyBindingConfig(
         @NonNull String definitionName,
         @NonNull String propertyName) {
       Map<String, IPropertyBindingConfiguration> defProps = propertyBindingConfigs.get(definitionName);
       return defProps == null ? null : defProps.get(propertyName);
     }
 
     /**
      * Set the property binding configuration for a specific property within a
      * definition.
      *
      * @param definitionName
      *          the name of the containing definition
      * @param propertyName
      *          the name of the property
      * @param config
      *          the property binding configuration
      * @return the old property binding configuration, or {@code null} if none was
      *         previously configured
      */
     @Nullable
     public IPropertyBindingConfiguration addPropertyBindingConfig(
         @NonNull String definitionName,
         @NonNull String propertyName,
         @NonNull IPropertyBindingConfiguration config) {
       return propertyBindingConfigs
           .computeIfAbsent(definitionName, k -> new ConcurrentHashMap<>())
           .put(propertyName, config);
     }
   }
 }