/*
    * 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.assertNotSame;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  import static org.junit.jupiter.api.Assertions.fail;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  import java.util.concurrent.CountDownLatch;
  
  import org.apache.commons.configuration2.SynchronizerTestImpl.Methods;
  import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
  import org.apache.commons.configuration2.builder.fluent.Parameters;
  import org.apache.commons.configuration2.ex.ConfigurationException;
  import org.apache.commons.configuration2.io.FileHandler;
  import org.apache.commons.configuration2.tree.ImmutableNode;
  import org.apache.commons.configuration2.tree.InMemoryNodeModel;
  import org.apache.commons.configuration2.tree.NodeStructureHelper;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * A test class for {@code BaseHierarchicalConfiguration} which checks whether the Synchronizer is called correctly by
   * the methods specific for hierarchical configurations.
   */
  public class TestBaseHierarchicalConfigurationSynchronization {
  
      /**
       * A thread class for testing concurrent access to SubNode configurations.
       */
      private static final class SubNodeAccessThread extends Thread {
  
          /** The test configuration. */
          private final HierarchicalConfiguration<ImmutableNode> config;
  
          /** The latch for synchronizing thread start. */
          private final CountDownLatch latch;
  
          /** The key for the sub configuration. */
          private final String keySub;
  
          /** The key for the property. */
          private final String keyProp;
  
          /** The value read by this thread. */
          private String value;
  
          /**
           * Creates a new instance of {@code SubNodeAccessThread}
           *
           * @param c the test configuration
           * @param startLatch the start latch
           * @param keySubConfig the key for the sub configuration
           * @param keyProperty the key for the property
           */
          public SubNodeAccessThread(final HierarchicalConfiguration<ImmutableNode> c, final CountDownLatch startLatch, final String keySubConfig,
              final String keyProperty) {
              config = c;
              latch = startLatch;
              keySub = keySubConfig;
              keyProp = keyProperty;
          }
  
          @Override
          public void run() {
              try {
                  latch.await();
                  final HierarchicalConfiguration<ImmutableNode> subConfig = config.configurationAt(keySub, true);
                  value = subConfig.getString(keyProp);
              } catch (final InterruptedException iex) {
                  // ignore
              }
          }
  
          /**
           * Verifies that the correct value was read.
          */
         public void verify() {
             try {
                 join();
             } catch (final InterruptedException e) {
                 fail("Waiting was interrupted: " + e);
             }
             assertEquals("I'm complex!", value);
         }
     }
 
     /**
      * Tests whether the specified configuration is detached.
      *
      * @param c the configuration to test
      * @return a flag whether the root node of this configuration is detached
      */
     private static boolean isDetached(final HierarchicalConfiguration<ImmutableNode> c) {
         final SubnodeConfiguration subnodeConfig = assertInstanceOf(SubnodeConfiguration.class, c);
         final InMemoryNodeModel nodeModel = subnodeConfig.getRootNodeModel();
         return nodeModel.isTrackedNodeDetached(subnodeConfig.getRootSelector());
     }
 
     /** The test synchronizer. */
     private SynchronizerTestImpl sync;
 
     /** The test file to be read. */
     private File testFile;
 
     /** The test configuration. */
     private BaseHierarchicalConfiguration config;
 
     @BeforeEach
     public void setUp() throws Exception {
         final XMLConfiguration c = new XMLConfiguration();
         testFile = ConfigurationAssert.getTestFile("test.xml");
         new FileHandler(c).load(testFile);
         sync = new SynchronizerTestImpl();
         c.setSynchronizer(sync);
         config = c;
     }
 
     /**
      * Tests whether addNodes() is correctly synchronized.
      */
     @Test
     void testAddNodesSynchronized() {
         final ImmutableNode node = NodeStructureHelper.createNode("newNode", "true");
         config.addNodes("test.addNodes", Collections.singleton(node));
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
     }
 
     /**
      * Tests whether childConfigurationsAt() is correctly synchronized.
      */
     @Test
     void testChildConfigurationsAtSynchronized() {
         final List<HierarchicalConfiguration<ImmutableNode>> subs = config.childConfigurationsAt("clear");
         assertFalse(subs.isEmpty());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
     }
 
     /**
      * Tests whether clearTree() is correctly synchronized.
      */
     @Test
     void testClearTreeSynchronized() {
         config.clearTree("clear");
         sync.verify(Methods.BEGIN_WRITE, Methods.END_WRITE);
     }
 
     /**
      * Tests whether a clone() operation also copies the data used to manage SubnodeConfiguration objects.
      */
     @Test
     void testCloneCopySubnodeData() {
         final BaseHierarchicalConfiguration conf2 = new BaseHierarchicalConfiguration(config);
 
         final HierarchicalConfiguration<ImmutableNode> sub = conf2.configurationAt("element2.subelement", true);
         @SuppressWarnings("unchecked") // clone retains the type
         final HierarchicalConfiguration<ImmutableNode> copy = (HierarchicalConfiguration<ImmutableNode>) conf2.clone();
         final HierarchicalConfiguration<ImmutableNode> sub2 = copy.configurationAt("element2.subelement", true);
         // This must not cause a validate operation on sub1, but on sub2
         copy.clearTree("element2");
         assertTrue(isDetached(sub2));
         assertFalse(isDetached(sub));
     }
 
     /**
      * Tests whether clone() is correctly synchronized.
      */
     @Test
     void testCloneSynchronized() {
         final BaseHierarchicalConfiguration clone = (BaseHierarchicalConfiguration) config.clone();
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         assertNotSame(config.getSynchronizer(), clone.getSynchronizer());
     }
 
     /**
      * Tests whether synchronization is performed when constructing a SubnodeConfiguration.
      */
     @Test
     void testConfigurationAtSynchronized() {
         final HierarchicalConfiguration<ImmutableNode> sub = config.configurationAt("element2");
         assertEquals("I'm complex!", sub.getString("subelement.subsubelement"));
         sync.verify(Methods.BEGIN_READ, Methods.END_READ, Methods.BEGIN_READ, Methods.END_READ);
     }
 
     /**
      * Tests whether synchronization is performed when constructing multiple SubnodeConfiguration objects.
      */
     @Test
     void testConfigurationsAtSynchronized() {
         final List<HierarchicalConfiguration<ImmutableNode>> subs = config.configurationsAt("list.item");
         assertFalse(subs.isEmpty());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
     }
 
     /**
      * Tests whether synchronization is performed when copying a configuration.
      */
     @Test
     void testCopyConstructorSynchronized() {
         final BaseHierarchicalConfiguration copy = new BaseHierarchicalConfiguration(config);
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         assertNotSame(sync, copy.getSynchronizer());
     }
 
     /**
      * Tests whether getMaxIndex() is correctly synchronized.
      */
     @Test
     void testGetMaxIndexSynchronized() {
         assertTrue(config.getMaxIndex("list.item") > 0);
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
     }
 
     /**
      * Tests whether getRootElementName() is correctly synchronized.
      */
     @Test
     void testGetRootElementNameSynchronized() {
         assertEquals("testconfig", config.getRootElementName());
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
     }
 
     /**
      * Tests that access to an initialized configuration's sub configurations is possible without a special synchronizer.
      */
     @Test
     void testReadOnlyAccessToSubConfigurations() throws ConfigurationException {
         final FileBasedConfigurationBuilder<XMLConfiguration> builder = new FileBasedConfigurationBuilder<>(XMLConfiguration.class);
         builder.configure(new Parameters().fileBased().setFile(testFile));
         config = builder.getConfiguration();
 
         final CountDownLatch startLatch = new CountDownLatch(1);
         final Collection<SubNodeAccessThread> threads = new ArrayList<>();
         for (int i = 0; i < 4; i++) {
             final SubNodeAccessThread t = new SubNodeAccessThread(config, startLatch, "element2", "subelement.subsubelement");
             t.start();
             threads.add(t);
         }
         for (int i = 0; i < 4; i++) {
             final SubNodeAccessThread t = new SubNodeAccessThread(config, startLatch, "element2.subelement", "subsubelement");
             t.start();
             threads.add(t);
         }
 
         startLatch.countDown();
         for (final SubNodeAccessThread t : threads) {
             t.verify();
         }
     }
 
     /**
      * Tests whether updates on nodes are communicated to all SubnodeConfigurations of a configuration.
      */
     @Test
     void testSubnodeUpdate() {
         config.addProperty("element2.test", Boolean.TRUE);
         final HierarchicalConfiguration<ImmutableNode> sub = config.configurationAt("element2", true);
         final HierarchicalConfiguration<ImmutableNode> subsub = sub.configurationAt("subelement", true);
         config.clearTree("element2.subelement");
         assertFalse(isDetached(sub));
         assertTrue(isDetached(subsub));
     }
 
     /**
      * Tests whether updates caused by a SubnodeConfiguration are communicated to all other SubnodeConfigurations.
      */
     @Test
     void testSubnodeUpdateBySubnode() {
         final HierarchicalConfiguration<ImmutableNode> sub = config.configurationAt("element2", true);
         final HierarchicalConfiguration<ImmutableNode> subsub = sub.configurationAt("subelement", true);
         final HierarchicalConfiguration<ImmutableNode> sub2 = config.configurationAt("element2.subelement", true);
         sub.clearTree("subelement");
         assertTrue(isDetached(sub2));
         assertTrue(isDetached(subsub));
     }
 
     /**
      * Tests whether subset() is correctly synchronized.
      */
     @Test
     void testSubsetSynchronized() {
         final Configuration subset = config.subset("test");
         sync.verify(Methods.BEGIN_READ, Methods.END_READ);
         assertSame(sync, subset.getSynchronizer());
     }
 }