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

import static org.mockito.Mockito.*;
import static org.testng.Assert.*;

import java.io.File;
import java.io.FilenameFilter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;

import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.server.config.server.SizeLimitLogRotationPolicyCfg;
import org.opends.server.DirectoryServerTestCase;
import org.opends.server.TestCaseUtils;
import org.opends.server.types.FilePermission;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

/** Tests the rotation of {@link MultifileTextWriter}, in particular when the rename fails. */
@SuppressWarnings("javadoc")
public class MultifileTextWriterTestCase extends DirectoryServerTestCase
{
  private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();

  private static final DN PUBLISHER_DN = DN.valueOf("cn=Test Logger,cn=Loggers,cn=config");
  /** Small enough for two records to overflow it, large enough for one not to. */
  private static final long SIZE_LIMIT = 64;
  private static final String RECORD_A = "a".repeat(32);
  private static final String RECORD_B = "b".repeat(32);
  /** Long enough to leave the re-opened stream over the size limit together with the first record. */
  private static final String STAND_IN_WARNING =
      "stand-in for the permission warnings logged while the writer is re-opened";

  /** Naming policy with fixed names, so that the test does not depend on the current second. */
  private static final class FixedNamingPolicy implements FileNamingPolicy
  {
    private final File initialFile;
    private final File nextFile;

    private FixedNamingPolicy(File initialFile, File nextFile)
    {
      this.initialFile = initialFile;
      this.nextFile = nextFile;
    }

    @Override
    public File getInitialName()
    {
      return initialFile;
    }

    @Override
    public File getNextName()
    {
      return nextFile;
    }

    @Override
    public FilenameFilter getFilenameFilter()
    {
      return new FilenameFilter()
      {
        @Override
        public boolean accept(File dir, String name)
        {
          return name.equals(nextFile.getName());
        }
      };
    }

    @Override
    public File[] listFiles()
    {
      return new File[0];
    }
  }

  /**
   * A file which can run a hook from within constructWriter(): after a failed rotation the writer
   * is re-opened, and {@code FilePermission.setPermissions} checks {@code exists()} at the exact
   * point where the permission warnings are logged.
   */
  private static final class HookedFile extends File
  {
    private static final long serialVersionUID = 1L;
    private transient Runnable onExists;

    private HookedFile(File parent, String child)
    {
      super(parent, child);
    }

    @Override
    public boolean exists()
    {
      if (onExists != null)
      {
        onExists.run();
      }
      return super.exists();
    }
  }

  private File tempDir;
  private File logFile;
  private File rotatedFile;
  private MultifileTextWriter writer;

  @BeforeClass
  public void startServer() throws Exception
  {
    // The writer registers itself as a shutdown listener, which requires a bootstrapped server.
    TestCaseUtils.startServer();
  }

  @BeforeMethod
  public void setUp() throws Exception
  {
    tempDir = Files.createTempDirectory("MultifileTextWriterTestCase").toFile();
    logFile = new File(tempDir, "test.log");
    rotatedFile = new File(tempDir, "test.log.rotated");
  }

  @AfterMethod
  public void tearDown() throws Exception
  {
    if (writer != null)
    {
      writer.shutdown();
      writer = null;
    }
    deleteRecursively(tempDir);
  }

  /**
   * Makes the rename attempted by the rotation fail on every platform: renaming a file onto a
   * non-empty directory is refused both on POSIX systems and on Windows.
   */
  private void breakRotation() throws Exception
  {
    assertTrue(rotatedFile.mkdir());
    assertTrue(new File(rotatedFile, "blocker").createNewFile());
  }

  private MultifileTextWriter newWriter() throws Exception
  {
    MultifileTextWriter newWriter = new MultifileTextWriter("Multifile Text Writer for " + PUBLISHER_DN,
        Long.MAX_VALUE, new FixedNamingPolicy(logFile, rotatedFile), FilePermission.decodeUNIXMode("600"),
        new LogPublisherErrorHandler(PUBLISHER_DN), "UTF-8", true, true, 0);

    SizeLimitLogRotationPolicyCfg config = mock(SizeLimitLogRotationPolicyCfg.class);
    when(config.getFileSizeLimit()).thenReturn(SIZE_LIMIT);
    SizeBasedRotationPolicy policy = new SizeBasedRotationPolicy();
    policy.initializeLogRotationPolicy(config);
    newWriter.addRotationPolicy(policy);

    // The rotater thread is deliberately not started: the rotations under test are the ones
    // triggered inline by writeRecord().
    return newWriter;
  }

  private List<String> linesOf(File file) throws Exception
  {
    return Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
  }

  private static void deleteRecursively(File file)
  {
    if (file.isDirectory())
    {
      for (File child : file.listFiles())
      {
        deleteRecursively(child);
      }
    }
    file.delete();
  }

