test_that("DistanceMatrix dispatches row-wise BIDistances routes", {
  Data = rbind(
    Case1 = c(0, 1, 2),
    Case2 = c(1, 2, 4),
    Case3 = c(2, 1, 3),
    Case4 = c(4, 3, 1)
  )

  fractional = DistanceMatrix(Data, "Fractional_Distance", p = 0.5)
  expect_equal(fractional, Fractional_Distance(Data, p = 0.5))
  expect_equal(dim(fractional), c(nrow(Data), nrow(Data)))
  expect_identical(rownames(fractional), rownames(Data))

  shared = DistanceMatrix(
    Data,
    "SharedNeighbor_Distance",
    k = 2,
    NThreads = 1,
    ComputationInR = TRUE
  )
  reference_shared = SharedNeighbor_Distance(
    Data,
    k = 2,
    NThreads = 1,
    ComputationInR = TRUE
  )
  expect_equal(shared, reference_shared)
  Gene2GO = rbind(
    Gene1 = c(1, 0, 2),
    Gene2 = c(0, 1, 1),
    Gene3 = c(1, 1, 0)
  )
  tfidf = DistanceMatrix(Gene2GO, "Tfidf_Distance")
  expect_equal(tfidf, Tfidf_Distance(Gene2GO)$Distance)
  expect_equal(
    DistanceMatrix(Gene2GO, "Tfidf_dist"),
    tfidf
  )
})

test_that("DistanceMatrix dispatches column-wise time-series routes", {
  Data = cbind(
    Series1 = c(1, 2, 3, 4, 5),
    Series2 = c(1, 2, 3, 4, 7),
    Series3 = c(2, 2, 3, 5, 8)
  )

  observed = DistanceMatrix(Data, "MSMD_Distance", ParameterC = 1)
  expect_equal(dim(observed), c(ncol(Data), ncol(Data)))
  expect_identical(rownames(observed), colnames(Data))
  expect_equal(
    diag(observed),
    setNames(rep(0, ncol(Data)), colnames(Data))
  )
  expect_equal(observed, t(observed))
})

test_that("time-variable requirements are reported by DistanceMatrix", {
  Data = cbind(Series1 = 1:4, Series2 = c(1, 2, 3, 5))

  expect_error(
    DistanceMatrix(Data, "TWED_Distance"),
    "requires explicit Time1 and Time2"
  )
  expect_error(
    DistanceMatrix(Data, "DTW_Distance", Time = 1:4),
    "does not accept a separate time variable"
  )
  expect_error(
    DistanceMatrix(Data, "MSMD_Distance", ParameterC = 1, Time = 1:4),
    "does not accept a separate time variable"
  )
})

test_that("Gini routing agrees with the direct function", {
  skip_if_not_installed("ineq")

  Data = rbind(
    Case1 = c(1, 0, 2),
    Case2 = c(0, 1, 1),
    Case3 = c(1, 1, 0)
  )
  expected = Gini_Distance(Data)
  expect_equal(DistanceMatrix(Data, "Gini_Distance"), expected)
})

test_that("Jaccard routing agrees with the direct function", {
  Data = rbind(
    Case1 = c(1, 0, 2),
    Case2 = c(0, 1, 1),
    Case3 = c(1, 1, 0)
  )
  expect_equal(
    DistanceMatrix(Data, "Jaccard_Distance"),
    Jaccard_Distance(Data)
  )
})

test_that("Wasserstein routing agrees with the direct function", {
  skip_if_not_installed("transport")

  Data = rbind(
    Case1 = c(0, 1, 2),
    Case2 = c(1, 2, 3),
    Case3 = c(0, 0, 4)
  )
  observed = DistanceMatrix(Data, "Wasserstein_Distance", p = 1)
  expect_equal(observed, Wasserstein_Distance(Data, p = 1))
})

test_that("DTW routing compares columns without a time variable", {
  skip_if_not_installed("dtw")
  skip_if_not_installed("proxy")

  Data = cbind(
    Series1 = c(1, 2, 3, 4),
    Series2 = c(1, 2, 3, 5),
    Series3 = c(2, 2, 4, 5)
  )
  observed = DistanceMatrix(Data, "DTW_Distance")
  reference = DTW_Distance(Data)
  expect_equal(observed, reference)
  expect_equal(dim(observed), c(ncol(Data), ncol(Data)))
})

test_that("Endres-Schindelin routing compares columns", {
  skip_on_cran()
  skip_if_not_installed("ScatterDensity")

  set.seed(123)
  Data = cbind(
    Variable1 = rnorm(32),
    Variable2 = rnorm(32, mean = 1),
    Variable3 = rnorm(32, mean = 2)
  )
  observed = DistanceMatrix(
    Data,
    "EndresSchindelin_Distance",
    ncores = 1
  )
  reference = EndresSchindelin_Distance(Data, ncores = 1)
  expect_equal(observed, reference)
  expect_equal(dim(observed), c(ncol(Data), ncol(Data)))
})


test_that("legacy BIDistances method names are rejected except Tfidf_dist", {
  Data = rbind(c(0, 1, 2), c(1, 2, 3), c(2, 1, 0))
  legacy = c(
    "FractionalDistance", "SharedNeighborDistance", "GiniDist",
    "CosinusDistance", "WassersteinDist", "EndresSchindelinDistance",
    "DTWdistance", "msmd"
  )
  for (method in legacy) {
    expect_error(DistanceMatrix(Data, method), "Unknown distance method|not available")
  }
})

test_that("cosine uses parallelDist and Cosine_Distance uses BIDistances", {
  Data = rbind(c(1, 0), c(0, 1), c(1, 1))
  expect_equal(
    DistanceMatrix(Data, "cosine"),
    as.matrix(parallelDist::parDist(Data, method = "cosine"))
  )
  expect_equal(
    DistanceMatrix(Data, "Cosine_Distance"),
    Cosine_Distance(Data)
  )
})