/*
 * 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.configuration2;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.StringTokenizer;

import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
import org.apache.commons.configuration2.event.ConfigurationEvent;
import org.apache.commons.configuration2.event.EventListener;
import org.apache.commons.configuration2.event.EventListenerTestImpl;
import org.apache.commons.configuration2.ex.ConversionException;
import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
import org.apache.commons.configuration2.interpol.Lookup;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Tests some basic functions of the BaseConfiguration class. Missing keys will throw Exceptions
 */
public class TestBaseConfiguration {

    /** Constant for the number key. */
    static final String KEY_NUMBER = "number";

    protected static Class<?> missingElementException = NoSuchElementException.class;
    protected static Class<?> incompatibleElementException = ConversionException.class;
    protected BaseConfiguration config;

    @BeforeEach
    public void setUp() throws Exception {
        config = new BaseConfiguration();
        config.setThrowExceptionOnMissing(true);
        config.setListDelimiterHandler(new DefaultListDelimiterHandler(','));
    }

    @Test
    void testAddProperty() throws Exception {
        Collection<Object> props = new ArrayList<>();
        props.add("one");
        props.add("two,three,four");
        props.add(new String[] {"5.1", "5.2", "5.3,5.4", "5.5"});
        props.add("six");
        config.addProperty("complex.property", props);

        Object val = config.getProperty("complex.property");
        Collection<?> col = assertInstanceOf(Collection.class, val);
        assertEquals(10, col.size());

        props = new ArrayList<>();
        props.add("quick");
        props.add("brown");
        props.add("fox,jumps");
        final Object[] data = {"The", props, "over,the", "lazy", "dog."};
        config.setProperty("complex.property", data);
        val = config.getProperty("complex.property");
        col = assertInstanceOf(Collection.class, val);
        final Iterator<?> it = col.iterator();
        final StringTokenizer tok = new StringTokenizer("The quick brown fox jumps over the lazy dog.", " ");
        while (tok.hasMoreTokens()) {
            assertTrue(it.hasNext());
            assertEquals(tok.nextToken(), it.next());
        }
        assertFalse(it.hasNext());

        config.setProperty("complex.property", null);
        assertFalse(config.containsKey("complex.property"));
    }

    /**
     * Tests cloning a BaseConfiguration.
     */
    @Test
    void testClone() {
        for (int i = 0; i < 10; i++) {
            config.addProperty("key" + i, Integer.valueOf(i));
        }
        final BaseConfiguration config2 = (BaseConfiguration) config.clone();

        for (final Iterator<String> it = config.getKeys(); it.hasNext();) {
            final String key = it.next();
            assertTrue(config2.containsKey(key), "Key not found: " + key);
            assertEquals(config.getProperty(key), config2.getProperty(key), "Wrong value for key " + key);
        }
    }

    /**
     * Tests whether interpolation works as expected after cloning.
     */
    @Test
    void testCloneInterpolation() {
        final String keyAnswer = "answer";
        config.addProperty(keyAnswer, "The answer is ${" + KEY_NUMBER + "}.");
        config.addProperty(KEY_NUMBER, 42);
        final BaseConfiguration clone = (BaseConfiguration) config.clone();
        clone.setProperty(KEY_NUMBER, 43);
        assertEquals("The answer is 42.", config.getString(keyAnswer));
        assertEquals("The answer is 43.", clone.getString(keyAnswer));
    }

    /**
     * Tests the clone() method if a list property is involved.
     */
    @Test
    void testCloneListProperty() {
        final String key = "list";
        config.addProperty(key, "value1");
        config.addProperty(key, "value2");
        final BaseConfiguration config2 = (BaseConfiguration) config.clone();
        config2.addProperty(key, "value3");
        assertEquals(2, config.getList(key).size());
    }

    /**
     * Tests whether a cloned configuration is decoupled from its original.
     */
    @Test
    void testCloneModify() {
        final EventListener<ConfigurationEvent> l = new EventListenerTestImpl(config);
        config.addEventListener(ConfigurationEvent.ANY, l);
        config.addProperty("original", Boolean.TRUE);
        final BaseConfiguration config2 = (BaseConfiguration) config.clone();

        config2.addProperty("clone", Boolean.TRUE);
        assertFalse(config.containsKey("clone"));
        config2.setProperty("original", Boolean.FALSE);
        assertTrue(config.getBoolean("original"));

        assertTrue(config2.getEventListeners(ConfigurationEvent.ANY).isEmpty());
    }

