test_that("computeCostByDomain validates domains and executes SQL for valid inputs", {
  connection <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$sql <- character()

  expect_error(
    OdysseusCostModule::computeCostByDomain(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      domainsToUse = "BadDomain"
    ),
    "Invalid domains requested"
  )

  local_namespace_mock("SqlRender", "loadRenderTranslateSql", function(...) paste(c(list(...)), collapse = "|"))
  local_namespace_mock("DatabaseConnector", "executeSql", function(connection, sql) {
    state$sql <- c(state$sql, sql)
    invisible(NULL)
  })

  expect_no_error(
    OdysseusCostModule::computeCostByDomain(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      costMeasures = c("total_charge", "total_cost"),
      domainsToUse = c("Drug", "Visit")
    )
  )

  expect_length(state$sql, 4)
  expect_true(all(grepl("OdysseusCostModule", state$sql, fixed = TRUE)))
})

test_that("computeOverallCost renders one statement per domain and measure", {
  connection <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$load_calls <- list()
  state$sql <- character()

  local_namespace_mock("SqlRender", "loadRenderTranslateSql", function(...) {
    state$load_calls[[length(state$load_calls) + 1]] <- list(...)
    "domain_sql"
  })
  local_namespace_mock("DatabaseConnector", "executeSql", function(connection, sql) {
    state$sql <- c(state$sql, sql)
    invisible(NULL)
  })

  expect_no_error(
    OdysseusCostModule::computeOverallCost(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      costMeasures = c("total_charge", "total_cost")
    )
  )

  expect_equal(length(state$load_calls), length(OdysseusCostModule:::getCostDomains()) * 2)
  expect_equal(length(state$sql), length(OdysseusCostModule:::getCostDomains()) * 2)
  expect_true(all(vapply(state$load_calls, `[[`, character(1), "sqlFilename") == "ComputeOverallCost.sql"))
})

test_that("computeCostStatistics builds metrics and distribution SQL", {
  connection <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$load_calls <- list()
  state$executed <- character()

  local_namespace_mock("SqlRender", "loadRenderTranslateSql", function(...) {
    state$load_calls[[length(state$load_calls) + 1]] <- list(...)
    sprintf("sql_%d", length(state$load_calls))
  })
  local_namespace_mock("DatabaseConnector", "executeSql", function(connection, sql) {
    state$executed <- c(state$executed, sql)
    invisible(NULL)
  })

  expect_no_error(
    OdysseusCostModule::computeCostStatistics(
      connection = connection,
      workDatabaseSchema = "work"
    )
  )

  expect_length(state$load_calls, 2)
  expect_length(state$executed, 1)
  expect_match(state$executed[[1]], "sql_1")
  expect_match(state$executed[[1]], "sql_2")
  expect_identical(
    vapply(state$load_calls, `[[`, character(1), "sqlFilename"),
    c("CostMetrics.sql", "ComputeCostStatistics.sql")
  )
})

test_that("computeCostByConceptSet validates inputs and executes domain SQL", {
  connection <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$sql <- character()

  expect_error(
    OdysseusCostModule::computeCostByConceptSet(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      conceptSets = list()
    ),
    "must be provided"
  )

  local_namespace_mock("OdysseusCostModule", "buildConceptSetQueries", function(...) list(a = "select 1", b = "select 2"))
  local_namespace_mock("OdysseusCostModule", "createConceptSetTempTable", function(...) invisible("#concept_sets"))
  local_namespace_mock("SqlRender", "loadRenderTranslateSql", function(...) "concept_sql")
  local_namespace_mock("DatabaseConnector", "executeSql", function(connection, sql) {
    state$sql <- c(state$sql, sql)
    invisible(NULL)
  })
  local_namespace_mock("DatabaseConnector", "renderTranslateExecuteSql", function(...) invisible(NULL))

  expect_no_error(
    OdysseusCostModule::computeCostByConceptSet(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      conceptSets = list(example = list(items = list(list(concept = list(CONCEPT_ID = 1))))),
      costMeasures = c("total_charge", "total_cost")
    )
  )

  expect_equal(length(state$sql), length(OdysseusCostModule:::getCostDomains()) * 2 * 2)

  expect_error(
    OdysseusCostModule::computeCostByConceptSet(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      conceptSets = list(example = list(items = list(list(concept = list(CONCEPT_ID = 1))))),
      domainsToUse = "BadDomain"
    ),
    "domainsToUse contains invalid domain"
  )

  local_namespace_mock("OdysseusCostModule", "buildConceptSetQueries", function(...) list(a = "", b = ""))
  expect_error(
    OdysseusCostModule::computeCostByConceptSet(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      workDatabaseSchema = "work",
      conceptSets = list(example = list(items = list(list(concept = list(CONCEPT_ID = 1)))))
    ),
    "resolved to empty queries"
  )
})

test_that("createAnalysisWindows, calculatePersonTime, and disease cost render expected SQL", {
  connection <- fake_connection()
  state <- new.env(parent = emptyenv())
  state$args <- list()
  state$executed <- character()

  local_namespace_mock("SqlRender", "loadRenderTranslateSql", function(...) {
    state$args[[length(state$args) + 1]] <- list(...)
    sprintf("sql_%d", length(state$args))
  })
  local_namespace_mock("DatabaseConnector", "executeSql", function(connection, sql) {
    state$executed <- c(state$executed, sql)
    invisible(NULL)
  })
  local_namespace_mock("OdysseusCostModule", "buildConceptSetQuery", function(...) "select concept_id from cdm.CONCEPT")

  expect_no_error(
    OdysseusCostModule:::.createAnalysisWindows(
      connection = connection,
      cdmDatabaseSchema = "cdm",
      cohortDatabaseSchema = "cohort",
      cohortTable = "cohort_table",
      cohortIds = c(1, 2),
      window = list(startWith = "start", startOffset = 0, endWith = "end", endOffset = 30)
    )
  )
  expect_no_error(OdysseusCostModule:::.calculatePersonTime(connection = connection))

  expect_length(state$args, 2)
  expect_identical(
    vapply(state$args, `[[`, character(1), "sqlFilename"),
    c("CreateAnalysisWindows.sql", "CalculatePersonTime.sql")
  )
  expect_identical(state$executed, c("sql_1", "sql_2"))

})