  @Test
  public void testSuccessfulRotationRenamesTheFile() throws Exception
  {
    writer = newWriter();

    writer.writeRecord(RECORD_A);
    writer.writeRecord(RECORD_B);
    writer.flush();

    assertEquals(writer.getTotalFilesRotated(), 1);
    assertEquals(linesOf(rotatedFile), List.of(RECORD_A));
    assertEquals(linesOf(logFile), List.of(RECORD_B));
  }

  @Test
  public void testFailedRotationAppendsInsteadOfTruncating() throws Exception
  {
    breakRotation();
    writer = newWriter();

    writer.writeRecord(RECORD_A);
    assertEquals(writer.getTotalFilesRotated(), 0);

    // Overflows the size limit, so a rotation is attempted and fails.
    writer.writeRecord(RECORD_B);
    writer.flush();

    assertEquals(writer.getTotalFilesRotated(), 0, "a failed rotation must not be counted");
    assertTrue(rotatedFile.isDirectory(), "the rotation target must have been left alone");
    assertEquals(linesOf(logFile), List.of(RECORD_A, RECORD_B),
        "the log file must have been appended to rather than truncated");
  }

  /**
   * A failed rotation of the file backing the error log used to come back into writeRecord() on the
   * same thread, from a writer which had just been closed and was still over the size limit, and to
   * recurse until the stack blew up.
   */
  @Test
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public void testFailedRotationOfTheErrorLogDoesNotRecurse() throws Exception
  {
    breakRotation();
    writer = newWriter();

    MultifileTextWriter publishing = writer;
    ErrorLogPublisher publisher = TextErrorLogPublisher.getServerStartupTextErrorPublisher(publishing);
    ErrorLogger.getInstance().addLogPublisher(publisher);
    try
    {
      publishing.writeRecord(RECORD_A);
      // Overflows the size limit: the rotation fails and reports the failure through the very
      // logger this writer is backing.
      publishing.writeRecord(RECORD_B);
      publishing.flush();
    }
    finally
    {
      // Removing the publisher closes it, which already shuts this writer down.
      ErrorLogger.getInstance().removeLogPublisher(publisher);
      writer = null;
    }

    assertEquals(publishing.getTotalFilesRotated(), 0);

    List<String> lines = linesOf(logFile);
    assertEquals(lines.get(0), RECORD_A, "the log file must have been appended to");
    assertTrue(lines.contains(RECORD_B), "the record which triggered the rotation must not be lost");
    assertTrue(lines.stream().anyMatch(line -> line.contains("rotating log file")),
        "the rotation failure must be reported in the log file, but it contained: " + lines);
  }

  /**
   * constructWriter() logs permission warnings of its own, between re-seeding the stream with the
   * over-limit file length and the point where the failed rotation used to set its latch. When the
   * writer backs the error log, such a warning used to re-enter writeRecord() and to recurse until
   * the stack blew up. The hook stands in for the permission warning, firing at the same point of
   * the re-open.
   */
  @Test
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public void testWarningDuringReopenAfterFailedRotationDoesNotRecurse() throws Exception
  {
    breakRotation();
    HookedFile hookedLogFile = new HookedFile(tempDir, logFile.getName());
    logFile = hookedLogFile;
    writer = newWriter();

    MultifileTextWriter publishing = writer;
    ErrorLogPublisher publisher = TextErrorLogPublisher.getServerStartupTextErrorPublisher(publishing);
    ErrorLogger.getInstance().addLogPublisher(publisher);
    try
    {
      publishing.writeRecord(RECORD_A);
      hookedLogFile.onExists = () -> logger.warn(LocalizableMessage.raw(STAND_IN_WARNING));
      // Overflows the size limit: the rotation fails, and while the writer is re-opened the hook
      // logs through the very logger this writer is backing, like the permission warnings do.
      publishing.writeRecord(RECORD_B);
      publishing.flush();
    }
    finally
    {
      // Removing the publisher closes it, which already shuts this writer down.
      ErrorLogger.getInstance().removeLogPublisher(publisher);
      writer = null;
    }

    assertEquals(publishing.getTotalFilesRotated(), 0);

    List<String> lines = linesOf(logFile);
    assertEquals(lines.get(0), RECORD_A, "the log file must have been appended to");
    assertTrue(lines.stream().anyMatch(line -> line.contains(STAND_IN_WARNING)),
        "the warning logged during the re-open must not be lost, but the log file contained: " + lines);
    assertTrue(lines.contains(RECORD_B), "the record which triggered the rotation must not be lost");
    assertEquals(lines.stream().filter(line -> line.contains("rotating log file")).count(), 1L,
        "the rotation failure must be reported exactly once, but the log file contained: " + lines);
  }
}