*
 * @param <K> the key type
 * @param <V> the value type
 */
public class ParamMap<K, V> implements Map<K, V> {

    private final Map<K, V> parent;

    /**
     * Creates a new parameter map.
     *
     * @param parent the parent map
     */
    public ParamMap(final Map<K, V> parent) {
        this.parent = parent;
    }

    /**
     * Gets the parent map.
     *

        String template = "${greeting} ${name}, you are ${age} years old";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("greeting", "Hello");
        paramMap.put("name", "Alice");
        paramMap.put("age", 25);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("Hello Alice, you are 25 years old", result);
    }

    public void test_store_withValidData() {
        // Prepare test data
        DataStoreParams paramMap = new DataStoreParams();
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("url", "http://example.com/test");
        dataMap.put("title", "Test Document");

        // Execute
        indexUpdateCallback.store(paramMap, dataMap);

        // Verify

        paramMap = ParameterUtil.parse(value);
        assertEquals(1, paramMap.size());
        assertEquals("", paramMap.get("a"));

        value = "a";
        paramMap = ParameterUtil.parse(value);
        assertEquals(1, paramMap.size());
        assertEquals("", paramMap.get("a"));

        value = "a=b=c";
        paramMap = ParameterUtil.parse(value);
        assertEquals(1, paramMap.size());

                            }
                            paramMap.put(key, data);
                        } else {
                            paramMap.put(key, StringUtil.EMPTY);
                        }
                    } else {
                        paramMap.put(line.trim(), StringUtil.EMPTY);
                    }
                }
            }
        }
        return paramMap;
    }

    /**

        scriptEngineFactory.add("modifyEngine", new ScriptEngine() {
            @Override
            public Object evaluate(String template, Map<String, Object> paramMap) {
                // Try to add new param
                paramMap.put("newKey", "newValue");
                return paramMap.size();
            }
        });

        // Execute first time
        Object result1 = scriptExecutor.execute("modifyEngine", "script1");

        }

        final Map<String, String[]> paramMap = new HashMap<>(paramListMap.size());
        for (final Map.Entry<String, List<String>> entry : paramListMap.entrySet()) {
            final List<String> list = entry.getValue();
            paramMap.put(entry.getKey(), list.toArray(new String[list.size()]));
        }
        return paramMap;
    }

    /**

        storeData(config, callback, paramMap.newInstance(), configScriptMap, defaultDataMap);

    }

    /**
     * Get the script type.
     * @param paramMap The parameters.
     * @return The script type.
     */
    protected String getScriptType(final DataStoreParams paramMap) {
        final String value = paramMap.getAsString(SCRIPT_TYPE);
        if (StringUtil.isBlank(value)) {

     */
    protected boolean isUrlCrawlable(final DataStoreParams paramMap, final String url) {
        if (paramMap.containsKey(URL_EXCLUDE_PATTERN)) {
            if (paramMap.get(URL_EXCLUDE_PATTERN) instanceof final String value) {
                final Pattern pattern = Pattern.compile(value);
                paramMap.put(URL_EXCLUDE_PATTERN, pattern);
                if (logger.isDebugEnabled()) {

    // ExecutorService executorService = Executors.newFixedThreadPool(1);
    //
    // // HttpClient Parameters
    // Map<String, Object> paramMap = new HashMap<String, Object>();
    // httpClient.setInitParameterMap(paramMap);
    //
    // DigestScheme digestScheme = new DigestScheme();
    // List<Authentication> basicAuthList = new ArrayList<Authentication>();