test_that("utility helpers validate expected structures", {
  domains <- OdysseusCostModule:::getCostDomains()

  expect_true(all(c("Condition", "Drug", "Procedure", "Device", "Measurement", "Observation", "Visit") %in% names(domains)))
  expect_identical(OdysseusCostModule:::.getDomainConceptColumn("Drug"), "drug_concept_id")
  expect_error(OdysseusCostModule:::.getDomainConceptColumn("Nope"), "Unknown domain")

  measures <- OdysseusCostModule:::.validCostMeasures()
  expect_true(all(c("total_charge", "total_cost", "paid_by_payer") %in% measures))
})

test_that("validateWindow accepts valid windows and rejects invalid ones", {
  valid_window <- list(
    startWith = "start",
    startOffset = 0,
    endWith = "end",
    endOffset = 30
  )

  expect_invisible(OdysseusCostModule:::.validateWindow(valid_window))

  expect_error(OdysseusCostModule:::.validateWindow(NULL), "must be a list")
  expect_error(OdysseusCostModule:::.validateWindow(list(startWith = "start")), "must be a list")
  expect_error(
    OdysseusCostModule:::.validateWindow(modifyList(valid_window, list(startWith = "middle"))),
    "must be either 'start' or 'end'"
  )
  expect_error(
    OdysseusCostModule:::.validateWindow(modifyList(valid_window, list(endWith = NA_character_))),
    "must be either 'start' or 'end'"
  )
  expect_error(
    OdysseusCostModule:::.validateWindow(modifyList(valid_window, list(startOffset = 1.5))),
    "must be a single integer-like value"
  )
  expect_error(
    OdysseusCostModule:::.validateWindow(modifyList(valid_window, list(endOffset = NA_real_))),
    "must be a single integer-like value"
  )
})

test_that("validateWindow rejects missing required fields", {
  expect_error(
    OdysseusCostModule:::.validateWindow(list(startWith = "start", startOffset = 0, endWith = "end", extra = 1)),
    "missing required fields"
  )
})

test_that("normalizeWindows wraps a single window", {
  w <- list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 30)
  result <- OdysseusCostModule:::.normalizeWindows(w)
  expect_named(result, "default")
  expect_identical(result$default, w)
})

test_that("normalizeWindows accepts named list of windows", {
  w1 <- list(startWith = "start", startOffset = 0, endWith = "start", endOffset = 365)
  w2 <- list(startWith = "start", startOffset = -365, endWith = "start", endOffset = -1)
  result <- OdysseusCostModule:::.normalizeWindows(list(first_year = w1, baseline = w2))
  expect_named(result, c("first_year", "baseline"))
})

test_that("normalizeWindows auto-names unnamed windows", {
  w1 <- list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 0)
  w2 <- list(startWith = "start", startOffset = 0, endWith = "start", endOffset = 30)
  result <- OdysseusCostModule:::.normalizeWindows(list(w1, w2))
  expect_named(result, c("window_1", "window_2"))
})

test_that("normalizeWindows rejects empty or non-list input", {
  expect_error(OdysseusCostModule:::.normalizeWindows(list()), "non-empty list")
  expect_error(OdysseusCostModule:::.normalizeWindows("bad"), "non-empty list")
})

test_that("normalizeWindows validates each window and reports name on error", {
  w_ok  <- list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 0)
  w_bad <- list(startWith = "bad", startOffset = 0, endWith = "end", endOffset = 0)
  expect_error(
    OdysseusCostModule:::.normalizeWindows(list(good = w_ok, broken = w_bad)),
    "Window 'broken'"
  )
})

# ---------- .ocm_can_style / .ocm_can_unicode ----------

test_that(".ocm_can_style respects option override", {
  withr::local_options(list(OdysseusCostModule.useAnsi = TRUE))
  expect_true(OdysseusCostModule:::.ocm_can_style())

  withr::local_options(list(OdysseusCostModule.useAnsi = FALSE))
  expect_false(OdysseusCostModule:::.ocm_can_style())
})

test_that(".ocm_can_unicode respects option override", {
  withr::local_options(list(OdysseusCostModule.useUnicode = TRUE))
  expect_true(OdysseusCostModule:::.ocm_can_unicode())

  withr::local_options(list(OdysseusCostModule.useUnicode = FALSE))
  expect_false(OdysseusCostModule:::.ocm_can_unicode())
})

# ---------- .ocm_style ----------

