import { folderStructureArray } from "../src/indexing/allIds"
import { getRecordInfo } from "../src/recordApi/recordInfo"
import { setupApphierarchy } from "./specHelpers"

describe("getRecordInfo", () => {
  it("dir should not be sharded when record count = 1000", async () => {
    const { root } = (await setup({ parentCount: 1000 })).appHierarchy
    const { dir } = getRecordInfo(root, "/parents/1-abcd")
    expect(dir).toBe("/parents/1/1-abcd")
  })

  it("dir should be sharded when record count = 1001", async () => {
    const { root } = (await setup({ parentCount: 1001 })).appHierarchy
    const { dir } = getRecordInfo(root, "/parents/1-abcd")
    expect(dir).toBe("/parents/1/0123456789abcdefghijklmnopqrstuv/1-abcd")
  })

  it("dir should be sharded to one char per folder when record count = 63,000 (64*1000)", async () => {
    const { root } = (await setup({ parentCount: 64000 })).appHierarchy
    const { dir } = getRecordInfo(root, "/parents/1-abcd")
    expect(dir).toBe("/parents/1/a/1-abcd")
  })

  it("dir should be sharded to one char per folder, on 2 levels when record count = 4096000 (64*64*1000)", async () => {
    const { root } = (await setup({ parentCount: 4096000 })).appHierarchy
    const { dir } = getRecordInfo(root, "/parents/1-abcd")
    expect(dir).toBe("/parents/1/a/b/1-abcd")
  })

  it("child dir should not be sharded when record count = 1000", async () => {
    const { root, child } = (
      await setup({ parentCount: 4096000, childCount: 1000 })
    ).appHierarchy
    const { dir } = getRecordInfo(
      root,
      `/parents/1-abcd/children/${child.nodeId}-defg`
    )
    expect(dir).toBe(
      `/parents/1/a/b/1-abcd/children/${child.nodeId}/${child.nodeId}-defg`
    )
  })

  it("grandchild dir should not be sharded when record count = 1000", async () => {
    const { root, child, grandchild } = (
      await setup({ parentCount: 4096000, childCount: 4096000 })
    ).appHierarchy
    const { dir } = getRecordInfo(
      root,
      `/parents/1-abcd/children/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}-hijk`
    )
    expect(dir).toBe(
      `/parents/1/a/b/1-abcd/children/${child.nodeId}/d/e/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}/${grandchild.nodeId}-hijk`
    )
  })

  it("grandchild dir should be sharded when record count = 4096000", async () => {
    const { root, child, grandchild } = (
      await setup({
        parentCount: 4096000,
        childCount: 4096000,
        grandChildCount: 4096000,
      })
    ).appHierarchy
    const { dir } = getRecordInfo(
      root,
      `/parents/1-abcd/children/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}-hijk`
    )
    expect(dir).toBe(
      `/parents/1/a/b/1-abcd/children/${child.nodeId}/d/e/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}/h/i/${grandchild.nodeId}-hijk`
    )
  })

  it("child levels can be sharded, with parent not", async () => {
    const { root, child, grandchild } = (
      await setup({
        parentCount: 1000,
        childCount: 4096000,
        grandChildCount: 4096000,
      })
    ).appHierarchy
    const { dir } = getRecordInfo(
      root,
      `/parents/1-abcd/children/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}-hijk`
    )
    expect(dir).toBe(
      `/parents/1/1-abcd/children/${child.nodeId}/d/e/${child.nodeId}-defg/grandchildren/${grandchild.nodeId}/h/i/${grandchild.nodeId}-hijk`
    )
  })
})

describe("folderStructureArray", () => {
  const recordNode = count => ({ estimatedRecordCount: count })

  it("should return [] when folder count < 1000", () => {
    const result = folderStructureArray(recordNode(999))
    expect(result).toEqual([])
  })

  it("should return [4] when folder count between 3000 - 4000", () => {
    const result = folderStructureArray(recordNode(3456))
    expect(result).toEqual([4])
  })

  it("should return [64, 2] when folder count between 64000 - 65000", () => {
    const result = folderStructureArray(recordNode(64001))
    expect(result).toEqual([64, 2])
  })

  it("should return [64, 64] when folder = 4095999", () => {
    const result = folderStructureArray(recordNode(4095999))
    expect(result).toEqual([64, 64])
  })

  it("should return [64, 64] when folder = 4096000", () => {
    const result = folderStructureArray(recordNode(4096000))
    expect(result).toEqual([64, 64])
  })

  it("should return [64, 64, 2] when folder = 4096001", () => {
    const result = folderStructureArray(recordNode(4096001))
    expect(result).toEqual([64, 64, 2])
  })
})

const setup = ({ parentCount, childCount, grandChildCount }) =>
  setupApphierarchy(templateApi => {
    const root = templateApi.getNewRootLevel()

    const addField = recordNode => {
      const field = templateApi.getNewField("string")
      field.name = "test"
      templateApi.addField(recordNode, field)
      return field
    }

    const parent = templateApi.getNewModelTemplate(root, "parent")
    parent.estimatedRecordCount = parentCount || 1000
    parent.collectionName = "parents"
    addField(parent)
    const child = templateApi.getNewModelTemplate(parent, "child")
    child.estimatedRecordCount = childCount || 1000
    child.collectionName = "children"
    addField(child)
    const grandchild = templateApi.getNewModelTemplate(child, "grandchild")
    grandchild.estimatedRecordCount = grandChildCount || 1000
    grandchild.collectionName = "grandchildren"
    addField(grandchild)

    return {
      parent,
      child,
      grandchild,
      root,
    }
  })