/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions copyright [year] [name of copyright owner]".
 *
 * Copyright 2026 3A Systems, LLC.
 */
package org.opends.server.replication.plugin;

import static org.assertj.core.api.Assertions.*;
import static org.opends.server.TestCaseUtils.*;

import java.util.ArrayList;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

import org.forgerock.opendj.ldap.DN;
import org.opends.server.TestCaseUtils;
import org.opends.server.backends.MemoryBackend;
import org.opends.server.replication.ReplicationTestCase;
import org.opends.server.replication.server.ReplServerFakeConfiguration;
import org.opends.server.replication.server.ReplicationServer;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

/**
 * Tests that {@link MultimasterReplication#forEachDomain} gives every domain its turn
 * whatever one of them threw, and reports the failures the way it says it does: the first
 * is thrown once the loop is over, the others are suppressed under it where it records
 * suppression, and an instance thrown by two domains - the error a JVM out of memory hands
 * out as often as it is asked for one - is thrown once and suppresses nothing (issue #986).
 * <p>
 * Two domains, on backends of their own, neither of them started: the action is what
 * throws, and it never touches the domain it is given.
 */
@SuppressWarnings("javadoc")
public class ForEachDomainTest extends ReplicationTestCase
{
  private static final int RS_ID = 613;
  private static final String SECOND_BACKEND_ID = "test2";
  private static final String SECOND_ROOT_DN_STRING = "o=" + SECOND_BACKEND_ID;

  private DN firstBaseDN;
  private DN secondBaseDN;
  private ReplicationServer replicationServer;
  private LDAPReplicationDomain firstDomain;
  private LDAPReplicationDomain secondDomain;

  @BeforeMethod
  public void setUpLocal() throws Exception
  {
    firstBaseDN = DN.valueOf(TEST_ROOT_DN_STRING);
    secondBaseDN = DN.valueOf(SECOND_ROOT_DN_STRING);
    TestCaseUtils.initializeTestBackend(true);
    TestCaseUtils.initializeMemoryBackend(SECOND_BACKEND_ID, SECOND_ROOT_DN_STRING, true);

    final int rsPort = TestCaseUtils.findFreePort();
    replicationServer = new ReplicationServer(new ReplServerFakeConfiguration(
        rsPort, "forEachDomainTestDb", 0, RS_ID, 0, 100, new TreeSet<String>()));
    final SortedSet<String> replServers = new TreeSet<>();
    replServers.add("localhost:" + rsPort);
    firstDomain = MultimasterReplication.createNewDomain(new DomainFakeCfg(firstBaseDN, 1, replServers));
    secondDomain = MultimasterReplication.createNewDomain(new DomainFakeCfg(secondBaseDN, 2, replServers));
  }

  @AfterMethod
  public void tearDown() throws Exception
  {
    try
    {
      MultimasterReplication.deleteDomain(firstBaseDN);
      MultimasterReplication.deleteDomain(secondBaseDN);
    }
    finally
    {
      try
      {
        remove(replicationServer);
      }
      finally
      {
        final MemoryBackend backend = (MemoryBackend) getServerContext().getBackendConfigManager()
            .getLocalBackendById(SECOND_BACKEND_ID);
        if (backend != null)
        {
          backend.clearMemoryBackend();
          backend.finalizeBackend();
          getServerContext().getBackendConfigManager().deregisterLocalBackend(backend);
        }
      }
    }
  }

  @Test
  public void theFirstFailureIsThrownOnceTheLoopIsOverWithTheOthersSuppressedUnderIt()
  {
    final RuntimeException first = new RuntimeException("first");
    final RuntimeException second = new RuntimeException("second");
    final List<LDAPReplicationDomain> visited = new ArrayList<>();

    final Throwable thrown = catchThrowable(() -> MultimasterReplication.forEachDomain(domain ->
    {
      visited.add(domain);
      throw visited.size() == 1 ? first : second;
    }));

    assertThat(thrown).as("the failure thrown once the loop is over must be the first one met")
        .isSameAs(first);
    assertThat(thrown.getSuppressed()).as("the failure met after the first must be suppressed under it")
        .containsExactly(second);
    assertThat(visited).as("every domain must get its turn whatever the one before it threw")
        .containsExactlyInAnyOrder(firstDomain, secondDomain);
  }

  @Test
  public void aFailureThrownByTwoDomainsIsThrownOnceAndSuppressesNothing()
  {
    // The error a JVM out of memory prepared beforehand is handed out to every domain alike.
    final OutOfMemoryError theOneError = new OutOfMemoryError("prepared beforehand");
    final List<LDAPReplicationDomain> visited = new ArrayList<>();

    final Throwable thrown = catchThrowable(() -> MultimasterReplication.forEachDomain(domain ->
    {
      visited.add(domain);
      throw theOneError;
    }));

    assertThat(thrown).as("the failure thrown once the loop is over must be the one both domains threw")
        .isSameAs(theOneError);
    assertThat(thrown.getSuppressed()).as("a failure must not be suppressed under itself").isEmpty();
    assertThat(visited).as("every domain must get its turn whatever the one before it threw")
        .containsExactlyInAnyOrder(firstDomain, secondDomain);
  }

  @Test
  public void aFirstFailureWhichRecordsNoSuppressionStillGivesEveryDomainItsTurn()
  {
    final Error first = new ErrorWhichRecordsNoSuppression();
    final RuntimeException second = new RuntimeException("second");
    final List<LDAPReplicationDomain> visited = new ArrayList<>();

    final Throwable thrown = catchThrowable(() -> MultimasterReplication.forEachDomain(domain ->
    {
      visited.add(domain);
      if (visited.size() == 1)
      {
        throw first;
      }
      throw second;
    }));

    assertThat(thrown).as("the failure thrown once the loop is over must be the first one met")
        .isSameAs(first);
    assertThat(thrown.getSuppressed()).as("a failure which records no suppression must have none recorded")
        .isEmpty();
    assertThat(visited).as("every domain must get its turn whatever the one before it threw")
        .containsExactlyInAnyOrder(firstDomain, secondDomain);
  }

  /**
   * An error which keeps no record of the failures suppressed under it: the shape of the
   * error a JVM out of memory prepared beforehand, which was made without its constructor
   * and so keeps no list to record them in.
   */
  private static final class ErrorWhichRecordsNoSuppression extends Error
  {
    private static final long serialVersionUID = 1L;

    private ErrorWhichRecordsNoSuppression()
    {
      super("records no suppression", null, false, false);
    }
  }
}