package co.codewizards.cloudstore.core.config;

import static co.codewizards.cloudstore.core.io.StreamUtil.*;
import static co.codewizards.cloudstore.core.oio.OioFileFactory.*;
import static co.codewizards.cloudstore.core.util.AssertUtil.*;
import static co.codewizards.cloudstore.core.util.PropertiesUtil.*;
import static co.codewizards.cloudstore.core.util.StringUtil.*;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.WeakHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import co.codewizards.cloudstore.core.appid.AppIdRegistry;
import co.codewizards.cloudstore.core.io.LockFile;
import co.codewizards.cloudstore.core.io.LockFileFactory;
import co.codewizards.cloudstore.core.oio.File;
import co.codewizards.cloudstore.core.repo.local.LocalRepoHelper;
import co.codewizards.cloudstore.core.repo.local.LocalRepoManager;

/**
 * Configuration of CloudStore supporting inheritance of settings.
 * <p>
 * See {@link Config}.
 *
 * @author Marco หงุ่ยตระกูล-Schulze - marco at codewizards dot co
 */
public class ConfigImpl implements Config {
        private static final Logger logger = LoggerFactory.getLogger(ConfigImpl.class);

        private static final long fileRefsCleanPeriod = 60000L;
        private static long fileRefsCleanLastTimestamp;

//      private static final String PROPERTIES_FILE_NAME_FOR_DIRECTORY_LOCAL = '.' + APP_ID_SIMPLE_ID + ".local.properties";

//      private static final String PROPERTIES_FILE_NAME_FOR_DIRECTORY = '.' + APP_ID_SIMPLE_ID + ".properties";

        /**
         * @deprecated We should only support one of these files - this is unnecessary!
         */
        @Deprecated
        private static final String PROPERTIES_FILE_NAME_FOR_DIRECTORY_VISIBLE = APP_ID_SIMPLE_ID + ".properties";

        private static final String PROPERTIES_TEMPLATE_FILE_NAME = "cloudstore.properties"; // *NOT* dependent on AppId!

        private static final String PROPERTIES_FILE_FORMAT_FOR_FILE_HIDDEN = ".%s." + APP_ID_SIMPLE_ID + ".properties";

        /**
         * @deprecated We should only support one of these files - this is unnecessary!
         */
        @Deprecated
        private static final String PROPERTIES_FILE_FORMAT_FOR_FILE_VISIBLE = "%s." + APP_ID_SIMPLE_ID + ".properties";

        private static final String TRUE_STRING = Boolean.TRUE.toString();
        private static final String FALSE_STRING = Boolean.FALSE.toString();

        private static final LinkedHashSet<File> fileHardRefs = new LinkedHashSet<>();
        private static final int fileHardRefsMaxSize = 30;
        /**
         * {@link SoftReference}s to the files used in {@link #file2Config}.
         * <p>
         * There is no {@code SoftHashMap}, hence we use a WeakHashMap combined with the {@code SoftReference}s here.
         * @see #file2Config
         */
        private static final LinkedList<SoftReference<File>> fileSoftRefs = new LinkedList<>();
        /**
         * @see #fileSoftRefs
         */
        private static final Map<File, ConfigImpl> file2Config = new WeakHashMap<File, ConfigImpl>();

        private static final class ConfigHolder {
                public static final ConfigImpl instance = new ConfigImpl(
                                null, null,
                                new File[] { createFile(ConfigDir.getInstance().getFile(), PROPERTIES_FILE_NAME_FOR_DIRECTORY_VISIBLE) });
        }

        private final ConfigImpl parentConfig;
        private final WeakReference<File> fileRef;
        protected final File[] propertiesFiles;
        private final long[] propertiesFilesLastModified;
        protected final Properties properties;

        private static final Object classMutex = ConfigImpl.class;
        private final Object instanceMutex;

        private long version = 0;