test_that(".ocm_style applies ANSI codes when enabled", {
  withr::local_options(list(OdysseusCostModule.useAnsi = TRUE))
  styled <- OdysseusCostModule:::.ocm_style("hello", "32")
  expect_match(styled, "\033\\[32m")
  expect_match(styled, "hello")
})

test_that(".ocm_style returns plain text when disabled or NULL code", {
  withr::local_options(list(OdysseusCostModule.useAnsi = FALSE))
  expect_identical(OdysseusCostModule:::.ocm_style("hello", "32"), "hello")

  withr::local_options(list(OdysseusCostModule.useAnsi = TRUE))
  expect_identical(OdysseusCostModule:::.ocm_style("hello", NULL), "hello")
})

# ---------- .ocm_symbols ----------

test_that(".ocm_symbols returns unicode symbols when enabled", {
  withr::local_options(list(OdysseusCostModule.useUnicode = TRUE))
  syms <- OdysseusCostModule:::.ocm_symbols()
  expect_identical(syms$done, "\u2713")
  expect_identical(syms$start, "\u25b6")
})

test_that(".ocm_symbols returns ASCII fallbacks when disabled", {
  withr::local_options(list(OdysseusCostModule.useUnicode = FALSE))
  syms <- OdysseusCostModule:::.ocm_symbols()
  expect_identical(syms$done, "v")
  expect_identical(syms$start, ">")
  expect_identical(syms$warn, "!")
})

# ---------- .ocm_prefix ----------

test_that(".ocm_prefix handles all levels", {
  withr::local_options(list(
    OdysseusCostModule.useAnsi = FALSE,
    OdysseusCostModule.useUnicode = FALSE
  ))
  expect_identical(OdysseusCostModule:::.ocm_prefix("start"), "> ")
  expect_identical(OdysseusCostModule:::.ocm_prefix("warn"), "! ")
  expect_identical(OdysseusCostModule:::.ocm_prefix("step", indent = 2), "    - ")
})

test_that(".ocm_prefix adds ANSI for each level when enabled", {
  withr::local_options(list(
    OdysseusCostModule.useAnsi = TRUE,
    OdysseusCostModule.useUnicode = FALSE
  ))
  # start = bold cyan (1;36)
  expect_match(OdysseusCostModule:::.ocm_prefix("start"), "\033\\[1;36m")
  # step = blue (34)
  expect_match(OdysseusCostModule:::.ocm_prefix("step"), "\033\\[34m")
  # done = green (32)
  expect_match(OdysseusCostModule:::.ocm_prefix("done"), "\033\\[32m")
  # skip = grey (90)
  expect_match(OdysseusCostModule:::.ocm_prefix("skip"), "\033\\[90m")
  # warn = yellow (33)
  expect_match(OdysseusCostModule:::.ocm_prefix("warn"), "\033\\[33m")
})

# ---------- .ocm_message and convenience wrappers ----------

test_that(".ocm_message emits message with correct prefix", {
  withr::local_options(list(
    OdysseusCostModule.quiet = FALSE,
    OdysseusCostModule.useAnsi = FALSE,
    OdysseusCostModule.useUnicode = FALSE
  ))
  expect_message(OdysseusCostModule:::.ocm_message("hello", level = "step"), "- hello")
  expect_message(OdysseusCostModule:::.ocm_message("done!", level = "done"), "v done!")
  expect_message(OdysseusCostModule:::.ocm_message("oops", level = "warn"), "! oops")
})

test_that(".ocm_section emits a rule-formatted message", {
  withr::local_options(list(
    OdysseusCostModule.quiet = FALSE,
    OdysseusCostModule.useAnsi = FALSE,
    OdysseusCostModule.useUnicode = FALSE
  ))
  expect_message(OdysseusCostModule:::.ocm_section("Test"), "-- Test -+")
})

test_that(".ocm_skip emits skip-level message", {
  withr::local_options(list(
    OdysseusCostModule.quiet = FALSE,
    OdysseusCostModule.useAnsi = FALSE,
    OdysseusCostModule.useUnicode = FALSE
  ))
  expect_message(OdysseusCostModule:::.ocm_skip("skipped"), "o skipped")
})

# ---------- .ocm_rule ----------

test_that(".ocm_rule returns unicode rule when enabled", {
  withr::local_options(list(OdysseusCostModule.useUnicode = TRUE))
  rule <- OdysseusCostModule:::.ocm_rule("Hello")
  expect_match(rule, "^== Hello =+$")
})

