describe("gen_df", {
  it("can give a table of exact height", {
    forall(
      gen.element(0:6) |>
        gen.and_then(\(n) list(
          gen.pure(n),
          gen_df(n, 7, minrow = n, remove_dup_rows = FALSE)
        )),
      onRight(nrow) %>>% (uncurry(expect_identical))
    )
  })
  it("can give a table of exact width", {
    forall(
      gen.element(0:7) |>
        gen.and_then(\(n) list(
          gen.pure(n),
          gen_df(6, n, mincol = n, remove_dup_rows = FALSE)
        )),
      onRight(ncol) %>>% (uncurry(expect_identical))
    )
  })
  it("can generate a tibble without name failure", {
    forall(
      gen.df_fixed_ranges("logical", "..1", 2, TRUE, "tibble"),
      expect_silent
    )
  })
})

describe("gen.float_coincide", {
  it("adds offset that disappear in rounding", {
    forall(
      list(
        gen.numeric(c(1, 0)),
        gen.element(c(7:1, NA_integer_))
      ) |>
        gen.and_then(uncurry(\(x, digits) list(
          gen.pure(x),
          gen.pure(digits),
          gen.float_coincide(rep(x, 50), digits = digits)
        ))),
      \(x, digits, y) {
        expect_false(!anyDuplicated(coarsen_if_float(c(x, y), digits)))
      },
      curry = TRUE
    )
  })
})

describe("gen_flat_deps_fixed_names", {
  it("generates valid", {
    forall(gen_flat_deps_fixed_names(7, 20, to = 20L), expect_valid_functional_dependency)
  })
  test_that("generates valid", {
    forall(gen_flat_deps(7, 20, to = 20L), expect_valid_functional_dependency)
  })
})

describe("gen.relation_schema", {
  it("generates valid relation schemas", {
    forall(
      gen.element(c(FALSE, TRUE)) |>
        gen.and_then(\(sek) list(
          sek,
          gen.relation_schema(letters[1:6], 0, 8, single_empty_key = sek)
        )),
      \(sek, rs) expect_valid_relation_schema(rs, single_empty_key = sek),
      curry = TRUE
    )
  })
})

describe("gen.relation_schema_empty_keys", {
  it("generates valid relation schemas, enough empty keys", {
    forall(
      gen.element(0:4) |>
        gen.and_then(\(from) {
          gen.element(0:from) |>
            gen.and_then(\(me) {
              list(
                gen.pure(from),
                gen.pure(me),
                gen.relation_schema_empty_keys(
                  letters[1:6],
                  from = from,
                  to = 8,
                  min_empty = me
                )
              )
            })
        }),
      \(from, me, rs) {
        expect_valid_relation_schema(rs)
        expect_gte(
          sum(vapply(keys(rs), identical, logical(1), list(character()))),
          me
        )
      },
      curry = TRUE
    )
  })
})

describe("gen.database_schema", {
  it("generates valid database schemas", {
    forall(
      gen.element(c(FALSE, TRUE)) |>
        gen.list(of = 3) |>
        gen.and_then(uncurry(\(sek, san, skp) list(
          gen.pure(sek),
          gen.pure(san),
          gen.pure(skp),
          gen.database_schema(
            letters[1:6],
            0,
            8,
            single_empty_key = sek,
            same_attr_name = san,
            single_key_pairs = skp
          )
        ))),
      \(sek, san, skp, ds) expect_valid_database_schema(
        ds,
        single_empty_key = sek,
        same_attr_name = san,
        single_key_pairs = skp
      ),
      curry = TRUE
    )
  })
})

describe("gen.database_schema_empty_keys", {
  it("generates valid relation schemas, enough empty keys", {
    forall(
      list(
        gen.element(c(FALSE, TRUE)),
        gen.element(c(FALSE, TRUE)),
        gen.element(0:4)
      ) |>
        gen.and_then(uncurry(\(san, skp, from) list(
          gen.pure(san),
          gen.pure(skp),
          gen.element(0:from) |>
            gen.and_then(\(me) {
              list(
                gen.pure(me),
                gen.database_schema_empty_keys(
                  letters[1:6],
                  from = from,
                  to = 8,
                  min_empty = me,
                  same_attr_name = san,
                  single_key_pairs = skp
                )
              )
            })
        ))) |>
        gen.with(uncurry(\(san, skp, lst) {
          c(list(san, skp), lst)
        })),
      \(san, skp, me, ds) {
        expect_valid_database_schema(
          ds,
          same_attr_name = san,
          single_key_pairs = skp
        )
        expect_gte(
          sum(vapply(keys(ds), identical, logical(1), list(character()))),
          me
        )
      },
      curry = TRUE
    )
  })
})

describe("gen.relation", {
  it("generates valid relations", {
    forall(
      gen.element(c(FALSE, TRUE)) |>
        gen.and_then(\(sek) list(
          gen.pure(sek),
          gen.relation(letters[1:4], 6, 7, single_empty_key = sek)
        )),
      \(sek, r) expect_valid_relation(r, single_empty_key = sek),
      curry = TRUE
    )
  })
})

describe("gen.database", {
  it("generates valid databases", {
    forall(
      gen.element(c(FALSE, TRUE)) |>
        gen.list(of = 3) |>
        gen.and_then(uncurry(\(sek, san, skp) list(
          gen.pure(sek),
          gen.pure(san),
          gen.pure(skp),
          gen.database(
            letters[1:7],
            from = 0,
            to = 6,
            single_empty_key = sek,
            same_attr_name = san,
            single_key_pairs = skp
          )
        ))),
      \(sek, san, skp, ds) expect_valid_database(
        ds,
        single_empty_key = sek,
        same_attr_name = san,
        single_key_pairs = skp
      ),
      curry = TRUE
    )
  })
})

describe("remove_insertion_key_violations", {
  it("removes violations", {
    forall(
      gen.relation(letters[1:4], 0, 6) |>
        gen.and_then(\(r) {
          used_attrs <- attrs_order(r) %in% Reduce(c, attrs(r), init = character())
          used_classes <- vapply(
            rejoin(`attrs_order<-`(r, value = attrs_order(r)[used_attrs])),
            \(x) class(x)[[1]],
            character(1)
          )
          cls <- rep("logical", length(attrs_order(r)))
          cls[used_attrs] <- used_classes
          list(
            gen.pure(r),
            gen.int(10) |>
              gen.and_then(with_args(
                gen.df_fixed_ranges,
                classes = cls,
                nms = attrs_order(r),
                remove_dup_rows = TRUE
              ))
          )
        }) |>
        gen.with(uncurry(\(r, df) {
          list(
            r,
            unclass(r),
            df,
            remove_insertion_key_violations(df, r)
          )
        })),
      \(r, r_unclassed, df, df_trimmed) {
        recs <- records(r)
        ks <- keys(r)
        expect_true(all(vapply(
          seq_along(r),
          \(n) {
            r_df <- recs[[n]]
            new_rel <- df_unique(rbind(r_df, df_trimmed[, names(r_df), drop = FALSE]))
            all(vapply(
              ks[[n]],
              \(key) {!df_anyDuplicated(new_rel[, key, drop = FALSE])},
              logical(1)
            ))
          },
          logical(1)
        )))
      },
      curry = TRUE
    )
  })
})