/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.commons.text;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.commons.text.lookup.DefaultStringLookup;
  import org.apache.commons.text.lookup.StringLookup;
  import org.apache.commons.text.lookup.StringLookupFactory;
  import org.junit.jupiter.api.Disabled;
  import org.junit.jupiter.api.Test;
  import org.junitpioneer.jupiter.SetEnvironmentVariable;
  
  class StringSubstitutorWithInterpolatorStringLookupTest {
  
      private static StringLookup createInterpolatorWithLookups(final DefaultStringLookup... lookups) {
          final Map<String, StringLookup> lookupMap = new HashMap<>();
          for (final DefaultStringLookup lookup : lookups) {
              lookupMap.put(lookup.getKey().toLowerCase(), lookup.getStringLookup());
          }
  
          return StringLookupFactory.INSTANCE.interpolatorStringLookup(lookupMap, null, false);
      }
  
      @Test
      void testCustomFunctionWithDefaults() {
          testCustomFunctionWithDefaults(true);
      }
  
      private void testCustomFunctionWithDefaults(final boolean addDefaultLookups) {
          final String key = "key";
          final String value = "value";
          final Map<String, String> map = new HashMap<>();
          map.put(key, value);
          final StringLookup mapStringLookup = StringLookupFactory.INSTANCE.functionStringLookup(map::get);
          final Map<String, StringLookup> stringLookupMap = new HashMap<>();
          stringLookupMap.put("customLookup", mapStringLookup);
          final StringSubstitutor strSubst = new StringSubstitutor(
              StringLookupFactory.INSTANCE.interpolatorStringLookup(stringLookupMap, null, addDefaultLookups));
          if (addDefaultLookups) {
              final String spKey = "user.name";
              assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}"));
          }
          assertEquals("value", strSubst.replace("${customLookup:key}"));
      }
  
      @Test
      void testCustomFunctionWithoutDefaults() {
          testCustomFunctionWithDefaults(false);
      }
  
      @Test
      void testCustomMapWithDefaults() {
          testCustomMapWithDefaults(true);
      }
  
      private void testCustomMapWithDefaults(final boolean addDefaultLookups) {
          final String key = "key";
          final String value = "value";
          final Map<String, String> map = new HashMap<>();
          map.put(key, value);
          final StringLookup mapStringLookup = StringLookupFactory.INSTANCE.mapStringLookup(map);
          final Map<String, StringLookup> stringLookupMap = new HashMap<>();
          stringLookupMap.put("customLookup", mapStringLookup);
          final StringSubstitutor strSubst = new StringSubstitutor(
              StringLookupFactory.INSTANCE.interpolatorStringLookup(stringLookupMap, null, addDefaultLookups));
          if (addDefaultLookups) {
              final String spKey = "user.name";
              assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}"));
          }
          assertEquals("value", strSubst.replace("${customLookup:key}"));
          assertEquals("${UnknownLookup:key}", strSubst.replace("${UnknownLookup:key}"));
      }
  
      @Test
      void testCustomMapWithoutDefaults() {
          testCustomMapWithDefaults(false);
     }
     @Test
     void testDefaultInterpolator() {
         // Used to cut and paste into the docs.
         // @formatter:off
         final StringSubstitutor interpolator = StringSubstitutor.createInterpolator();
         final String text = interpolator.replace(
                 "Base64 Decoder:        ${base64Decoder:SGVsbG9Xb3JsZCE=}\n"
               + "Base64 Encoder:        ${base64Encoder:HelloWorld!}\n"
               + "Java Constant:         ${const:java.awt.event.KeyEvent.VK_ESCAPE}\n"
               + "Date:                  ${date:yyyy-MM-dd}\n"
               + "Environment Variable:  ${env:USERNAME}\n"
               + "File Content:          ${file:UTF-8:src/test/resources/org/apache/commons/text/document.properties}\n"
               + "Java:                  ${java:version}\n"
               + "Localhost:             ${localhost:canonical-name}\n"
               + "Properties File:       ${properties:src/test/resources/org/apache/commons/text/document.properties::mykey}\n"
               + "Resource Bundle:       ${resourceBundle:org.apache.commons.text.example.testResourceBundleLookup:mykey}\n"
               + "System Property:       ${sys:user.dir}\n"
               + "URL Decoder:           ${urlDecoder:Hello%20World%21}\n"
               + "URL Encoder:           ${urlEncoder:Hello World!}\n"
               + "XML XPath:             ${xml:src/test/resources/org/apache/commons/text/document.xml:/root/path/to/node}\n"
         );
         // @formatter:on
         assertNotNull(text);
         // TEXT-171:
         assertFalse(text.contains("${base64Decoder:SGVsbG9Xb3JsZCE=}"));
         assertFalse(text.contains("${base64Encoder:HelloWorld!}"));
         assertFalse(text.contains("${urlDecoder:Hello%20World%21}"));
         assertFalse(text.contains("${urlEncoder:Hello World!}"));
         assertFalse(text.contains("${resourceBundle:org.apache.commons.text.example.testResourceBundleLookup:mykey}"));
     }
 
     @Test
     void testDefaultValueForMissingKeyInResourceBundle() {
         final StringLookup interpolatorStringLookup = StringLookupFactory.INSTANCE.interpolatorStringLookup(
             StringLookupFactory.INSTANCE.resourceBundleStringLookup("org.apache.commons.text.example.testResourceBundleLookup"));
         assertEquals("${missingKey:-defaultValue}", interpolatorStringLookup.apply("keyWithMissingKey"));
         assertEquals("${missingKey:-defaultValue}", interpolatorStringLookup.lookup("keyWithMissingKey"));
         final StringSubstitutor stringSubstitutor = new StringSubstitutor(interpolatorStringLookup);
         // The following would throw a MissingResourceException before TEXT-165.
         assertEquals("defaultValue", stringSubstitutor.replace("${keyWithMissingKey}"));
     }
 
     @Test
     void testDnsLookup() throws UnknownHostException {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         final String hostName = InetAddress.getLocalHost().getHostName();
         assertEquals(InetAddress.getByName(hostName).getHostAddress(),
             strSubst.replace("${dns:" + hostName + "}"));
     }
 
     @Test
     void testDnsLookup_disabledByDefault() throws UnknownHostException {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         final String hostName = InetAddress.getLocalHost().getHostName();
         final String input = "${dns:" + hostName + "}";
         assertEquals(input, strSubst.replace(input));
     }
 
     @Test
     void testDnsLookupAddress() throws UnknownHostException {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         assertEquals(InetAddress.getByName("apache.org").getHostAddress(),
             strSubst.replace("${dns:address|apache.org}"));
     }
 
     @Test
     void testDnsLookupCanonicalName() throws UnknownHostException {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         final String address = InetAddress.getLocalHost().getHostAddress();
         final InetAddress inetAddress = InetAddress.getByName(address);
         assertEquals(inetAddress.getCanonicalHostName(),
             strSubst.replace("${dns:canonical-name|" + address + "}"));
     }
 
     @Test
     void testDnsLookupName() throws UnknownHostException {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         final String address = InetAddress.getLocalHost().getHostAddress();
         final InetAddress inetAddress = InetAddress.getByName(address);
         assertEquals(inetAddress.getHostName(), strSubst.replace("${dns:name|" + address + "}"));
     }
 
     @Test
     void testDnsLookupNameUntrimmed() throws UnknownHostException {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         final String address = InetAddress.getLocalHost().getHostAddress();
         final InetAddress inetAddress = InetAddress.getByName(address);
         assertEquals(inetAddress.getHostName(), strSubst.replace("${dns:name| " + address + " }"));
     }
 
     @Test
     void testDnsLookupUnknown() {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.DNS));
         final String unknown = "${dns: u n k n o w n}";
         assertEquals(unknown, strSubst.replace(unknown));
     }
 
     @Test
     void testJavaScript() {
         final StringSubstitutor strSubst =
                 new StringSubstitutor(createInterpolatorWithLookups(DefaultStringLookup.SCRIPT));
 
         assertEquals("Hello World!", strSubst.replace("${script:javascript:\"Hello World!\"}"));
         assertEquals("7", strSubst.replace("${script:javascript:3 + 4}"));
     }
 
     @Test
     void testJavaScript_disabledByDefault() {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
 
         assertEquals("${script:javascript:3 + 4}", strSubst.replace("${script:javascript:3 + 4}"));
     }
 
     @Test
     void testLocalHostLookup_Address() throws UnknownHostException {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         assertEquals(InetAddress.getLocalHost().getHostAddress(), strSubst.replace("${localhost:address}"));
     }
 
     @Test
     void testLocalHostLookup_CanonicalName() throws UnknownHostException {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         assertEquals(InetAddress.getLocalHost().getCanonicalHostName(),
             strSubst.replace("${localhost:canonical-name}"));
     }
 
     @Test
     void testLocalHostLookup_Name() throws UnknownHostException {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         assertEquals(InetAddress.getLocalHost().getHostName(), strSubst.replace("${localhost:name}"));
     }
 
     @Test
     void testMapAndSystemProperty() {
         final String key = "key";
         final String value = "value";
         final Map<String, String> map = new HashMap<>();
         map.put(key, value);
         final StringSubstitutor strSubst = new StringSubstitutor(
             StringLookupFactory.INSTANCE.interpolatorStringLookup(map));
         final String spKey = "user.name";
         assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}"));
         assertEquals(value, strSubst.replace("${" + key + "}"));
     }
 
     @Test
     void testSystemProperty() {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         final String spKey = "user.name";
         assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}"));
     }
 
     @Test
     void testSystemPropertyDefaultDefault() {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         strSubst.setEnableSubstitutionInVariables(true);
         final String spKey = "user.name";
         // check that "sys" works
         final String spLookupStr = "${sys:" + spKey + "}";
         final String actual = System.getProperty(spKey);
         assertEquals(actual, strSubst.replace(spLookupStr));
         // test "sys" with default value
         assertEquals("foo", strSubst.replace("${sys:unknownkey1:-foo}"));
         assertEquals("foo", strSubst.replace("${sys:unknownkey1:-${sys:unknownkey2:-foo}}"));
         assertEquals("foo", strSubst.replace("${sys:unknownkey1:-${sys:unknownkey2:-${sys:unknownkey3:-foo}}}"));
         assertEquals("foo", strSubst.replace("${sys:unknownkey1:-${sys:unknownkey2:-${sys:unknownkey3:-${sys:unknownkey4:-foo}}}}"));
         assertEquals("foo", strSubst.replace("${env:UNKNOWN_KEY:-${sys:unknownkey1:-${sys:unknownkey2:-${sys:unknownkey3:-${sys:unknownkey4:-foo}}}}}"));
         assertEquals(actual, strSubst.replace("${sys:unknownkey1:-" + spLookupStr + "}"));
         assertEquals(actual, strSubst.replace("${sys:unknownkey1:-${sys:unknownkey2:-" + spLookupStr + "}}"));
     }
 
     /**
      * In our POM. the module {@code java.base} must open "opens java.lang" for the {@link SetEnvironmentVariable} annotation to work. Otherwise, the test will
      * fail with an IllegalAccessException.
      */
     @Disabled("Needs java.base to open 'opens java.lang' for SetEnvironmentVariable.")
     @Test
     @SetEnvironmentVariable(key = "testSystemPropertyDefaultDefault", value = "123456789")
     void testSystemPropertyDefaultDefaultEnv() {
         final StringSubstitutor strSubst = StringSubstitutor.createInterpolator();
         assertEquals("123456789", strSubst
                 .replace("${env:testSystemPropertyDefaultDefault:-${sys:unknownkey1:-${sys:unknownkey2:-${sys:unknownkey3:-${sys:unknownkey4:-foo}}}}}"));
     }
 
     @Test
     void testSystemPropertyDefaultStringLookup() {
         final StringSubstitutor strSubst = new StringSubstitutor(
             StringLookupFactory.INSTANCE.interpolatorStringLookup(StringLookupFactory.INSTANCE.systemPropertyStringLookup()));
         final String spKey = "user.name";
         assertEquals(System.getProperty(spKey), strSubst.replace("${" + spKey + "}"));
         assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}"));
     }
 }