/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

#if !defined(_POSIX_C_SOURCE) && !defined(_WIN32) && !defined(__sun) &&       \
  !defined(__OpenBSD__)
// POSIX APIs are needed (sigaction, sigemptyset, SA_RESETHAND).
// NOLINTNEXTLINE(bugprone-reserved-identifier)
#  define _POSIX_C_SOURCE 200809L
#endif
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__QNX__)
// For isascii
// NOLINTNEXTLINE(bugprone-reserved-identifier)
#  define _XOPEN_SOURCE 700
#endif

#include "cmInstrumentationInterrupt.h"

#include <csignal>
#include <cstdlib>
#ifdef _WIN32
#  include <atomic>

#  include <windows.h>
#else
#  include <cstring>
#endif

namespace {
// Flag shared between the interrupt handler and the command flow that writes
// the instrumentation envelope snippet.  On Windows the console control
// handler runs on a separate thread, so an atomic is required; on POSIX the
// handler runs in signal context, where only `volatile sig_atomic_t` is
// guaranteed safe.
#ifdef _WIN32
std::atomic<int> interruptSignal{ 0 };

BOOL WINAPI cmInstrumentationConsoleHandler(DWORD type)
{
  if (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT) {
    int expected = 0;
    interruptSignal.compare_exchange_strong(expected, SIGINT);
    // Return TRUE so the main thread can finish writing the snippet before the
    // process exits.  Child processes (native build tool, install scripts,
    // tests) share the console and receive the event directly, so they still
    // terminate and unblock our loop.
    return TRUE;
  }
  return FALSE;
}
#else
sig_atomic_t volatile interruptSignal = 0;
struct sigaction savedSigIntAction;

extern "C" void cmInstrumentationSignalHandler(int sig)
{
  interruptSignal = sig;
}
#endif

// Set when the pending interrupt was injected by the test seam below rather
// than delivered by the OS.  An injected interrupt must NOT be re-raised (the
// process exits normally after flushing the snippet), so the test stays a
// clean-exit, leak-checkable case on every generator.
bool interruptInjected = false;

// Test-only seam.  An undocumented, unsupported environment variable lets the
// instrumentation test suite inject an "interrupted" condition
// deterministically, with no real OS signal -- so the instrumentation
// interrupt path can be exercised on every generator and platform.  The
// double-underscore name marks it internal; it is never set in normal use.
// Mirrors CTest's internal fake-hook convention.
void InjectTestInterrupt()
{
  char const* value = std::getenv("__CMAKE_INSTRUMENTATION_TEST_INTERRUPT");
  if (!value) {
    return;
  }
  int sig = std::atoi(value);
  if (sig <= 0) {
    return;
  }
#ifdef _WIN32
  interruptSignal.store(sig);
#else
  interruptSignal = static_cast<sig_atomic_t>(sig);
#endif
  interruptInjected = true;
}

// Install the interrupt handler and clear any previously recorded signal.
void InstallInterruptHandler()
{
#ifdef _WIN32
  interruptSignal.store(0);
  SetConsoleCtrlHandler(cmInstrumentationConsoleHandler, TRUE);
#else
  interruptSignal = 0;
  struct sigaction sa;
  memset(&sa, 0, sizeof(sa));
  sa.sa_handler = cmInstrumentationSignalHandler;
  sigemptyset(&sa.sa_mask);
  // One-shot: after the first interrupt the default disposition is restored,
  // so a second Ctrl+C terminates immediately even while we are mid-flush.
  sa.sa_flags = SA_RESETHAND;
  sigaction(SIGINT, &sa, &savedSigIntAction);
#endif
}

// Restore the disposition that was in effect before InstallInterruptHandler().
void RestoreInterruptHandler()
{
#ifdef _WIN32
  SetConsoleCtrlHandler(cmInstrumentationConsoleHandler, FALSE);
#else
  sigaction(SIGINT, &savedSigIntAction, nullptr);
#endif
}
}

int cmInstrumentationInterrupt::PendingInterruptSignal()
{
#ifdef _WIN32
  return interruptSignal.load();
#else
  return static_cast<int>(interruptSignal);
#endif
}

cmInstrumentationInterrupt::InterruptOutcome
cmInstrumentationInterrupt::HandleInterrupt(
  bool active, std::function<int()> const& callback)
{
  // Only trap interrupts when instrumentation is active, so non-instrumented
  // flows keep their default signal behavior.
  if (!active) {
    return { callback(), false, 0, true };
  }
  InstallInterruptHandler();
  interruptInjected = false;
  // Test-only: allow the suite to inject an interrupt deterministically.
  InjectTestInterrupt();
  int ret = callback();
  int sig = PendingInterruptSignal();
  RestoreInterruptHandler();
  // A real OS interrupt should be re-raised so the exit status reflects it; an
  // injected (test) interrupt should not, so the process exits cleanly.
  return { ret, sig != 0, sig, !interruptInjected };
}

void cmInstrumentationInterrupt::RaiseInterrupt(int sig)
{
#ifdef _WIN32
  // On Windows the process exits normally after flushing; the caller
  // propagates the (failed) build result.
  static_cast<void>(sig);
#else
  // Restore the default disposition (SA_RESETHAND already did so for the first
  // delivery) and re-raise so the exit status reflects the interrupt.
  signal(sig, SIG_DFL);
  raise(sig);
#endif
}