library(testthat)

set.seed(123)

n <- 500

# --- Generate moderator
z <- sort(rnorm(n))
z1 <- z[z <= 0]
z2 <- z[z > 0]

# --- x -> y when m <= 0
x1 <- rchisq(length(z1), df = 4) - 4
e1 <- rchisq(length(z1), df = 3) - 3
y1 <- 0.5 * x1 + e1

# --- y -> x when m > 0
y2 <- rchisq(length(z2), df = 4) - 4
e2 <- rchisq(length(z2), df = 3) - 3
x2 <- 0.5 * y2 + e2

# Combine data
y <- c(y1, y2)
x <- c(x1, x2)
dat <- data.frame(x = x, y = y, z = z)

# Fit model
m <- lm(y ~ x * z, data = dat)

# ------------------------
# Basic smoke tests
# ------------------------

test_that("cdda.indep runs with numeric nlfun and returns a list-like object", {
  out <- cdda.indep(
    formula = m,
    pred = "x",
    mod = "z",
    modval = c(0, 1),
    dcor = TRUE,
    diff = FALSE,
    hetero = FALSE,
    data = dat,
    nlfun = 2,
    B = 100
  )
  expect_true(is.list(out))
})

test_that("cdda.indep accepts a function nlfun and supports print/summary", {
  out_f <- cdda.indep(
    formula = m,
    pred = "x",
    mod = "z",
    modval = c(0, 1),
    data = dat,
    nlfun = function(t) t^2,
    B = 100
  )
  expect_true(is.list(out_f))
  expect_output(print(out_f))
  expect_output(summary(out_f, hsic = FALSE))
})

# ------------------------
# Defensive / input-validation tests
# ------------------------

test_that("cdda.indep errors when pred is not in the model", {
  expect_error(cdda.indep(formula = m, pred = "no_such_variable", data = dat))
})

test_that("cdda.indep errors when formula is not an lm object", {
  expect_error(cdda.indep(formula = 1, pred = "x", data = dat))
  expect_error(cdda.indep(formula = "y ~ x", pred = "x", data = dat))
})

test_that("cdda.indep errors when nlfun is of wrong type", {
  expect_error(cdda.indep(formula = m, pred = "x", data = dat, nlfun = "not_a_function"))
})

test_that("cdda.indep errors when B is nonsensical (negative or zero)", {
  expect_error(cdda.indep(formula = m, pred = "x", data = dat, B = -10))
  expect_error(cdda.indep(formula = m, pred = "x", data = dat, B = 0))
})

# ------------------------
# Small-B bootstrap HSIC defensive test (no skip, tolerant)
# ------------------------
test_that("cdda.indep small-B bootstrap HSIC: tolerant behavior (warning, error, or valid return accepted)", {
  # We run with a very small B and accept any of:
  #  - a warning emitted
  #  - an error (returned as an error object by tryCatch)
  #  - a successful return (list)
  w_msgs <- character()
  res <- NULL

  withCallingHandlers(
    {
      res <- tryCatch(
        cdda.indep(formula = m, pred = "x", data = dat, hsic.method = "bootstrap", B = 10, diff = FALSE, mod = "z", modval = c(0,1)),
        error = function(e) e
      )
    },
    warning = function(w) {
      w_msgs <<- c(w_msgs, conditionMessage(w))
      invokeRestart("muffleWarning")
    }
  )

  # Accept any warning as evidence the function handled the situation (e.g., warned and possibly fell back)
  if (length(w_msgs) > 0) {
    expect_true(TRUE)
    return()
  }

  # If an error was returned, accept it (defensive test) — we don't assert a specific message here
  if (inherits(res, "error")) {
    expect_true(TRUE)
    return()
  }

  # If a valid object was returned, ensure it's list-like
  if (is.list(res)) {
    expect_true(TRUE)
    return()
  }

  # Otherwise fail (shouldn't happen)
  fail("Unexpected non-error, non-warning, non-list outcome from cdda.indep with small B")
})

# ------------------------
# Final lightweight checks
# ------------------------

test_that("cdda.indep handles modval variations (numeric and named)", {
  # numeric pick-a-point
  out_num <- cdda.indep(formula = m, pred = "x", mod = "z", modval = c(-1, 1), data = dat, B = 50)
  expect_true(is.list(out_num))

  # named 'mean' approach (ensure it does not error)
  out_mean <- cdda.indep(formula = m, pred = "x", mod = "z", modval = "mean", data = dat, B = 50)
  expect_true(is.list(out_mean))
})

test_that("cdda.indep returns non-empty structure", {
  out <- cdda.indep(formula = m, pred = "x", mod = "z", modval = c(0,1), data = dat, nlfun = 2, B = 50)
  expect_true(is.list(out))
  expect_true(length(out) > 0)
})