        protected ConfigImpl(final ConfigImpl parentConfig, final File file, final File [] propertiesFiles) {
                this.parentConfig = parentConfig;

                if (parentConfig == null)
                        fileRef = null;
                else
                        fileRef = new WeakReference<File>(assertNotNull(file, "file"));

                this.propertiesFiles = assertNotNullAndNoNullElement(propertiesFiles, "propertiesFiles");
                properties = new Properties(parentConfig == null ? null : parentConfig.properties);
                propertiesFilesLastModified = new long[propertiesFiles.length];
                instanceMutex = properties;

                // Create the default global configuration (it's an empty template with some comments).
                if (parentConfig == null && !propertiesFiles[0].exists()) {
                        try {
                                AppIdRegistry.getInstance().copyResourceResolvingAppId(
                                                ConfigImpl.class, "/" + PROPERTIES_TEMPLATE_FILE_NAME, propertiesFiles[0]);
                        } catch (final IOException e) {
                                throw new RuntimeException(e);
                        }
                }
        }

        /**
         * Get the directory or file for which this Config instance is responsible.
         * @return the directory or file for which this Config instance is responsible. Might be <code>null</code>, if already
         * garbage-collected or if this is the root-parent-Config. We try to make garbage-collection extremely unlikely
         * as long as the Config is held in memory.
         */
        protected File getFile() {
                return fileRef == null ? null : fileRef.get();
        }

        private static void cleanFileRefs() {
                synchronized (classMutex) {
                        if (System.currentTimeMillis() - fileRefsCleanLastTimestamp < fileRefsCleanPeriod)
                                return;

                        for (final Iterator<SoftReference<File>> it = fileSoftRefs.iterator(); it.hasNext(); ) {
                                final SoftReference<File> fileRef = it.next();
                                if (fileRef.get() == null)
                                        it.remove();
                        }
                        fileRefsCleanLastTimestamp = System.currentTimeMillis();
                }
        }

        /**
         * Gets the global {@code Config} for the current user.
         * @return the global {@code Config} for the current user. Never <code>null</code>.
         */
        public static Config getInstance() {
                return ConfigHolder.instance;
        }

        /**
         * Gets the {@code Config} for the given {@code directory}.
         * @param directory a directory inside a repository. Must not be <code>null</code>.
         * The directory does not need to exist (it may be created later).
         * @return the {@code Config} for the given {@code directory}. Never <code>null</code>.
         */
        public static Config getInstanceForDirectory(final File directory) {
                return getInstance(directory, true);
        }

        /**
         * Gets the {@code Config} for the given {@code file}.
         * @param file a file inside a repository. Must not be <code>null</code>.
         * The file does not need to exist (it may be created later).
         * @return the {@code Config} for the given {@code file}. Never <code>null</code>.
         */
        public static Config getInstanceForFile(final File file) {
                return getInstance(file, false);
        }

        private static Config getInstance(final File file, final boolean isDirectory) {
                assertNotNull(file, "file");
                cleanFileRefs();

                File config_file = null;
                ConfigImpl config;
                synchronized (classMutex) {
                        config = file2Config.get(file);
                        if (config != null) {
                                config_file = config.getFile();
                                if (config_file == null) // very unlikely, but it actually *can* happen.
                                        config = null; // we try to make it extremely probable that the Config we return does have a valid file reference.
                        }

                        if (config == null) {
                                final File localRoot = LocalRepoHelper.getLocalRootContainingFile(file);
                                if (localRoot == null)
                                        throw new IllegalArgumentException("file is not inside a repository: " + file.getAbsolutePath());

                                final ConfigImpl parentConfig = (ConfigImpl) (localRoot == file ? getInstance() : getInstance(file.getParentFile(), true));
                                config = new ConfigImpl(parentConfig, file, createPropertiesFiles(file, isDirectory));
                                file2Config.put(file, config);
                                fileSoftRefs.add(new SoftReference<File>(file));
                                config_file = config.getFile();
                        }
                        assertNotNull(config_file, "config_file");
                }
                refreshFileHardRefAndCleanOldHardRefs(config_file);
                return config;
        }

        private static File[] createPropertiesFiles(final File file, final boolean isDirectory) {
                if (isDirectory) {
                        List<File> files = new ArrayList<>();
                        File metaDir = createFile(file, LocalRepoManager.META_DIR_NAME);
                        if (metaDir.isDirectory())
                                files.add(createFile(metaDir, PROPERTIES_FILE_NAME_PARENT));

                        files.add(createFile(file, PROPERTIES_FILE_NAME_FOR_DIRECTORY));
                        files.add(createFile(file, PROPERTIES_FILE_NAME_FOR_DIRECTORY_VISIBLE));
                        files.add(createFile(file, PROPERTIES_FILE_NAME_FOR_DIRECTORY_LOCAL)); // overrides the settings of the shared file!
                        return files.toArray(new File[files.size()]);
                }
                else {
                        return new File[] {
                                createFile(file.getParentFile(), String.format(PROPERTIES_FILE_FORMAT_FOR_FILE_HIDDEN, file.getName())),
                                createFile(file.getParentFile(), String.format(PROPERTIES_FILE_FORMAT_FOR_FILE_VISIBLE, file.getName()))
                        };
                }
        }

