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

import static com.forgerock.opendj.util.OperatingSystem.*;
import static org.opends.messages.QuickSetupMessages.INFO_ERROR_STARTING_SERVER_CODE;
import static org.testng.Assert.*;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;

import org.forgerock.i18n.LocalizableMessage;
import org.opends.quicksetup.Application;
import org.opends.quicksetup.ApplicationException;
import org.opends.quicksetup.Installation;
import org.opends.quicksetup.ProgressStep;
import org.opends.quicksetup.ReturnCode;
import org.opends.server.DirectoryServerTestCase;
import org.testng.SkipException;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

/**
 * A failed start reports what the start command printed (issue #1160), unless the listeners of
 * the application have already shown it. The installation is a bare directory whose start command
 * is a stand-in script that prints and exits with 1.
 */
@SuppressWarnings("javadoc")
@Test(sequential = true)
public class ServerControllerStartFailureTest extends DirectoryServerTestCase
{
  private File root;

  @BeforeMethod
  public void createInstallation() throws IOException
  {
    root = Files.createTempDirectory("server-controller-start-failure").toFile();
  }

  @AfterMethod(alwaysRun = true)
  public void deleteInstallation() throws ApplicationException
  {
    new FileManager().deleteRecursively(root);
  }

  @Test
  public void failedStartReportsBothOutputStreams() throws Exception
  {
    writeStartCommandPrintingToBothStreams();

    String message = startAndExpectFailure(null, false);

    assertTrue(message.startsWith(exitCodeMessage()), message);
    assertTrue(message.contains("cause on stdout"), message);
    assertTrue(message.contains("cause on stderr"), message);
  }

  @Test
  public void failedStartReportsOnlyTheLastLines() throws Exception
  {
    if (isWindows())
    {
      writeStartCommand("@for /L %%i in (1,1,150) do @echo L%%iL", "@exit /b 1");
    }
    else
    {
      writeStartCommand("#!/bin/sh", "i=1", "while [ $i -le 150 ]; do echo \"L${i}L\"; i=$((i+1)); done", "exit 1");
    }

    String message = startAndExpectFailure(null, false);

    assertFalse(message.contains("L50L"), message);
    assertTrue(message.contains("L51L"), message);
    assertTrue(message.contains("L150L"), message);
  }

  @Test
  public void failedStartReportsWhatIsPrintedAfterTheExit() throws Exception
  {
    if (isWindows())
    {
      throw new SkipException("needs a child process that outlives the start command");
    }
    // The child holds the inherited pipes after sh exits, so its line arrives after waitFor().
    // When the process exits, the JDK drains what is already in a pipe and closes it, unless a
    // reader is blocked in read() on that stream, which the drain then waits for. The first
    // line and the pause before the exit leave the stdout reader blocked there, so that the
    // line of the child is read rather than cut off by the drain.
    writeStartCommand("#!/bin/sh", "echo 'printed before the exit'", "sleep 1",
        "(sleep 1; echo 'printed after the exit') &", "exit 1");

    String message = startAndExpectFailure(null, false);

    assertTrue(message.contains("printed before the exit"), message);
    assertTrue(message.contains("printed after the exit"), message);
  }

  @Test
  public void silentFailedStartKeepsTheExitCodeMessage() throws Exception
  {
    if (isWindows())
    {
      writeStartCommand("@exit /b 1");
    }
    else
    {
      writeStartCommand("#!/bin/sh", "exit 1");
    }

    assertEquals(startAndExpectFailure(null, false), exitCodeMessage());
  }

  @Test
  public void failedStartShownToTheListenersKeepsTheExitCodeMessage() throws Exception
  {
    writeStartCommandPrintingToBothStreams();
    ListeningApplication application = new ListeningApplication();

    assertEquals(startAndExpectFailure(application, false), exitCodeMessage());
    assertTrue(application.getShown().contains("cause on stdout"), application.getShown());
    assertTrue(application.getShown().contains("cause on stderr"), application.getShown());
  }

  @Test
  public void failedStartHiddenFromTheListenersReportsBothOutputStreams() throws Exception
  {
    writeStartCommandPrintingToBothStreams();
    ListeningApplication application = new ListeningApplication();

    String message = startAndExpectFailure(application, true);

    assertTrue(message.startsWith(exitCodeMessage()), message);
    assertTrue(message.contains("cause on stdout"), message);
    assertTrue(message.contains("cause on stderr"), message);
    assertEquals(application.getShown(), "");
  }

  private static String exitCodeMessage()
  {
    return INFO_ERROR_STARTING_SERVER_CODE.get(1).toString();
  }

  private void writeStartCommandPrintingToBothStreams() throws IOException
  {
    if (isWindows())
    {
      writeStartCommand("@echo cause on stdout", "@echo cause on stderr 1>&2", "@exit /b 1");
    }
    else
    {
      writeStartCommand("#!/bin/sh", "echo 'cause on stdout'", "echo 'cause on stderr' >&2", "exit 1");
    }
  }

  private void writeStartCommand(String... lines) throws IOException
  {
    Installation installation = new Installation(root, root);
    File command = installation.getServerStartCommandFile();
    assertTrue(command.getParentFile().mkdirs());
    Files.write(command.toPath(), String.join(isWindows() ? "\r\n" : "\n", lines).concat("\n")
        .getBytes(StandardCharsets.US_ASCII));
    assertTrue(command.setExecutable(true));
  }

  private String startAndExpectFailure(Application application, boolean suppressOutput)
  {
    try
    {
      new ServerController(application, new Installation(root, root)).startServer(suppressOutput);
      fail("The start command exited with 1, but the start did not fail");
      return null;
    }
    catch (ApplicationException e)
    {
      assertEquals(e.getType(), ReturnCode.START_ERROR);
      return e.getMessage();
    }
  }

  /** An application whose listener keeps the log details it is shown. */
  private static final class ListeningApplication extends Application
  {
    private final StringBuilder shown = new StringBuilder();

    ListeningApplication()
    {
      setProgressMessageFormatter(new PlainTextProgressMessageFormatter());
      addProgressUpdateListener(ev ->
      {
        synchronized (shown)
        {
          shown.append(ev.getNewLogs());
        }
      });
    }

    String getShown()
    {
      synchronized (shown)
      {
        return shown.toString();
      }
    }

    @Override
    public String getInstallationPath()
    {
      return null;
    }

    @Override
    public String getInstancePath()
    {
      return null;
    }

    @Override
    public ProgressStep getCurrentProgressStep()
    {
      return null;
    }

    @Override
    public Integer getRatio(ProgressStep step)
    {
      return null;
    }

    @Override
    public LocalizableMessage getSummary(ProgressStep step)
    {
      return null;
    }

    @Override
    public boolean isFinished()
    {
      return false;
    }

    @Override
    public boolean isCancellable()
    {
      return false;
    }

    @Override
    public void cancel()
    {
      // Nothing to cancel.
    }

    @Override
    public void run()
    {
      // Never run: the test drives the ServerController directly.
    }
  }
}