package net.sf.okapi.common.filters;
   
   import java.lang.reflect.InvocationTargetException;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Spliterator;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.function.Consumer;
  import java.util.function.Function;
  import java.util.function.Supplier;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import net.sf.okapi.common.IParameters;
  import net.sf.okapi.common.IParametersEditor;
  
  /**
   * Thread-safe implementation of {@link IFilterConfigurationMapper} that provides
   * a shared, unified view of filter configurations across all threads.
   * 
   * <p>
   * <b>Key Differences from ThreadSafeFilterConfigurationMapper:</b>
   * </p>
   * <ul>
   * <li>Uses {@link ConcurrentHashMap} for shared configuration storage</li>
   * <li>Provides consistent view of configurations across all threads</li>
   * <li>Eliminates thread-local storage overhead</li>
   * <li>Better suited for applications requiring configuration consistency</li>
   * </ul>
   * 
   * <p>
   * <b>Thread Safety:</b>
   * </p>
   * <ul>
   * <li>All read operations are lock-free and thread-safe</li>
   * <li>Write operations use appropriate synchronization</li>
   * <li>Configuration updates are atomic at the individual configuration level</li>
   * </ul>
   * 
   * @author Okapi Framework Development Team
   */
  public class SharedFilterConfigurationMapper implements IFilterConfigurationMapper {
    private static final Logger logger = LoggerFactory
        .getLogger(SharedFilterConfigurationMapper.class);
  
    /**
     * Shared thread-safe map of filter configurations, visible to all threads.
     * Uses ConcurrentHashMap to provide lock-free reads and thread-safe writes.
     */
    private final Map<String, FilterConfiguration> configMap;
  
    /**
     * Creates an empty SharedFilterConfigurationMapper.
     * Initializes with an empty ConcurrentHashMap.
     */
    public SharedFilterConfigurationMapper() {
      this.configMap = new ConcurrentHashMap<>();
    }
  
    /**
     * Creates a SharedFilterConfigurationMapper with pre-loaded configurations.
     *
     * @param initialConfigs initial map of filter configurations to populate the mapper
     */
    public SharedFilterConfigurationMapper(Map<String, FilterConfiguration> initialConfigs) {
      this.configMap = new ConcurrentHashMap<>(initialConfigs);
    }
  
    /**
     * Creates a SharedFilterConfigurationMapper using a supplier for initial configurations.
     *
     * @param fcSupplier supplier that provides the initial map of filter configurations
     */
    public SharedFilterConfigurationMapper(Supplier<Map<String, FilterConfiguration>> fcSupplier) {
      this.configMap = new ConcurrentHashMap<>(fcSupplier.get());
    }
  
    /**
     * Creates default parameters for a filter configuration.
     * Attempts to load parameters from various sources in order of priority:
     * <ol>
     * <li>Existing parameters in the configuration</li>
     * <li>Parameters from the specified location</li>
     * <li>Default reset parameters</li>
     * </ol>
     *
     * @param fc the filter configuration to create parameters for
     * @return IParameters instance with loaded default parameters
     */
    private static IParameters createDefaultParameters(FilterConfiguration fc) {
      // Create a unique IParameters instance from the filter
      try (IFilter filter = instantiateFilter(fc.filterClass)) {
       IParameters params = filter.getParameters();
 
       // Priority 1: Use parameters previously loaded in configuration
       if (fc.parameters != null) {
         // Load parameters from config as these may have been updated externally
         params.fromString(fc.parameters.toString());
         return params;
       }
       // Priority 2: Load parameters from specified location
       else if (fc.parametersLocation != null) {
         params.load(filter.getClass().getResourceAsStream(fc.parametersLocation), false);
         return params;
       }
 
       // Priority 3: Use default reset parameters
       if (params != null) {
         params.reset();
       }
       
       return params;
     }
   }
 
   /**
    * Instantiates a filter using reflection.
    * Uses the current thread's context class loader for class loading.
    *
    * @param filterClass the fully qualified class name of the filter to instantiate
    * @return new IFilter instance
    * @throws IllegalArgumentException if filter instantiation fails
    */
   private static IFilter instantiateFilter(String filterClass) {
     try {
       return (IFilter) Thread.currentThread().getContextClassLoader().loadClass(filterClass)
           .getDeclaredConstructor().newInstance();
     } catch (InstantiationException | IllegalAccessException | NoSuchMethodException
         | InvocationTargetException | ClassNotFoundException e) {
       throw new IllegalArgumentException("Could not instantiate: " + filterClass, e);
     }
   }
 
   @Override
   public void addCustomConfiguration(String configId, IParameters parameters) {
     // Prevent overwriting existing configurations
     if (configMap.containsKey(configId)) {
       return;
     }
 
     FilterConfiguration fc = new FilterConfiguration();
     fc.custom = true;
     fc.configId = configId;
 
     // Extract filter name from configuration ID
     String[] res = IFilterConfigurationMapper.splitFilterFromConfiguration(fc.configId);
 
     // Create the filter instance (assumes base-name is the default config ID)
     try (IFilter filter = createFilter(res[0])) {
       // Populate filter configuration details
       fc.filterClass = filter.getClass().getName();
       fc.mimeType = filter.getMimeType();
       fc.description = "Configuration " + fc.configId;
       fc.name = fc.configId;
       fc.parameters = filter.getParameters();
       fc.parameters.fromString(parameters.toString());
 
       // Atomically add to shared map if not present
       configMap.putIfAbsent(fc.configId, fc);
       logger.debug("Added custom config: {} with parameters: {}", configId, parameters);
     }
   }
 
   @Override
   public void addCustomConfiguration(String configId, String parameters) {
     // Prevent overwriting existing configurations
     if (configMap.containsKey(configId)) {
       return;
     }
 
     FilterConfiguration fc = new FilterConfiguration();
     fc.custom = true;
     fc.configId = configId;
 
     // Extract filter name from configuration ID
     String[] res = IFilterConfigurationMapper.splitFilterFromConfiguration(fc.configId);
 
     // Create the filter instance (assumes base-name is the default config ID)
     try (IFilter filter = createFilter(res[0])) {
       // Populate filter configuration details
       fc.filterClass = filter.getClass().getName();
       fc.mimeType = filter.getMimeType();
       fc.description = "Configuration " + fc.configId;
       fc.name = fc.configId;
       fc.parameters = filter.getParameters();
       fc.parameters.fromString(parameters);
 
       // Atomically add to shared map if not present
       configMap.putIfAbsent(fc.configId, fc);
       logger.debug("Added custom config: {} with parameters: {}", configId, parameters);
     }
   }
 
   @Override
   public void addConfigurations(String filterClass) {
     // Add all configurations for the specified filter class
     try (IFilter filter = instantiateFilter(filterClass)) {
       // Retrieve available configurations for this filter
       List<FilterConfiguration> list = filter.getConfigurations();
       if ((list == null) || (list.isEmpty())) {
         logger.warn("No configuration provided for '{}'", filterClass);
         return;
       }
 
       for (FilterConfiguration config : list) {
         // Skip if configuration already exists
         if (configMap.containsKey(config.configId)) {
           continue;
         }
 
         // Load default parameters for this configuration
         config.parameters = createDefaultParameters(config);
 
         // Validate and populate missing configuration fields
         if (config.filterClass == null) {
           logger.warn("Configuration without filter class name in '{}'", config);
           config.filterClass = filterClass;
         }
         if (config.name == null) {
           logger.warn("Configuration without name in '{}'", config);
           config.name = config.toString();
         }
         if (config.description == null) {
           logger.warn("Configuration without description in '{}'", config);
           config.description = config.toString();
         }
 
         // Atomically add to shared map
         configMap.putIfAbsent(config.configId, config);
         logger.debug("Added config: {} with parameters: {}", config.configId, config.parameters);
       }
     }
   }
 
   @Override
   public void addConfiguration(FilterConfiguration config) {
     // Atomically add single configuration to shared map
     configMap.putIfAbsent(config.configId, config);
     logger.debug("Added config: {} with parameters: {}", config.configId, config.parameters);
   }
 
   @Override
   public IFilter createFilter(String configId, IFilter existingFilter) {
     // Retrieve configuration for the specified configId
     FilterConfiguration fc = getConfiguration(configId);
     if (fc == null) {
       logger.error("Cannot find filter configuration '{}'", configId);
       return null;
     }
 
     // For thread safety, always create a new filter instance (ignore existingFilter)
     try {
       IFilter filter = instantiateFilter(fc.filterClass);
       filter.setFilterConfigurationMapper(this);
 
       // Apply parameters from configuration to the new filter instance
       IParameters params = filter.getParameters();
       if (params != null && fc.parameters != null) {
         params.fromString(fc.parameters.toString());
         filter.setParameters(params);
       }
 
       return filter;
 
     } catch (Exception e) {
       logger.error("Error creating filter for configuration '{}'", configId, e);
       return null;
     }
   }
 
   @Override
   public void clearConfigurations(boolean customOnly) {
     if (customOnly) {
       // Remove only custom configurations
       configMap.entrySet().removeIf(entry -> entry.getValue().custom);
     } else {
       // Remove all configurations
       configMap.clear();
     }
   }
 
   @Override
   public IFilter createFilter(String configId) {
     return createFilter(configId, null);
   }
 
   @Override
   public FilterConfiguration getConfiguration(String configId) {
     // Thread-safe read from concurrent map
     return configMap.get(configId);
   }
 
   @Override
   public FilterConfiguration getDefaultConfiguration(String mimeType) {
     // Special handling for XLIFF formats that share the same MIME type
     // Use the autoxliff filter to disambiguate between xliff1.2 and xliff2
     FilterConfiguration autoXliff = getConfiguration("okf_autoxliff");
     if (autoXliff != null && autoXliff.mimeType != null && autoXliff.mimeType.equals(mimeType)) {
       return autoXliff;
     }
 
     FilterConfiguration defaultConfig = null;
     for (FilterConfiguration config : configMap.values()) {
       if (config.mimeType == null || !config.mimeType.equals(mimeType)) {
         continue;
       }
 
       // Assume configurations without parametersLocation are defaults
       if (config.parametersLocation == null) {
         return config;
       }
 
       // Fallback: use first registered match if all have parametersLocation
       if (defaultConfig == null) {
         defaultConfig = config;
       }
     }
 
     return defaultConfig;
   }
 
   @Override
   public FilterConfiguration getDefaultConfigurationFromExtension(String ext) {
     // Normalize extension format for comparison
     String tmp = ext.toLowerCase() + ";";
     if (tmp.charAt(0) != '.') {
       tmp = ".".concat(tmp);
     }
 
     // Special handling for XLIFF formats that share the same file extensions
     // Use the autoxliff filter to disambiguate
     FilterConfiguration autoXliff = getConfiguration("okf_autoxliff");
     if (autoXliff != null && autoXliff.extensions != null && autoXliff.extensions.contains(tmp)) {
       return autoXliff;
     }
 
     // Search for configuration matching the file extension
     for (FilterConfiguration config : configMap.values()) {
       if (config.extensions != null) {
         // Ensure extensions string has trailing semicolon for proper matching
         String configExtensions = config.extensions + ";";
         if (configExtensions.contains(tmp)) {
           return config;
         }
       }
     }
     return null;
   }
 
   @Override
   public IParameters getParameters(FilterConfiguration config) {
     if (config == null) {
       return null;
     }
 
     try (IFilter filter = instantiateFilter(config.filterClass)) {
       IParameters params = filter.getParameters();
       if (params == null) {
         return null;
       }
 
       // Load parameters based on configuration settings
       if (config.parameters != null) {
         params.fromString(config.parameters.toString());
       } else if (config.parametersLocation != null) {
         params.load(filter.getClass().getResourceAsStream(config.parametersLocation), false);
       } else {
         params.reset();
       }
 
       return params;
     }
   }
 
   @Override
   public IParameters getParameters(FilterConfiguration config, IFilter existingFilter) {
     // For thread safety, ignore existingFilter and always create new parameters
     return getParameters(config);
   }
 
   @Override
   public FilterConfiguration createCustomConfiguration(FilterConfiguration baseConfig) {
     // Create a new custom configuration based on the base configuration
     FilterConfiguration newConfig = new FilterConfiguration();
     String[] res = IFilterConfigurationMapper.splitFilterFromConfiguration(baseConfig.configId);
     if (res == null) {
       return null;
     }
 
     newConfig.custom = true;
     // Generate unique configuration ID for the copy
     if (res[1] == null) {
       newConfig.configId = String.format("%s%ccopy-of-default",
           res[0], IFilterConfigurationMapper.CONFIGFILE_SEPARATOR);
     } else {
       newConfig.configId = String.format("%s%ccopy-of-%s",
           res[0], IFilterConfigurationMapper.CONFIGFILE_SEPARATOR, res[1]);
     }
 
     // Copy base configuration properties
     newConfig.classLoader = baseConfig.classLoader;
     newConfig.name = newConfig.configId;
     newConfig.description = "Copy of " + baseConfig.description;
     newConfig.filterClass = baseConfig.filterClass;
     newConfig.mimeType = baseConfig.mimeType;
     newConfig.extensions = baseConfig.extensions;
 
     // Deep copy parameters
     if (baseConfig.parameters != null) {
       try (IFilter filter = instantiateFilter(baseConfig.filterClass)) {
         IParameters params = filter.getParameters();
         if (params != null) {
           params.fromString(baseConfig.parameters.toString());
           newConfig.parameters = params;
         }
       }
     }
 
     return newConfig;
   }
 
   @Override
   public IParameters getCustomParameters(FilterConfiguration config, IFilter existingFilter) {
     // Return parameters only for custom configurations
     if (config.custom && config.parameters != null) {
       return config.parameters;
     }
     return null;
   }
 
   @Override
   public IParameters getCustomParameters(FilterConfiguration config) {
     return getCustomParameters(config, null);
   }
 
   @Override
   public Iterator<FilterConfiguration> getAllConfigurations() {
     return configMap.values().iterator();
   }
 
   @Override
   public List<FilterConfiguration> getFilterConfigurations(String filterClass) {
     List<FilterConfiguration> list = new ArrayList<>();
     // Find all configurations for the specified filter class
     for (FilterConfiguration config : configMap.values()) {
       if (config.filterClass != null && config.filterClass.equals(filterClass)) {
         list.add(config);
       }
     }
     return list;
   }
 
   @Override
   public IParametersEditor createConfigurationEditor(String configId, IFilter existingFilter) {
     throw new UnsupportedOperationException(
         "Configuration editors are not supported in this implementation");
   }
 
   @Override
   public IParametersEditor createConfigurationEditor(String configId) {
     throw new UnsupportedOperationException(
         "Configuration editors are not supported in this implementation");
   }
 
   @Override
   public List<FilterInfo> getFiltersInfo() {
     List<FilterInfo> filtersInfo = new ArrayList<>();
     Set<String> processedFilterClasses = new HashSet<>();
 
     // Collect unique filter information
     for (FilterConfiguration config : configMap.values()) {
       if (config.filterClass != null && !processedFilterClasses.contains(config.filterClass)) {
         try (IFilter filter = instantiateFilter(config.filterClass)) {
           FilterInfo info = new FilterInfo();
           info.className = config.filterClass;
           info.name = filter.getName();
           info.displayName = filter.getDisplayName();
           filtersInfo.add(info);
           processedFilterClasses.add(config.filterClass);
         } catch (Exception e) {
           logger.warn("Could not create filter info for {}", config.filterClass, e);
         }
       }
     }
 
     // Sort filters alphabetically by name
     Collections.sort(filtersInfo);
     return filtersInfo;
   }
 
   @Override
   public List<FilterConfiguration> getMimeConfigurations(String mimeType) {
     List<FilterConfiguration> list = new ArrayList<>();
     // Find all configurations for the specified MIME type
     for (FilterConfiguration config : configMap.values()) {
       if (config.mimeType != null && config.mimeType.equals(mimeType)) {
         list.add(config);
       }
     }
     return list;
   }
 
   @Override
   public void removeConfiguration(String configId) {
     configMap.remove(configId);
   }
 
   @Override
   public Iterator<FilterConfiguration> iterator() {
     return configMap.values().iterator();
   }
 
   @Override
   public void forEach(Consumer<? super FilterConfiguration> action) {
     configMap.values().forEach(action);
   }
 
   @Override
   public Spliterator<FilterConfiguration> spliterator() {
     return configMap.values().spliterator();
   }
 
   @Override
   public void removeConfigurations(String filterClass) {
     // Remove all configurations for the specified filter class
     configMap.entrySet().removeIf(entry -> entry.getValue().filterClass.equals(filterClass));
   }
 
   @Override
   public void saveCustomParameters(FilterConfiguration config, IParameters params) {
     if (config != null && params != null) {
       // Update parameters in the shared map with synchronization
       FilterConfiguration existingConfig = configMap.get(config.configId);
       if (existingConfig != null) {
         synchronized (existingConfig) { // Lock on the specific config object for update
           existingConfig.parameters = params;
         }
       }
     }
   }
 
   @Override
   public void deleteCustomParameters(FilterConfiguration config) {
     if (config != null) {
       // Clear parameters for the specified configuration
       FilterConfiguration existingConfig = configMap.get(config.configId);
       if (existingConfig != null) {
         synchronized (existingConfig) { // Lock on the specific config object for update
           existingConfig.parameters = null;
         }
       }
     }
   }
 
   /**
    * Builder for creating and configuring SharedFilterConfigurationMapper instances.
    * <p>
    * This builder allows for easy configuration of filter configurations
    * before creating the mapper.
    * 
    * <p>
    * <b>Usage Example:</b>
    * </p>
    * 
    * <pre>
    * SharedFilterConfigurationMapper mapper = new SharedFilterConfigurationMapper.ConfigBuilder()
    *     .addConfigurations(XMLFilter.class)
    *     .addConfigurations(PlainTextFilter.class)
    *     .updateConfiguration("okf_xml@custom", "customParams")
    *     .buildMapper();
    * </pre>
    */
   public static class ConfigBuilder {
     private final Map<String, FilterConfiguration> configs = new HashMap<>();
 
     /**
      * Adds all configurations from a filter class to the builder.
      *
      * @param filterClass the filter class to add configurations from
      * @return this builder for method chaining
      * @throws IllegalArgumentException if the filter cannot be instantiated or configurations
      *                                  loaded
      */
     public ConfigBuilder addConfigurations(Class<? extends IFilter> filterClass) {
       try {
         try (IFilter filter = instantiateFilter(filterClass.getCanonicalName())) {
           for (FilterConfiguration config : filter.getConfigurations()) {
             if (configs.containsKey(config.configId)) {
               continue;
             }
             // Load the default parameters as we may need to update them later
             config.parameters = createDefaultParameters(config);
             configs.put(config.configId, config);
           }
         }
         return this;
       } catch (Exception e) {
         throw new IllegalArgumentException(
             "Couldn't add configurations for " + filterClass.getName(), e);
       }
     }
 
     /**
      * Updates a specific configuration with new parameters.
      *
      * @param configId the configuration ID to update
      * @param params   the new parameters as a string
      * @return this builder for method chaining
      * @throws IllegalArgumentException if the configuration cannot be found
      */
     public ConfigBuilder updateConfiguration(String configId, String params) {
       try {
         String[] parts = IFilterConfigurationMapper.splitFilterFromConfiguration(configId);
         // Look up the base filter
         FilterConfiguration baseFilter = configs.get(parts[0]);
         if (baseFilter == null) {
           throw new IllegalArgumentException("Couldn't find base filter for " + configId);
         }
         FilterConfiguration fc = configs.get(configId);
         if (fc == null) {
           throw new IllegalArgumentException("Couldn't find filter configuration for " + configId);
         }
         // Update the parameters
         fc.parameters.fromString(params);
         configs.put(configId, fc);
         return this;
       } catch (Exception e) {
         throw new IllegalArgumentException("Couldn't update configurations for " + configId, e);
       }
     }
 
     /**
      * Applies a transformation function to all configurations' parameters.
      *
      * @param function the function to apply to each configuration's parameters
      * @return this builder for method chaining
      */
     public ConfigBuilder updateConfigurations(Function<IParameters, IParameters> function) {
       for (FilterConfiguration config : configs.values()) {
         config.parameters = function.apply(config.parameters);
       }
       return this;
     }
 
     /**
      * Builds the configuration map.
      *
      * @return an immutable map of filter configurations
      */
     public Map<String, FilterConfiguration> build() {
       return new HashMap<>(configs);
     }
 
     /**
      * Builds a SharedFilterConfigurationMapper with the configured settings.
      *
      * @return a new SharedFilterConfigurationMapper instance
      */
     public SharedFilterConfigurationMapper buildMapper() {
       return new SharedFilterConfigurationMapper(build());
     }
   }
 }