        private void readIfNeeded() {
                synchronized (instanceMutex) {
                        for (int i = 0; i < propertiesFiles.length; i++) {
                                final File propertiesFile = propertiesFiles[i];
                                final long lastModified = propertiesFilesLastModified[i];
                                if (propertiesFile.lastModified() != lastModified) {
                                        read();
                                        break;
                                }
                        }
                }

                if (parentConfig != null)
                        parentConfig.readIfNeeded();
        }

        private void read() {
                synchronized (instanceMutex) {
                        logger.trace("read: Entered instanceMutex.");
                        try {
                                properties.clear();
                                version = 0;
                                for (int i = 0; i < propertiesFiles.length; i++) {
                                        final File propertiesFile = propertiesFiles[i];
                                        logger.debug("read: Reading propertiesFile '{}'.", propertiesFile.getAbsolutePath());
                                        final long lastModified = getLastModifiedAndWaitIfNeeded(propertiesFile);
                                        if (propertiesFile.exists()) { // prevent the properties file from being modified while we're reading it.
                                                try ( LockFile lockFile = LockFileFactory.getInstance().acquire(propertiesFile, 10000); ) { // TODO maybe system property for timeout?
                                                        final InputStream in = castStream(lockFile.createInputStream());
                                                        try {
                                                                properties.load(in);
                                                        } finally {
                                                                in.close();
                                                        }
                                                }
                                        }
                                        propertiesFilesLastModified[i] = lastModified;
                                        version += lastModified;
                                }
                        } catch (final IOException e) {
                                properties.clear();
                                throw new RuntimeException(e);
                        }
                }
        }

        private void write() {
                synchronized (instanceMutex) {
                        logger.trace("read: Entered instanceMutex.");
                        try {
                                // TODO We should switch to another Properties implementation (our own?! didn't I write one, already? where do I have this code?!)
                                // Using java.util.Properties causes the entries' order to be randomized and all comments in the file to be lost :-(

                                // Which of the multiple files is used? We overwrite this, if it's only one.

                                File propertiesFile = getSinglePropertiesFile();
                                if (propertiesFile == null)
                                        propertiesFile = propertiesFiles[propertiesFiles.length - 1]; // the last one has the last word ;-)

                                logger.debug("write: Writing propertiesFile '{}'.", propertiesFile.getAbsolutePath());
                                try ( LockFile lockFile = LockFileFactory.getInstance().acquire(propertiesFile, 10000); ) { // TODO maybe system property for timeout?
                                        final OutputStream out = castStream(lockFile.createOutputStream());
                                        try {
                                                properties.store(out, null);
                                        } finally {
                                                out.close();
                                        }
                                }

                                // TODO should we set propertiesFilesLastModified[...] to prevent re-reading?! would be more efficient - but then, we rarely ever write anyway.
                        } catch (final IOException e) {
                                properties.clear();
                                throw new RuntimeException(e);
                        }
                }
        }

        private File getSinglePropertiesFile() {
                File result = null;
                for (final File propertiesFile : propertiesFiles) {
                        if (propertiesFile.exists()) {
                                if (result == null)
                                        result = propertiesFile;
                                else
                                        return null; // multiple in use
                        }
                }

//              if (result == null) // none in use, yet => choose the .* one (the first)
//                      result = propertiesFiles[0]; // now using the local file by default (the last)

                return result;
        }

