# ---------- planAnalysis: defaults and class -----------------------------------

test_that("planAnalysis returns CostAnalysisPlan with defaults", {
  plan <- planAnalysis()
  expect_s3_class(plan, "CostAnalysisPlan")
  expect_identical(plan$which, c("overall", "domain", "conceptSet"))
  expect_true("total_charge" %in% plan$costMeasures)
  expect_true("total_cost" %in% plan$costMeasures)
  expect_true(plan$excludeNegativeCosts)
  expect_false(plan$excludeZeroCostPatients)
  expect_null(plan$domainsToUse)
  expect_true(is.list(plan$conceptSets))
  expect_null(plan$conceptSetDomains)
  expect_null(plan$analysisWindows)
})

# ---------- overall sub-plan --------------------------------------------------

test_that("planAnalysis with only overall tier enabled", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, costMeasures = "total_paid"),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_identical(plan$which, "overall")
  expect_identical(plan$costMeasures, "total_paid")
})

test_that("planAnalysis overall defaults NULL costMeasures to total_charge/total_cost", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, costMeasures = NULL),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_identical(plan$costMeasures, c("total_charge", "total_cost"))
})

test_that("planAnalysis overall rejects invalid cost measures", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = TRUE, costMeasures = "bad_measure"),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(compute = FALSE)
    ),
    "useOverallCost.*invalid"
  )
})

test_that("planAnalysis overall excludeZeroCostPatients propagates", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, excludeZeroCostPatients = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_true(plan$excludeZeroCostPatients)
})

test_that("planAnalysis overall excludeNegativeCosts defaults TRUE", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_true(plan$excludeNegativeCosts)
})

test_that("planAnalysis overall excludeNegativeCosts can be FALSE", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, excludeNegativeCosts = FALSE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_false(plan$excludeNegativeCosts)
})

# ---------- domain sub-plan ---------------------------------------------------

test_that("planAnalysis with only domain tier enabled", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = TRUE, domainsToUse = c("Drug", "Visit")),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_identical(plan$which, "domain")
  expect_identical(plan$domainsToUse, c("Drug", "Visit"))
})

test_that("planAnalysis domain rejects invalid domains", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = TRUE, domainsToUse = "Fake"),
      useConceptSetCost = list(compute = FALSE)
    ),
    "useDomainCost.*invalid domain"
  )
})

test_that("planAnalysis domain rejects invalid cost measures", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = TRUE, costMeasures = "nope"),
      useConceptSetCost = list(compute = FALSE)
    ),
    "useDomainCost.*invalid"
  )
})

test_that("planAnalysis domain defaults NULL costMeasures", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = TRUE, costMeasures = NULL),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_identical(plan$costMeasures, c("total_charge", "total_cost"))
})

# ---------- concept-set sub-plan ----------------------------------------------

test_that("planAnalysis with only conceptSet tier enabled", {
  cs <- list(diabetes = list(items = list(
    list(concept = list(CONCEPT_ID = 201820L), includeDescendants = TRUE)
  )))
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = TRUE, conceptSets = cs)
  )
  expect_identical(plan$which, "conceptSet")
  expect_identical(names(plan$conceptSets), "diabetes")
})

test_that("planAnalysis conceptSet rejects NULL/empty concept sets", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(compute = TRUE, conceptSets = NULL)
    ),
    "non-empty named list"
  )
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(compute = TRUE, conceptSets = list())
    ),
    "non-empty named list"
  )
})

test_that("planAnalysis conceptSet rejects unnamed concept sets", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE,
        conceptSets = list(list(items = list(
          list(concept = list(CONCEPT_ID = 1L))
        )))
      )
    ),
    "must be named"
  )
})

test_that("planAnalysis conceptSet rejects missing items", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE,
        conceptSets = list(bad = list(noitems = 1))
      )
    ),
    "must be a list with an 'items' element"
  )
})

test_that("planAnalysis conceptSet rejects missing CONCEPT_ID", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE,
        conceptSets = list(bad = list(items = list(
          list(concept = list())
        )))
      )
    ),
    "must contain concept\\$CONCEPT_ID"
  )
})

test_that("planAnalysis conceptSet rejects non-numeric CONCEPT_ID", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE,
        conceptSets = list(bad = list(items = list(
          list(concept = list(CONCEPT_ID = "abc"))
        )))
      )
    ),
    "must be numeric"
  )
})

test_that("planAnalysis conceptSet rejects invalid cost measures", {
  cs <- list(a = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE, conceptSets = cs, costMeasures = "bad"
      )
    ),
    "useConceptSetCost.*invalid"
  )
})

