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

import static org.assertj.core.api.Assertions.*;
import static org.forgerock.opendj.ldap.SearchScope.*;
import static org.opends.server.protocols.internal.InternalClientConnection.*;
import static org.opends.server.protocols.internal.Requests.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.opendj.server.config.server.MonitorProviderCfg;
import org.opends.server.TestCaseUtils;
import org.opends.server.api.ConnectionHandler;
import org.opends.server.api.MonitorData;
import org.opends.server.api.MonitorProvider;
import org.opends.server.core.DirectoryServer;
import org.opends.server.protocols.http.HTTPConnectionHandler;
import org.opends.server.protocols.internal.InternalSearchOperation;
import org.opends.server.protocols.ldap.LDAPConnectionHandler;
import org.opends.server.types.Entry;
import org.forgerock.opendj.reactive.LDAPConnectionHandler2;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

/**
 * A monitor provider whose name holds ',', '+' or '\' must get the monitor entry it names, and must not
 * break the rest of cn=monitor (issue #1153).
 */
@SuppressWarnings("javadoc")
public class MonitorDNTestCase extends MonitorTestCase
{
  private static final DN MONITOR_ROOT = DN.valueOf("cn=monitor");

  /** A monitor provider of a third party, which gives its name as is. */
  private static final class NamedMonitorProvider extends MonitorProvider<MonitorProviderCfg>
  {
    private final String name;

    NamedMonitorProvider(String name)
    {
      this.name = name;
    }

    @Override
    public void initializeMonitorProvider(MonitorProviderCfg configuration)
    {
      // No implementation required.
    }

    @Override
    public String getMonitorInstanceName()
    {
      return name;
    }

    @Override
    public MonitorData getMonitorData()
    {
      return new MonitorData(0);
    }
  }

  @BeforeClass
  public void startServer() throws Exception
  {
    TestCaseUtils.startServer();
  }

  /** The name of {@link TestMonitorProvider} is a relative DN: it still names an entry two levels down. */
  @Test
  public void relativeDNNameKeepsItsTree()
  {
    assertThat((Object) DirectoryServer.getMonitorProviderDN(new TestMonitorProvider()))
        .isEqualTo(DN.valueOf("cn=Test monitor for dc=example,dc=com,cn=monitor"));
  }

  @DataProvider
  public Object[][] namesThatAreNotRelativeDNs()
  {
    return new Object[][] { { "LDAP, internal 0.0.0.0 port 41390" }, { "a+b" }, { "a;b" }, { "x\\" } };
  }

  @Test(dataProvider = "namesThatAreNotRelativeDNs")
  public void nameThatIsNotARelativeDNNamesOneEntry(String name) throws Exception
  {
    final NamedMonitorProvider provider = new NamedMonitorProvider(name);
    assertThat((Object) DirectoryServer.getMonitorProviderDN(provider)).isEqualTo(MONITOR_ROOT.child("cn", name));

    DirectoryServer.registerMonitorProvider(provider);
    try
    {
      assertMonitorIsSearchable();
      assertEntryExists(MONITOR_ROOT.child("cn", name));
    }
    finally
    {
      DirectoryServer.deregisterMonitorProvider(provider);
    }
  }

  @DataProvider
  public Object[][] connectionHandlerClasses()
  {
    final String[] ldap = { "ds-cfg-allow-ldap-v2: false", "ds-cfg-allow-start-tls: false" };
    return new Object[][] {
      { LDAPConnectionHandler.class.getName(), "ds-cfg-ldap-connection-handler", ldap },
      { LDAPConnectionHandler2.class.getName(), "ds-cfg-ldap-connection-handler", ldap },
      { HTTPConnectionHandler.class.getName(), "ds-cfg-http-connection-handler", new String[0] },
    };
  }

  /** The connection handler, its client connections and its statistics each get the entry they name. */
  @Test(dataProvider = "connectionHandlerClasses")
  public void connectionHandlerWithACommaInItsName(String javaClass, String objectClass, String[] attributes)
      throws Exception
  {
    // Unescaped, "LDAP,ou=internal 127.0.0.1 port N" would be a relative DN two levels down
    final String name = "LDAP,ou=internal";
    final int port = TestCaseUtils.findFreePort();
    final List<String> ldif = new ArrayList<>(Arrays.asList(
        "dn: cn=LDAP\\,ou\\=internal,cn=Connection Handlers,cn=config",
        "objectClass: top",
        "objectClass: ds-cfg-connection-handler",
        "objectClass: " + objectClass,
        "cn: " + name,
        "ds-cfg-java-class: " + javaClass,
        "ds-cfg-enabled: true",
        "ds-cfg-listen-address: 127.0.0.1",
        "ds-cfg-listen-port: " + port,
        "ds-cfg-use-ssl: false"));
    Collections.addAll(ldif, attributes);
    final Entry handlerEntry = TestCaseUtils.makeEntry(ldif.toArray(new String[0]));
    TestCaseUtils.addEntry(handlerEntry);
    try
    {
      final String handlerName = connectionHandlerName(name);
      assertMonitorIsSearchable();
      assertEntryExists(MONITOR_ROOT.child("cn", handlerName));
      assertEntryExists(MONITOR_ROOT.child("cn", handlerName).child("cn", "Client Connections"));
      assertEntryExists(MONITOR_ROOT.child("cn", handlerName + " Statistics"));
    }
    finally
    {
      TestCaseUtils.deleteEntry(handlerEntry);
    }
  }