        /**
         * Gets the {@link File#lastModified() lastModified} timestamp of the given {@code file}
         * and waits if needed.
         * <p>
         * Waiting is needed, if the modification's age is shorter than the file system's time granularity.
         * Since we do not know the file system's time granularity, we assume 2 seconds. Thus, if the file
         * was changed e.g. 600 ms before invoking this method, the method will wait for 1400 ms to make sure
         * the modification is at least as old as the assumed file system's temporal granularity.
         * <p>
         * This waiting strategy makes sure that a future modification of the file, after the file was read,
         * is reliably detected - causing the file to be read again.
         * @param file the file whose {@link File#lastModified() lastModified} timestamp to obtain. Must not be <code>null</code>.
         * @return the {@link File#lastModified() lastModified} timestamp. 0, if the specified {@code file}
         * does not exist.
         */
        private long getLastModifiedAndWaitIfNeeded(final File file) {
                assertNotNull(file, "file");
                long lastModified = file.lastModified(); // is 0 for non-existing file
                final long now = System.currentTimeMillis();

                // Check and handle timestamp in the future.
                if (lastModified > now) {
                        file.setLastModified(now);
                        logger.warn("getLastModifiedAndWaitIfNeeded: lastModified of '{}' was in the future! Changed it to now!", file.getAbsolutePath());

                        lastModified = file.lastModified();
                        if (lastModified > now) {
                                logger.error("getLastModifiedAndWaitIfNeeded: lastModified of '{}' is in the future! Changing it FAILED! Permissions?!", file.getAbsolutePath());
                                return lastModified;
                        }
                }

                // Wait, if the modification is not yet older than the file system's (assumed!) granularity.
                // No file system should have a granularity worse than 2 seconds. Waiting max. 2 seconds in this use-case
                // in this rare situation is acceptable. After all, this is a config file which isn't changed often.
                final long fileSystemTemporalGranularity = 2000; // TODO maybe make this configurable?! Warning: we are in the config here - accessing the config is thus not so easy (=> recursion).
                final long modificationAge = now - lastModified;
                final long waitPeriod = fileSystemTemporalGranularity - modificationAge;
                if (waitPeriod > 0) {
                        logger.info("getLastModifiedAndWaitIfNeeded: Waiting {} ms.", waitPeriod);
                        try { Thread.sleep(waitPeriod); } catch (InterruptedException e) { }
                }

                return lastModified;
        }

        @Override
        public long getVersion() {
                long result;

                synchronized (instanceMutex) {
                        readIfNeeded();
                        result = version;
                }

                if (parentConfig != null)
                        result += parentConfig.getVersion();

                return result;
        }

        @Override
        public String getProperty(final String key, final String defaultValue) {
                assertNotNull(key, "key");
                refreshFileHardRefAndCleanOldHardRefs();

                final String sysPropKey = SYSTEM_PROPERTY_PREFIX + key;
                final String sysPropVal = System.getProperty(sysPropKey);
                if (sysPropVal != null) {
                        logger.debug("getProperty: System property with key='{}' and value='{}' overrides config (config is not queried).", sysPropKey, sysPropVal);
                        return sysPropVal;
                }

                final String envVarKey = systemPropertyToEnvironmentVariable(sysPropKey);
                final String envVarVal = System.getenv(envVarKey);
                if (envVarVal != null) {
                        logger.debug("getProperty: Environment variable with key='{}' and value='{}' overrides config (config is not queried).", envVarKey, envVarVal);
                        return envVarVal;
                }

                logger.debug("getProperty: System property with key='{}' is not set (config is queried next).", sysPropKey);

                synchronized (instanceMutex) {
                        readIfNeeded();
                        return properties.getProperty(key, defaultValue);
                }
        }

        @Override
        public String getDirectProperty(final String key) {
                assertNotNull(key, "key");

                // TODO should we really take system properties and environment variables into account?!

                final String sysPropKey = SYSTEM_PROPERTY_PREFIX + key;
                final String sysPropVal = System.getProperty(sysPropKey);
                if (sysPropVal != null) {
                        logger.debug("getProperty: System property with key='{}' and value='{}' overrides config (config is not queried).", sysPropKey, sysPropVal);
                        return sysPropVal;
                }

                final String envVarKey = systemPropertyToEnvironmentVariable(sysPropKey);
                final String envVarVal = System.getenv(envVarKey);
                if (envVarVal != null) {
                        logger.debug("getProperty: Environment variable with key='{}' and value='{}' overrides config (config is not queried).", envVarKey, envVarVal);
                        return envVarVal;
                }

                refreshFileHardRefAndCleanOldHardRefs();
                synchronized (instanceMutex) {
                        readIfNeeded();
                        return (String) properties.get(key);
                }
        }

