# --- zarrs_get_subset: Rust read path tests ---

test_that("zarrs retrieves 1D float64 array", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_1d_")
  z <- zarr_create(store = d, shape = 10L, chunks = 5L, dtype = "<f8")
  z$set_item("...", as.double(1:10))

  result <- zarrs_get_subset(d, "", list(c(0L, 10L)), NULL)
  expect_equal(result$data, as.double(1:10))
  expect_equal(result$shape, 10L)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs retrieves 2D integer array slice", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_2d_")
  z <- zarr_create(store = d, shape = c(10L, 5L), chunks = c(5L, 5L), dtype = "<i4")
  z$set_item("...", array(1:50, dim = c(10, 5)))

  # Read rows 2-5, all columns (0-based: 2:5 x 0:5)
  result <- zarrs_get_subset(d, "", list(c(2L, 5L), c(0L, 5L)), NULL)
  expect_equal(result$shape, c(3L, 5L))
  expect_type(result$data, "integer")
  expect_equal(length(result$data), 15L)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs retrieves V3 array", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_v3_")
  store <- DirectoryStore$new(d)
  g <- zarr_create_group(store = store, zarr_format = 3L)
  a <- g$create_dataset("arr", shape = 6L, dtype = "<f8", compressor = NA)
  a$set_item("...", as.double(11:16))

  result <- zarrs_get_subset(d, "arr", list(c(0L, 6L)), NULL)
  expect_equal(result$data, as.double(11:16))
  expect_equal(result$shape, 6L)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs retrieves int16 array widened to integer", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_i16_")
  z <- zarr_create(store = d, shape = 5L, chunks = 5L, dtype = "<i2")
  z$set_item("...", 1:5)

  result <- zarrs_get_subset(d, "", list(c(0L, 5L)), NULL)
  expect_type(result$data, "integer")
  expect_equal(result$data, 1:5)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs retrieves uint8 array widened to integer", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_u8_")
  z <- zarr_create(store = d, shape = 5L, chunks = 5L, dtype = "|u1")
  z$set_item("...", 1:5)

  result <- zarrs_get_subset(d, "", list(c(0L, 5L)), NULL)
  expect_type(result$data, "integer")
  expect_equal(result$data, 1:5)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs returns fill values for unwritten chunks", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_fill_")
  z <- zarr_create(store = d, shape = 10L, chunks = 5L, dtype = "<f8",
                   fill_value = 42.0)

  result <- zarrs_get_subset(d, "", list(c(0L, 10L)), NULL)
  expect_equal(result$data, rep(42.0, 10))

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("zarrs errors on unsupported dtype (string)", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  # zarrs_get_subset should error on string arrays
  # (we don't have a convenient way to create a string zarr array from R,
  #  so test via dtype_family returning None — the error path)
  # Instead, test that the dispatch function correctly falls back.
  # Use a MemoryStore to test can_use_zarrs returning FALSE.
  ms <- MemoryStore$new()
  z <- zarr_create(store = ms, shape = 5L, chunks = 5L, dtype = "<f8")
  indexer <- BasicIndexer$new(list(slice(1L, 5L)), z)
  expect_false(can_use_zarrs(indexer, ms))
})

test_that("concurrent_target option is honored", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_ret_ct_")
  z <- zarr_create(store = d, shape = 10L, chunks = 5L, dtype = "<f8")
  z$set_item("...", as.double(1:10))

  result <- zarrs_get_subset(d, "", list(c(0L, 10L)), 1L)
  expect_equal(result$data, as.double(1:10))

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

# --- R-side dispatch tests ---

test_that("can_use_zarrs returns FALSE for MemoryStore", {
  ms <- MemoryStore$new()
  z <- zarr_create(store = ms, shape = 5L, chunks = 5L, dtype = "<f8")
  indexer <- BasicIndexer$new(list(slice(1L, 5L)), z)
  expect_false(can_use_zarrs(indexer, ms))
})

test_that("can_use_zarrs returns FALSE when zarrs unavailable", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_disp_")
  z <- zarr_create(store = d, shape = 5L, chunks = 5L, dtype = "<f8")
  ds <- DirectoryStore$new(d)
  indexer <- BasicIndexer$new(list(slice(1L, 5L)), z)

  old <- .pizzarr_env$zarrs_available
  .pizzarr_env$zarrs_available <- FALSE
  on.exit(.pizzarr_env$zarrs_available <- old)
  expect_false(can_use_zarrs(indexer, ds))

  unlink(d, recursive = TRUE)
})

test_that("selection_to_ranges converts indexer dims", {
  ms <- MemoryStore$new()
  z <- zarr_create(store = ms, shape = c(10L, 20L), chunks = c(5L, 10L),
                   dtype = "<f8")
  indexer <- BasicIndexer$new(list(slice(2L, 8L), slice(5L, 15L)), z)
  ranges <- selection_to_ranges(indexer)

  expect_length(ranges, 2)
  # slice(2L, 8L) is 1-based; SliceDimIndexer stores 0-based start=1, stop=8
  expect_equal(ranges[[1]], c(1L, 8L))
  # slice(5L, 15L) is 1-based; SliceDimIndexer stores 0-based start=4, stop=15
  expect_equal(ranges[[2]], c(4L, 15L))
})