test_that("planAnalysis conceptSet rejects invalid domains", {
  cs <- list(a = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(
        compute = TRUE, conceptSets = cs, domains = "NotADomain"
      )
    ),
    "useConceptSetCost.*invalid domain"
  )
})

test_that("planAnalysis conceptSet domains propagate", {
  cs <- list(a = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(
      compute = TRUE, conceptSets = cs, domains = c("Drug", "Condition")
    )
  )
  expect_identical(plan$conceptSetDomains, c("Drug", "Condition"))
})

# ---------- all compute = FALSE -----------------------------------------------

test_that("planAnalysis errors when all tiers are disabled", {
  expect_error(
    planAnalysis(
      useOverallCost    = list(compute = FALSE),
      useDomainCost     = list(compute = FALSE),
      useConceptSetCost = list(compute = FALSE)
    ),
    "At least one"
  )
})

# ---------- combined tiers / deduplication ------------------------------------

test_that("planAnalysis deduplicates cost measures across tiers", {
  cs <- list(a = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, costMeasures = "total_charge"),
    useDomainCost     = list(compute = TRUE, costMeasures = "total_charge"),
    useConceptSetCost = list(
      compute = TRUE, conceptSets = cs, costMeasures = "total_charge"
    )
  )
  expect_identical(plan$costMeasures, "total_charge")
  expect_identical(plan$which, c("overall", "domain", "conceptSet"))
})

test_that("planAnalysis excludeNegative is TRUE if any tier requests it", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, excludeNegativeCosts = FALSE),
    useDomainCost     = list(compute = TRUE, excludeNegativeCosts = TRUE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_true(plan$excludeNegativeCosts)
})

# ---------- analysisWindows ---------------------------------------------------

test_that("planAnalysis stores single analysisWindow", {
  w <- list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 0)
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE),
    analysisWindows   = w
  )
  expect_named(plan$analysisWindows, "default")
  expect_identical(plan$analysisWindows$default, w)
})

test_that("planAnalysis stores multiple analysisWindows", {
  ws <- list(
    baseline   = list(startWith = "start", startOffset = -365,
                      endWith = "start", endOffset = -1),
    first_year = list(startWith = "start", startOffset = 0,
                      endWith = "start", endOffset = 365)
  )
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE),
    analysisWindows   = ws
  )
  expect_named(plan$analysisWindows, c("baseline", "first_year"))
})

# ---------- print.CostAnalysisPlan --------------------------------------------

test_that("print.CostAnalysisPlan outputs expected text", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE, costMeasures = "total_charge"),
    useDomainCost     = list(compute = TRUE, domainsToUse = c("Drug", "Visit"),
                             costMeasures = "total_charge"),
    useConceptSetCost = list(compute = FALSE)
  )
  out <- capture.output(print(plan))
  expect_true(any(grepl("Cost Analysis Plan", out)))
  expect_true(any(grepl("overall, domain", out)))
  expect_true(any(grepl("total_charge", out)))
  expect_true(any(grepl("Drug, Visit", out)))
  expect_true(any(grepl("set at execution time", out)))
})

test_that("print.CostAnalysisPlan shows concept sets and CS domains", {
  cs <- list(diab = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(
      compute = TRUE, conceptSets = cs, domains = "Drug"
    )
  )
  out <- capture.output(print(plan))
  expect_true(any(grepl("diab", out)))
  expect_true(any(grepl("CS domains.*Drug", out)))
})

test_that("print.CostAnalysisPlan shows 'CS domains: all' when no CS domains filter", {
  cs <- list(diab = list(items = list(list(concept = list(CONCEPT_ID = 1L)))))
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = TRUE, conceptSets = cs)
  )
  out <- capture.output(print(plan))
  expect_true(any(grepl("CS domains.*all", out)))
})

test_that("print.CostAnalysisPlan shows windows when set", {
  w <- list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 0)
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE),
    analysisWindows   = w
  )
  out <- capture.output(print(plan))
  expect_true(any(grepl("Windows.*default", out)))
})

test_that("print.CostAnalysisPlan shows 'Domains: all' when domainsToUse is NULL", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = FALSE),
    useDomainCost     = list(compute = TRUE, domainsToUse = NULL),
    useConceptSetCost = list(compute = FALSE)
  )
  out <- capture.output(print(plan))
  expect_true(any(grepl("Domains.*all", out)))
})

test_that("print.CostAnalysisPlan returns invisibly", {
  plan <- planAnalysis(
    useOverallCost    = list(compute = TRUE),
    useDomainCost     = list(compute = FALSE),
    useConceptSetCost = list(compute = FALSE)
  )
  expect_invisible(print(plan))
})