        @Override
        public void setDirectProperty(final String key, final String value) {
                assertNotNull(key, "key");

                // TODO really prevent modifying values? Or handle system props + env-vars differently?

                final String sysPropKey = SYSTEM_PROPERTY_PREFIX + key;
                if (System.getProperty(sysPropKey) != null) {
                        throw new IllegalStateException(String.format(
                                        "System property with key='%s' overrides config. The property '%s' can therefore not be modified.", sysPropKey, key));
                }

                final String envVarKey = systemPropertyToEnvironmentVariable(sysPropKey);
                if (System.getenv(envVarKey) != null) {
                        throw new IllegalStateException(String.format(
                                        "Environment variable with key='%s' overrides config. The property '%s' can therefore not be modified.", envVarKey, key));
                }

                refreshFileHardRefAndCleanOldHardRefs();
                synchronized (instanceMutex) {
                        readIfNeeded();
                        if (value == null)
                                properties.remove(key);
                        else
                                properties.put(key, value);

                        write();
                }
        }

        @Override
        public String getPropertyAsNonEmptyTrimmedString(final String key, final String defaultValue) {
                assertNotNull(key, "key");
                refreshFileHardRefAndCleanOldHardRefs();

                final String sysPropKey = SYSTEM_PROPERTY_PREFIX + key;
                final String sysPropVal = trim(System.getProperty(sysPropKey));
                if (! isEmpty(sysPropVal)) {
                        logger.debug("getPropertyAsNonEmptyTrimmedString: System property with key='{}' and value='{}' overrides config (config is not queried).", sysPropKey, sysPropVal);
                        return sysPropVal;
                }

                final String envVarKey = systemPropertyToEnvironmentVariable(sysPropKey);
                final String envVarVal = trim(System.getenv(envVarKey));
                if (! isEmpty(envVarVal)) {
                        logger.debug("getPropertyAsNonEmptyTrimmedString: Environment variable with key='{}' and value='{}' overrides config (config is not queried).", envVarKey, envVarVal);
                        return envVarVal;
                }

                logger.debug("getPropertyAsNonEmptyTrimmedString: System property with key='{}' is not set (config is queried next).", sysPropKey);

                synchronized (instanceMutex) {
                        readIfNeeded();
                        String sval = trim(properties.getProperty(key));
                        if (isEmpty(sval))
                                return defaultValue;

                        return sval;
                }
        }

        @Override
        public long getPropertyAsLong(final String key, final long defaultValue) {
                final String sval = getPropertyAsNonEmptyTrimmedString(key, null);
                if (sval == null)
                        return defaultValue;

                try {
                        final long lval = Long.parseLong(sval);
                        return lval;
                } catch (final NumberFormatException x) {
                        logger.warn("getPropertyAsLong: One of the properties files %s contains the key '%s' (or the system properties override it) with the illegal value '%s'. Falling back to default value '%s'!", propertiesFiles, key, sval, defaultValue);
                        return defaultValue;
                }
        }

        @Override
        public long getPropertyAsPositiveOrZeroLong(final String key, final long defaultValue) {
                final long value = getPropertyAsLong(key, defaultValue);
                if (value < 0) {
                        logger.warn("getPropertyAsPositiveOrZeroLong: One of the properties files %s contains the key '%s' (or the system properties override it) with the negative value '%s' (only values >= 0 are allowed). Falling back to default value '%s'!", propertiesFiles, key, value, defaultValue);
                        return defaultValue;
                }
                return value;
        }

        @Override
        public int getPropertyAsInt(final String key, final int defaultValue) {
                final String sval = getPropertyAsNonEmptyTrimmedString(key, null);
                if (sval == null)
                        return defaultValue;

                try {
                        final int ival = Integer.parseInt(sval);
                        return ival;
                } catch (final NumberFormatException x) {
                        logger.warn("getPropertyAsInt: One of the properties files %s contains the key '%s' (or the system properties override it) with the illegal value '%s'. Falling back to default value '%s'!", propertiesFiles, key, sval, defaultValue);
                        return defaultValue;
                }
        }

        @Override
        public int getPropertyAsPositiveOrZeroInt(final String key, final int defaultValue) {
                final int value = getPropertyAsInt(key, defaultValue);
                if (value < 0) {
                        logger.warn("getPropertyAsPositiveOrZeroInt: One of the properties files %s contains the key '%s' (or the system properties override it) with the negative value '%s' (only values >= 0 are allowed). Falling back to default value '%s'!", propertiesFiles, key, value, defaultValue);
                        return defaultValue;
                }
                return value;
        }

