test_that("simulate_design produces reproducible Stage 1 input", {
  
  trial_generator <- function(N, A, F, rate_C, rate_T) {
    arm <- rep(c(0, 1), each = N / 2)
    entry <- runif(N, 0, A)
    event_time <- rexp(
      N, rate = ifelse(arm == 0, rate_C, rate_T)
    )
    censor_time <- A + F - entry
    
    data.frame(
      arm = arm,
      X = pmin(event_time, censor_time),
      status = as.numeric(event_time <= censor_time)
    )
  }
  
  args <- list(
    N = 160,
    A = 48,
    F = 36,
    rate_C = -log(0.60) / 36,
    rate_T = 0.55 * (-log(0.60) / 36)
  )
  
  run_simulation <- function() {
    simulate_design(
      trial_generator = trial_generator,
      n_sim = 4,
      tau_grid = c(24, 36),
      trial_args = args,
      scenario_id = "test_design",
      seed = 202611
    )
  }
  
  raw <- run_simulation()
  
  # Check simulation structure
  expect_s3_class(raw, "data.frame")
  expect_equal(nrow(raw), 8)
  expect_true(all(table(raw$tau) == 4))
  expect_equal(
    anyDuplicated(raw[c("scenario_id", "sim_id", "tau")]),
    0L
  )
  
  # Check reproducibility
  expect_identical(raw, run_simulation())
  
  # Check Stage 1 integration
  audit <- stage1_audit(
    raw,
    thresholds = list(
      p_risk_min = 0.10,
      n_risk_min = 10,
      p_support_min = 0.95
    )
  )
  
  expect_equal(nrow(audit$scenario_summary), 2)
  expect_true(all(audit$scenario_summary$n_sim == 4))
})

test_that("simulate_design rejects invalid inputs", {
  
  dummy_generator <- function(...) {
    stop("Generator should not be called")
  }
  
  # Invalid simulation count
  expect_error(
    simulate_design(
      dummy_generator, n_sim = 0,
      tau_grid = c(24, 36), seed = 202611
    ),
    "n_sim must be a positive whole number"
  )
  
  # Invalid horizon
  expect_error(
    simulate_design(
      dummy_generator, n_sim = 10,
      tau_grid = c(24, -36), seed = 202611
    ),
    "tau_grid must contain distinct"
  )
  
  # Invalid random seed
  expect_error(
    simulate_design(
      dummy_generator, n_sim = 10,
      tau_grid = c(24, 36), seed = -1
    ),
    "seed must be a nonnegative whole number"
  )
  
  # Invalid significance level
  expect_error(
    simulate_design(
      dummy_generator, n_sim = 10,
      tau_grid = c(24, 36), seed = 202611,
      alpha = 1
    ),
    "alpha must be strictly between 0 and 1"
  )
})

test_that("simulate_design restores RNG after generator failure", {
  
  bad_generator <- function(...) {
    runif(3)
    stop("intentional failure")
  }
  
  set.seed(20261015)
  rng_before <- .Random.seed
  kind_before <- RNGkind()
  
  expect_error(
    simulate_design(
      trial_generator = bad_generator,
      n_sim = 2,
      tau_grid = c(24, 36),
      seed = 202611
    ),
    "Trial generation failed in replicate 1"
  )
  
  expect_identical(.Random.seed, rng_before)
  expect_identical(RNGkind(), kind_before)
})

test_that("simulate_design rejects invalid trial data", {
  
  bad_trial_generator <- function(...) {
    runif(2)
    
    data.frame(
      arm = c(0, 1, 0, 1),
      X = c(10, 15, 12, 20),
      status = c(1, 0, 2, 1)
    )
  }
  
  set.seed(20261015)
  rng_before <- .Random.seed
  
  expect_error(
    simulate_design(
      trial_generator = bad_trial_generator,
      n_sim = 2,
      tau_grid = c(24, 36),
      seed = 202611
    ),
    "Invalid trial in replicate 1"
  )
  
  expect_identical(.Random.seed, rng_before)
})