test_that("can_use_zarrs accepts IntDimIndexer (manual construction)", {
  # IntDimIndexer is only created when normalize_list_selection uses
  # convert_integer_selection_to_slices=FALSE (not the default get_item path).
  # Test the dispatch function handles it correctly anyway.
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_int_dim_")
  z <- zarr_create(store = d, shape = c(10L, 5L), chunks = c(5L, 5L),
                   dtype = "<f8")
  ds <- DirectoryStore$new(d)
  # Manually build an indexer with IntDimIndexer on dim 1
  int_di <- IntDimIndexer$new(3L, 10L, 5L)
  slice_di <- SliceDimIndexer$new(slice(1L, 5L), 5L, 5L)
  idx <- list()
  idx$dim_indexers <- list(int_di, slice_di)
  idx$shape <- list(5L)
  class(idx) <- "BasicIndexer"
  expect_true(can_use_zarrs(idx, ds))

  unlink(d, recursive = TRUE)
})

test_that("selection_to_ranges handles IntDimIndexer", {
  # IntDimIndexer stores 0-based dim_sel from normalize_integer_selection.
  # 3L -> dim_sel=3 (0-based) -> range [3, 4)
  int_di <- IntDimIndexer$new(3L, 10L, 5L)
  slice_di <- SliceDimIndexer$new(slice(5L, 15L), 20L, 10L)
  idx <- list()
  idx$dim_indexers <- list(int_di, slice_di)
  class(idx) <- "BasicIndexer"
  ranges <- selection_to_ranges(idx)

  expect_length(ranges, 2)
  expect_equal(ranges[[1]], c(3L, 4L))
  # slice(5L, 15L) is 1-based; SliceDimIndexer stores 0-based start=4, stop=15
  expect_equal(ranges[[2]], c(4L, 15L))
})

test_that("zarrs and R-native read produce identical results", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_compare_")
  z <- zarr_create(store = d, shape = c(10L, 8L), chunks = c(5L, 4L),
                   dtype = "<f8")
  data <- array(as.double(1:80), dim = c(10, 8))
  z$set_item("...", data)

  # Read via zarrs
  zarrs_result <- zarrs_get_subset(d, "", list(c(2L, 7L), c(1L, 6L)), NULL)

  # Read via R-native
  z2 <- zarr_open(store = d)
  r_result <- z2$get_item(list(slice(3L, 7L), slice(2L, 6L)))

  # zarrs returns flat data; R-native returns NestedArray
  expect_equal(length(zarrs_result$data), length(r_result$data))

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

# --- End-to-end dispatch: ZarrArray$get_item via zarrs ---

test_that("ZarrArray$get_item dispatches to zarrs for eligible selection", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_e2e_")
  z <- zarr_create(store = d, shape = 10L, chunks = 5L, dtype = "<f8")
  z$set_item("...", as.double(1:10))

  # Re-open to get a DirectoryStore-backed array
  z2 <- zarr_open(store = d)
  result <- z2$get_item("...")
  expect_equal(as.double(result$data), as.double(1:10))

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("ZarrArray$get_item dispatches to zarrs for 2D slice", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_e2e_2d_")
  z <- zarr_create(store = d, shape = c(10L, 5L), chunks = c(5L, 5L),
                   dtype = "<i4")
  z$set_item("...", array(1:50, dim = c(10, 5)))

  z2 <- zarr_open(store = d)
  # Slice rows 3-7 (1-based), all cols
  result <- z2$get_item(list(slice(3L, 7L), slice(1L, 5L)))
  expect_equal(dim(result$data), c(5, 5))

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})

test_that("ZarrArray$get_item dispatches to zarrs for scalar + slice", {
  skip_if(!.pizzarr_env$zarrs_available, "zarrs backend not available")
  d <- tempfile("zarrs_e2e_scalar_")
  z <- zarr_create(store = d, shape = c(10L, 5L), chunks = c(5L, 5L),
                   dtype = "<f8")
  data <- array(as.double(1:50), dim = c(10, 5))
  z$set_item("...", data)

  z2 <- zarr_open(store = d)
  # 3L (0-based index 3) selects the 4th row; get_item converts to slice(3,4)
  # so output shape keeps the length-1 dim: c(1, 5)
  zarrs_result <- z2$get_item(list(3L, slice(1L, 5L)))
  expect_equal(dim(zarrs_result$data), c(1L, 5L))
  # Compare with R-native
  old <- .pizzarr_env$zarrs_available
  .pizzarr_env$zarrs_available <- FALSE
  r_result <- z2$get_item(list(3L, slice(1L, 5L)))
  .pizzarr_env$zarrs_available <- old
  expect_equal(zarrs_result$data, r_result$data)

  zarrs_close_store(d)
  unlink(d, recursive = TRUE)
})