    @Test
    void testCommaSeparatedString() {
        final String prop = "hey, that's a test";
        config.setProperty("prop.string", prop);
        final List<Object> list = config.getList("prop.string");
        assertEquals(Arrays.asList("hey", "that's a test"), list);
    }

    @Test
    void testCommaSeparatedStringEscaped() {
        final String prop2 = "hey\\, that's a test";
        config.setProperty("prop.string", prop2);
        assertEquals("hey, that's a test", config.getString("prop.string"));
    }

    @Test
    void testContainsValue() {
        assertFalse(config.containsValue(null));
    }

    @Test
    void testGetBigDecimal() {
        config.setProperty("numberBigD", "123.456");
        final BigDecimal number = new BigDecimal("123.456");
        final BigDecimal defaultValue = new BigDecimal("654.321");

        assertEquals(number, config.getBigDecimal("numberBigD"));
        assertEquals(number, config.getBigDecimal("numberBigD", defaultValue));
        assertEquals(defaultValue, config.getBigDecimal("numberNotInConfig", defaultValue));
    }

    @Test
    void testGetBigDecimalIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getBigDecimal("test.empty"));
    }

    @Test
    void testGetBigDecimalUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getBigDecimal("numberNotInConfig"));
    }

    @Test
    void testGetBigInteger() {
        config.setProperty("numberBigI", "1234567890");
        final BigInteger number = new BigInteger("1234567890");
        final BigInteger defaultValue = new BigInteger("654321");

        assertEquals(number, config.getBigInteger("numberBigI"));
        assertEquals(number, config.getBigInteger("numberBigI", defaultValue));
        assertEquals(defaultValue, config.getBigInteger("numberNotInConfig", defaultValue));
    }

    @Test
    void testGetBigIntegerIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getBigInteger("test.empty"));
    }

    @Test
    void testGetBigIntegerUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getBigInteger("numberNotInConfig"));
    }

    @Test
    void testGetBinaryValue() {
        config.setProperty("number", "0b11111111");
        assertEquals((byte) 0xFF, config.getByte("number"));

        config.setProperty("number", "0b1111111111111111");
        assertEquals((short) 0xFFFF, config.getShort("number"));

        config.setProperty("number", "0b11111111111111111111111111111111");
        assertEquals(0xFFFFFFFF, config.getInt("number"));

        config.setProperty("number", "0b1111111111111111111111111111111111111111111111111111111111111111");
        assertEquals(0xFFFFFFFFFFFFFFFFL, config.getLong("number"));

        assertEquals(0xFFFFFFFFFFFFFFFFL, config.getBigInteger("number").longValue());
    }

    @Test
    void testGetBoolean() {
        config.setProperty("boolA", Boolean.TRUE);
        final boolean boolT = true;
        final boolean boolF = false;
        assertEquals(boolT, config.getBoolean("boolA"));
        assertEquals(boolT, config.getBoolean("boolA", boolF));
        assertEquals(boolF, config.getBoolean("boolNotInConfig", boolF));
        assertEquals(Boolean.valueOf(boolT), config.getBoolean("boolA", Boolean.valueOf(boolF)));
    }

    @Test
    void testGetBooleanIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getBoolean("test.empty"));
    }

    @Test
    void testGetBooleanUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getBoolean("numberNotInConfig"));
    }

    @Test
    void testGetByte() {
        config.setProperty("number", "1");
        final byte oneB = 1;
        final byte twoB = 2;
        assertEquals(oneB, config.getByte("number"));
        assertEquals(oneB, config.getByte("number", twoB));
        assertEquals(twoB, config.getByte("numberNotInConfig", twoB));
        assertEquals(Byte.valueOf(oneB), config.getByte("number", Byte.valueOf("2")));
    }

    @Test
    void testGetByteIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getByte("test.empty"));
    }

    @Test
    void testGetByteUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getByte("numberNotInConfig"));
    }

    @Test
    void testGetDouble() {
        config.setProperty("numberD", "1.0");
        final double oneD = 1;
        final double twoD = 2;
        assertEquals(oneD, config.getDouble("numberD"), 0);
        assertEquals(oneD, config.getDouble("numberD", twoD), 0);
        assertEquals(twoD, config.getDouble("numberNotInConfig", twoD), 0);
        assertEquals(Double.valueOf(oneD), config.getDouble("numberD", Double.valueOf("2")));
    }

    @Test
    void testGetDoubleIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getDouble("test.empty"));
    }

    @Test
    void testGetDoubleUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getDouble("numberNotInConfig"));
    }

    @Test
    void testGetDuration() {
        final Duration d = Duration.ofSeconds(1);
        config.setProperty("durationD", d.toString());
        final Duration oneD = Duration.ofSeconds(1);
        final Duration twoD = Duration.ofSeconds(2);
        assertEquals(oneD, config.getDuration("durationD"));
        assertEquals(oneD, config.getDuration("durationD", twoD));
        assertEquals(twoD, config.getDuration("numberNotInConfig", twoD));
        assertEquals(oneD, config.getDuration("durationD", twoD));
    }

    @Test
    void testGetDurationIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getDuration("test.empty"));
    }

    @Test
    void testGetDurationUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getDuration("numberNotInConfig"));
    }

    @Test
    void testGetEnum() {
        config.setProperty("testEnum", EnumFixture.SMALLTALK.name());
        config.setProperty("testBadEnum", "This is not an enum value.");
        final EnumFixture enum1 = EnumFixture.SMALLTALK;
        final EnumFixture defaultValue = EnumFixture.JAVA;
        //
        assertEquals(enum1, config.getEnum("testEnum", EnumFixture.class));
        assertEquals(enum1, config.getEnum("testEnum", EnumFixture.class, defaultValue));
        assertEquals(defaultValue, config.getEnum("stringNotInConfig", EnumFixture.class, defaultValue));
        //
        assertThrows(ConversionException.class, () -> config.getEnum("testBadEnum", EnumFixture.class));
        //
        assertThrows(ConversionException.class, () -> config.getEnum("testBadEnum", EnumFixture.class, defaultValue));
    }

    @Test
    void testGetFloat() {
        config.setProperty("numberF", "1.0");
        final float oneF = 1;
        final float twoF = 2;
        assertEquals(oneF, config.getFloat("numberF"), 0);
        assertEquals(oneF, config.getFloat("numberF", twoF), 0);
        assertEquals(twoF, config.getFloat("numberNotInConfig", twoF), 0);
        assertEquals(Float.valueOf(oneF), config.getFloat("numberF", Float.valueOf("2")));
    }

    @Test
    void testGetFloatIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getFloat("test.empty"));
    }

    @Test
    void testGetFloatUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getFloat("numberNotInConfig"));
    }

    @Test
    void testGetHexadecimalValue() {
        config.setProperty("number", "0xFF");
        assertEquals((byte) 0xFF, config.getByte("number"));

        config.setProperty("number", "0xFFFF");
        assertEquals((short) 0xFFFF, config.getShort("number"));

        config.setProperty("number", "0xFFFFFFFF");
        assertEquals(0xFFFFFFFF, config.getInt("number"));

        config.setProperty("number", "0xFFFFFFFFFFFFFFFF");
        assertEquals(0xFFFFFFFFFFFFFFFFL, config.getLong("number"));

        assertEquals(0xFFFFFFFFFFFFFFFFL, config.getBigInteger("number").longValue());
    }

    @Test
    void testGetInterpolatedList() {
        config.addProperty("number", "1");
        config.addProperty("array", "${number}");
        config.addProperty("array", "${number}");

        final List<String> list = new ArrayList<>();
        list.add("1");
        list.add("1");

        assertEquals(list, config.getList("array"));
    }

    @Test
    void testGetInterpolatedPrimitives() {
        config.addProperty("number", "1");
        config.addProperty("value", "${number}");

        config.addProperty("boolean", "true");
        config.addProperty("booleanValue", "${boolean}");

        // primitive types
        assertTrue(config.getBoolean("booleanValue"));
        assertEquals(1, config.getByte("value"));
        assertEquals(1, config.getShort("value"));
        assertEquals(1, config.getInt("value"));
        assertEquals(1, config.getLong("value"));
        assertEquals(1, config.getFloat("value"), 0);
        assertEquals(1, config.getDouble("value"), 0);

        // primitive wrappers
        assertEquals(Boolean.TRUE, config.getBoolean("booleanValue", null));
        assertEquals(Byte.valueOf("1"), config.getByte("value", null));
        assertEquals(Short.valueOf("1"), config.getShort("value", null));
        assertEquals(Integer.valueOf("1"), config.getInteger("value", null));
        assertEquals(Long.valueOf("1"), config.getLong("value", null));
        assertEquals(Float.valueOf("1"), config.getFloat("value", null));
        assertEquals(Double.valueOf("1"), config.getDouble("value", null));

        assertEquals(new BigInteger("1"), config.getBigInteger("value", null));
        assertEquals(new BigDecimal("1"), config.getBigDecimal("value", null));
    }

    /**
     * Tests accessing and manipulating the interpolator object.
     */
    @Test
    void testGetInterpolator() {
        InterpolationTestHelper.testGetInterpolator(config);
    }

    @Test
    void testGetList() {
        config.addProperty("number", "1");
        config.addProperty("number", "2");
        final List<Object> list = config.getList("number");
        assertEquals(Arrays.asList("1", "2"), list);
    }

    @Test
    void testGetLong() {
        config.setProperty("numberL", "1");
        final long oneL = 1;
        final long twoL = 2;
        assertEquals(oneL, config.getLong("numberL"));
        assertEquals(oneL, config.getLong("numberL", twoL));
        assertEquals(twoL, config.getLong("numberNotInConfig", twoL));
        assertEquals(Long.valueOf(oneL), config.getLong("numberL", Long.valueOf("2")));
    }

    @Test
    void testGetLongIncompatibleTypes() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getLong("test.empty"));
    }

    @Test
    void testGetLongUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getLong("numberNotInConfig"));
    }

    @Test
    void testGetProperty() {
        /* should be empty and return null */
        assertNull(config.getProperty("foo"));

        /* add a real value, and get it two different ways */
        config.setProperty("number", "1");
        assertEquals("1", config.getProperty("number"));
        assertEquals("1", config.getString("number"));
    }

    @Test
    void testGetShort() {
        config.setProperty("numberS", "1");
        final short oneS = 1;
        final short twoS = 2;
        assertEquals(oneS, config.getShort("numberS"));
        assertEquals(oneS, config.getShort("numberS", twoS));
        assertEquals(twoS, config.getShort("numberNotInConfig", twoS));
        assertEquals(Short.valueOf(oneS), config.getShort("numberS", Short.valueOf("2")));
    }

    @Test
    void testGetShortIncompatibleType() {
        config.setProperty("test.empty", "");
        assertThrows(ConversionException.class, () -> config.getShort("test.empty"));
    }

    @Test
    void testGetShortUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getShort("numberNotInConfig"));
    }

    @Test
    void testGetString() {
        config.setProperty("testString", "The quick brown fox");
        final String string = "The quick brown fox";
        final String defaultValue = "jumps over the lazy dog";

        assertEquals(string, config.getString("testString"));
        assertEquals(string, config.getString("testString", defaultValue));
        assertEquals(defaultValue, config.getString("stringNotInConfig", defaultValue));
    }

    /**
     * Tests that the first scalar of a list is returned.
     */
    @Test
    void testGetStringForListValue() {
        config.addProperty("number", "1");
        config.addProperty("number", "2");
        assertEquals("1", config.getString("number"));
    }

    @Test
    void testGetStringUnknown() {
        assertThrows(NoSuchElementException.class, () -> config.getString("stringNotInConfig"));
    }

    /**
     * Tests whether a {@code ConfigurationInterpolator} can be created and installed.
     */
    @Test
    void testInstallInterpolator() {
        final Lookup prefixLookup = mock(Lookup.class);
        final Lookup defLookup = mock(Lookup.class);
        final Map<String, Lookup> prefixLookups = new HashMap<>();
        prefixLookups.put("test", prefixLookup);
        final List<Lookup> defLookups = new ArrayList<>();
        defLookups.add(defLookup);
        config.installInterpolator(prefixLookups, defLookups);
        final ConfigurationInterpolator interpolator = config.getInterpolator();
        assertEquals(prefixLookups, interpolator.getLookups());
        final List<Lookup> defLookups2 = interpolator.getDefaultLookups();
        assertEquals(2, defLookups2.size());
        assertSame(defLookup, defLookups2.get(0));
        final String var = "testVariable";
        final Object value = 42;
        config.addProperty(var, value);
        assertEquals(value, defLookups2.get(1).lookup(var));
    }

    /**
     * Tests obtaining a configuration with all variables replaced by their actual values.
     */
    @Test
    void testInterpolatedConfiguration() {
        InterpolationTestHelper.testInterpolatedConfiguration(config);
    }

    @Test
    void testInterpolation() {
        InterpolationTestHelper.testInterpolation(config);
    }

    /**
     * Tests interpolation of constant values.
     */
    @Test
    void testInterpolationConstants() {
        InterpolationTestHelper.testInterpolationConstants(config);
    }

    /**
     * Tests interpolation of environment properties.
     */
    @Test
    void testInterpolationEnvironment() {
        InterpolationTestHelper.testInterpolationEnvironment(config);
    }

    /**
     * Tests whether a variable can be escaped, so that it won't be interpolated.
     */
    @Test
    void testInterpolationEscaped() {
        InterpolationTestHelper.testInterpolationEscaped(config);
    }

    /**
     * Tests interpolation with localhost values.
     */
    @Test
    void testInterpolationLocalhost() {
        InterpolationTestHelper.testInterpolationLocalhost(config);
    }

    @Test
    void testInterpolationLoop() {
        InterpolationTestHelper.testInterpolationLoop(config);
    }

    /**
     * Tests interpolation when a subset configuration is involved.
     */
    @Test
    void testInterpolationSubset() {
        InterpolationTestHelper.testInterpolationSubset(config);
    }

    /**
     * Tests interpolation of system properties.
     */
    @Test
    void testInterpolationSystemProperties() {
        InterpolationTestHelper.testInterpolationSystemProperties(config);
    }

    /**
     * Tests interpolation when the referred property is not found.
     */
    @Test
    void testInterpolationUnknownProperty() {
        InterpolationTestHelper.testInterpolationUnknownProperty(config);
    }

    @Test
    void testMultipleInterpolation() {
        InterpolationTestHelper.testMultipleInterpolation(config);
    }

    /**
     * Tests whether property access is possible without a {@code ConfigurationInterpolator}.
     */
    @Test
    void testNoInterpolator() {
        config.setProperty("test", "${value}");
        config.setInterpolator(null);
        assertEquals("${value}", config.getString("test"));
    }

    /**
     * Tests if conversion between number types is possible.
     */
    @Test
    void testNumberConversions() {
        config.setProperty(KEY_NUMBER, Integer.valueOf(42));
        assertEquals(42, config.getInt(KEY_NUMBER));
        assertEquals(42L, config.getLong(KEY_NUMBER));
        assertEquals((byte) 42, config.getByte(KEY_NUMBER));
        assertEquals(42.0f, config.getFloat(KEY_NUMBER), 0.01f);
        assertEquals(42.0, config.getDouble(KEY_NUMBER), 0.001);

        assertEquals(Long.valueOf(42L), config.getLong(KEY_NUMBER, null));
        assertEquals(new BigInteger("42"), config.getBigInteger(KEY_NUMBER));
        assertEquals(new BigDecimal("42.0"), config.getBigDecimal(KEY_NUMBER));
    }

    @Test
    void testPropertyAccess() {
        config.clearProperty("prop.properties");
        config.setProperty("prop.properties", "");
        assertEquals(new Properties(), config.getProperties("prop.properties"));
        config.clearProperty("prop.properties");
        config.setProperty("prop.properties", "foo=bar, baz=moo, seal=clubber");

        final Properties p = new Properties();
        p.setProperty("foo", "bar");
        p.setProperty("baz", "moo");
        p.setProperty("seal", "clubber");
        assertEquals(p, config.getProperties("prop.properties"));
    }

    /**
     * Tests whether a {@code ConfigurationInterpolator} can be set.
     */
    @Test
    void testSetInterpolator() {
        final ConfigurationInterpolator interpolator = mock(ConfigurationInterpolator.class);
        config.setInterpolator(interpolator);
        assertSame(interpolator, config.getInterpolator());
    }

    /**
     * Tests the specific size() implementation.
     */
    @Test
    void testSize() {
        final int count = 16;
        for (int i = 0; i < count; i++) {
            config.addProperty("key" + i, "value" + i);
        }
        assertEquals(count, config.size());
    }

    @Test
    void testSubset() {
        /*
         * test subset : assure we don't reprocess the data elements when generating the subset
         */

        final String prop = "hey, that's a test";
        final String prop2 = "hey\\, that's a test";
        config.setProperty("prop.string", prop2);
        config.setProperty("property.string", "hello");

        Configuration subEprop = config.subset("prop");

        assertEquals(prop, subEprop.getString("string"));
        assertEquals(1, subEprop.getList("string").size());

        Iterator<String> it = subEprop.getKeys();
        it.next();
        assertFalse(it.hasNext());

        subEprop = config.subset("prop.");
        it = subEprop.getKeys();
        assertFalse(it.hasNext());
    }

    @Test
    void testThrowExceptionOnMissing() {
        assertTrue(config.isThrowExceptionOnMissing());
    }
}