        @Override
        public <E extends Enum<E>> E getPropertyAsEnum(final String key, final E defaultValue) {
                assertNotNull(defaultValue, "defaultValue");
                @SuppressWarnings("unchecked")
                final Class<E> enumClass = (Class<E>) defaultValue.getClass();
                return getPropertyAsEnum(key, enumClass, defaultValue);
        }

        @Override
        public <E extends Enum<E>> E getPropertyAsEnum(final String key, final Class<E> enumClass, final E defaultValue) {
                assertNotNull(enumClass, "enumClass");
                final String sval = getPropertyAsNonEmptyTrimmedString(key, null);
                if (sval == null)
                        return defaultValue;

                try {
                        return Enum.valueOf(enumClass, sval);
                } catch (final IllegalArgumentException x) {
                        logger.warn("getPropertyAsEnum: One of the properties files %s contains the key '%s' with the illegal value '%s'. Falling back to default value '%s'!", propertiesFiles, key, sval, defaultValue);
                        return defaultValue;
                }
        }

        @Override
        public boolean getPropertyAsBoolean(final String key, final boolean defaultValue) {
                final String sval = getPropertyAsNonEmptyTrimmedString(key, null);
                if (sval == null)
                        return defaultValue;

                if (TRUE_STRING.equalsIgnoreCase(sval))
                        return true;
                else if (FALSE_STRING.equalsIgnoreCase(sval))
                        return false;
                else {
                        logger.warn("getPropertyAsBoolean: One of the properties files %s contains the key '%s' with the illegal value '%s'. Falling back to default value '%s'!", propertiesFiles, key, sval, defaultValue);
                        return defaultValue;
                }
        }

        private static final void refreshFileHardRefAndCleanOldHardRefs(final ConfigImpl config) {
                final File config_file = assertNotNull(config, "config").getFile();
                if (config_file != null)
                        refreshFileHardRefAndCleanOldHardRefs(config_file);
        }

        private final void refreshFileHardRefAndCleanOldHardRefs() {
                if (parentConfig != null)
                        parentConfig.refreshFileHardRefAndCleanOldHardRefs();

                refreshFileHardRefAndCleanOldHardRefs(this);
        }

        private static final void refreshFileHardRefAndCleanOldHardRefs(final File config_file) {
                assertNotNull(config_file, "config_file");
                synchronized (fileHardRefs) {
                        // make sure the config_file is at the end of fileHardRefs
                        fileHardRefs.remove(config_file);
                        fileHardRefs.add(config_file);

                        // remove the first entry until size does not exceed limit anymore.
                        while (fileHardRefs.size() > fileHardRefsMaxSize)
                                fileHardRefs.remove(fileHardRefs.iterator().next());
                }
        }

        @Override
        public Map<String, List<String>> getKey2GroupsMatching(final Pattern regex) {
                assertNotNull(regex, "regex");
                refreshFileHardRefAndCleanOldHardRefs();

                final Map<String, List<String>> key2Groups = new HashMap<>();
                populateKeysMatching(key2Groups, regex);
                return Collections.unmodifiableMap(key2Groups);
        }

        protected void populateKeysMatching(final Map<String, List<String>> key2Groups, final Pattern regex) {
                assertNotNull(key2Groups, "key2Groups");
                assertNotNull(regex, "regex");
                if (parentConfig != null)
                        parentConfig.populateKeysMatching(key2Groups, regex);

                synchronized (instanceMutex) {
                        readIfNeeded();

                        for (final Object k : properties.keySet()) {
                                final String key = (String) k;
                                if (key2Groups.containsKey(key))
                                        continue;

                                final Matcher matcher = regex.matcher(key);
                                if (matcher.matches()) {
                                        final int groupCount = matcher.groupCount();
                                        final List<String> groups = new ArrayList<>(groupCount);
                                        for (int i = 1; i <= groupCount; ++i) // ignore group 0, because this is the same as key.
                                                groups.add(matcher.group(i));

                                        key2Groups.put(key, Collections.unmodifiableList(groups));
                                }
                        }
                }
        }
}