test_that(".ocm_rule returns ASCII rule when disabled", {
  withr::local_options(list(OdysseusCostModule.useUnicode = FALSE))
  rule <- OdysseusCostModule:::.ocm_rule("Hello")
  expect_match(rule, "^-- Hello -+$")
})

# ---------- .persistTempTable ----------

test_that(".persistTempTable executes SQL and logs message", {
  conn <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$sqls <- character()

  local_namespace_mock("DatabaseConnector", "renderTranslateExecuteSql", function(connection, sql, ...) {
    state$sqls <- c(state$sqls, sql)
    invisible(NULL)
  })

  withr::local_options(list(OdysseusCostModule.quiet = TRUE))

  OdysseusCostModule:::.persistTempTable(
    connection = conn,
    workDatabaseSchema = "work_schema",
    tableName = "my_table"
  )

  expect_true(any(grepl("SELECT \\* INTO work_schema\\.my_table FROM #my_table", state$sqls)))
  expect_true(any(grepl("CREATE INDEX", state$sqls)))
})

# ---------- .dropTempTables ----------

test_that(".dropTempTables drops specified tables plus defaults", {
  conn <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$dropped <- character()

  local_namespace_mock("DatabaseConnector", "renderTranslateExecuteSql", function(connection, sql, ...) {
    state$dropped <- c(state$dropped, sql)
    invisible(NULL)
  })

  OdysseusCostModule:::.dropTempTables(conn, c("#extra_table"))

  expect_true(any(grepl("#cost_aw_tmp", state$dropped)))
  expect_true(any(grepl("#person_time_tmp", state$dropped)))
  expect_true(any(grepl("#extra_table", state$dropped)))
})

test_that(".dropTempTables issues warning on drop error", {
  conn <- fake_connection()

  local_namespace_mock("DatabaseConnector", "renderTranslateExecuteSql", function(connection, sql, ...) {
    stop("table not found")
  })

  expect_warning(
    OdysseusCostModule:::.dropTempTables(conn, c("#bad_table")),
    "Could not drop"
  )
})

# ---------- check_installed ----------

test_that("check_installed returns TRUE for base packages", {
  expect_true(OdysseusCostModule:::check_installed("base"))
  expect_true(OdysseusCostModule:::check_installed("stats"))
})

test_that("check_installed errors for non-existent packages", {
  expect_error(
    OdysseusCostModule:::check_installed("nonExistentPackage99z"),
    "not installed"
  )
})

test_that("check_installed handles version checks", {
  expect_true(OdysseusCostModule:::check_installed("base", version = "0.0.1"))
})

test_that("check_installed errors on bad version requirement", {
  expect_error(
    OdysseusCostModule:::check_installed("base", version = "999.999.999"),
    "needs|update"
  )
})

test_that("check_installed invokes custom action for missing packages", {
  action_called <- FALSE
  result <- OdysseusCostModule:::check_installed(
    "nonExistentPackage99z",
    action = function(pkg, version, compare, reason) {
      action_called <<- TRUE
    }
  )
  expect_true(action_called)
  expect_false(result)
})

test_that("check_installed handles multiple packages", {
  expect_true(OdysseusCostModule:::check_installed(c("base", "stats")))
})

test_that("check_installed includes reason in error message", {
  expect_error(
    OdysseusCostModule:::check_installed("nonExistentPackage99z", reason = "for testing"),
    "for testing"
  )
})

test_that("check_installed rejects non-character pkg", {
  expect_error(OdysseusCostModule:::check_installed(123), "must be a character vector")
  expect_error(OdysseusCostModule:::check_installed(character(0)), "must be a character vector")
})

test_that("check_installed handles comparison operators", {
  expect_true(OdysseusCostModule:::check_installed("base", version = "0.0.1", compare = ">="))
  expect_true(OdysseusCostModule:::check_installed("base", version = "0.0.1", compare = "!="))
  expect_error(OdysseusCostModule:::check_installed("base", version = "999.0.0", compare = "=="), "update")
  expect_error(
    OdysseusCostModule:::check_installed("base", version = "0.0.1", compare = "%%"),
    "Unknown comparison"
  )
})

test_that("check_installed reports both missing and outdated", {
  action_pkgs <- NULL
  OdysseusCostModule:::check_installed(
    c("nonExistentPkg99z", "base"),
    version = c(NA, "999.999.999"),
    action = function(pkg, ...) { action_pkgs <<- pkg }
  )
  expect_true("nonExistentPkg99z" %in% action_pkgs)
  expect_true("base" %in% action_pkgs)
})