  @DataProvider
  public Object[][] storageBackends()
  {
    return new Object[][] {
      { "ds-cfg-je-backend", "org.opends.server.backends.jeb.JEBackend", " JE Database" },
      { "ds-cfg-pdb-backend", "org.opends.server.backends.pdb.PDBBackend", " PDB Database" },
    };
  }

  /** A backend whose ID holds ',' and '=' gets its backend, storage, database and disk space monitor entries. */
  @Test(dataProvider = "storageBackends")
  public void backendWithACommaInItsID(String objectClass, String javaClass, String databaseSuffix) throws Exception
  {
    // Unescaped, "monitor,ou=a b Backend" would be a relative DN two levels down
    final String backendID = "monitor,ou=a b";
    final Entry backendEntry = TestCaseUtils.makeEntry(
        "dn: ds-cfg-backend-id=monitor\\,ou\\=a b,cn=Backends,cn=config",
        "objectClass: top",
        "objectClass: ds-cfg-backend",
        "objectClass: ds-cfg-local-backend",
        "objectClass: ds-cfg-pluggable-backend",
        "objectClass: " + objectClass,
        "ds-cfg-enabled: true",
        "ds-cfg-java-class: " + javaClass,
        "ds-cfg-backend-id: " + backendID,
        "ds-cfg-writability-mode: enabled",
        "ds-cfg-base-dn: o=monitor dn test",
        "ds-cfg-db-directory: db_monitor_dn_test",
        "ds-cfg-db-cache-percent: 2");
    TestCaseUtils.addEntry(backendEntry);
    try
    {
      assertMonitorIsSearchable();
      assertEntryExists(MONITOR_ROOT.child("cn", backendID + " Backend"));
      assertEntryExists(MONITOR_ROOT.child("cn", backendID + " Storage"));
      assertEntryExists(MONITOR_ROOT.child("cn", backendID + databaseSuffix));
      assertEntryExists(MONITOR_ROOT.child("cn", "Disk Space Monitor").child("cn", backendID + " backend"));
    }
    finally
    {
      TestCaseUtils.deleteEntry(backendEntry);
    }
  }

  /** An entry cache whose name holds ',' and '=' gets its monitor entry. */
  @Test
  public void entryCacheWithACommaInItsName() throws Exception
  {
    // Unescaped, "FIFO,ou=a b Entry Cache" would be a relative DN two levels down
    final String cacheName = "FIFO,ou=a b";
    final Entry cacheEntry = TestCaseUtils.makeEntry(
        "dn: cn=FIFO\\,ou\\=a b,cn=Entry Caches,cn=config",
        "objectClass: top",
        "objectClass: ds-cfg-entry-cache",
        "objectClass: ds-cfg-fifo-entry-cache",
        "cn: " + cacheName,
        "ds-cfg-cache-level: 7",
        "ds-cfg-java-class: org.opends.server.extensions.FIFOEntryCache",
        "ds-cfg-enabled: true",
        "ds-cfg-max-entries: 10");
    TestCaseUtils.addEntry(cacheEntry);
    try
    {
      assertMonitorIsSearchable();
      assertEntryExists(MONITOR_ROOT.child("cn", cacheName + " Entry Cache"));
    }
    finally
    {
      TestCaseUtils.deleteEntry(cacheEntry);
    }
  }

  /** The name of a connection handler starts with the name of its configuration entry, then its address and port. */
  private static String connectionHandlerName(String configName)
  {
    for (ConnectionHandler<?> handler : DirectoryServer.getConnectionHandlers())
    {
      if (handler.getConnectionHandlerName().startsWith(configName + " "))
      {
        return handler.getConnectionHandlerName();
      }
    }
    return fail("no connection handler named " + configName);
  }

  private static void assertMonitorIsSearchable() throws Exception
  {
    final InternalSearchOperation subtree = getRootConnection().processSearch(newSearchRequest(MONITOR_ROOT, WHOLE_SUBTREE));
    assertThat(subtree.getResultCode()).as(String.valueOf(subtree.getErrorMessage())).isEqualTo(ResultCode.SUCCESS);
    assertEntryExists(DN.valueOf("cn=Version,cn=monitor"));
  }

  /** Asserts that a monitor provider gives the entry: a branch (glue) entry would not do. */
  private static void assertEntryExists(DN dn) throws Exception
  {
    final InternalSearchOperation base = getRootConnection().processSearch(
        newSearchRequest(dn, BASE_OBJECT, "(!(objectClass=ds-mon-branch))"));
    assertThat(base.getResultCode()).as(dn + ": " + base.getErrorMessage()).isEqualTo(ResultCode.SUCCESS);
    assertThat(base.getSearchEntries()).hasSize(1);
  }
}