import { expect, test } from "vitest"

import { BaseTable } from "#Source/storage/index.ts"

interface TestRow extends Record<string, unknown> {
  id: string
  label: string
  count: number
  meta: {
    rank: number
  }
  status?: string
}

class TestTable extends BaseTable<TestRow> {
  // No additional implementation needed for testing BaseTable functionality
}

const createTestTable = (): TestTable => {
  return new TestTable({
    uniqueGetter: (row) => row.id,
  })
}

const createRow = (overrides: Partial<TestRow> = {}): TestRow => {
  return {
    id: "row-1",
    label: "alpha",
    count: 1,
    meta: {
      rank: 1,
    },
    status: "kept",
    ...overrides,
  }
}

const createRows = (): [TestRow, TestRow, TestRow] => {
  return [
    createRow(),
    createRow({
      id: "row-2",
      label: "beta",
      count: 2,
      meta: {
        rank: 2,
      },
      status: "held",
    }),
    createRow({
      id: "row-3",
      label: "gamma",
      count: 3,
      meta: {
        rank: 3,
      },
      status: "fresh",
    }),
  ]
}

test("BaseTable.clearTable removes all rows and emits an empty snapshot", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()
  const snapshots: TestRow[][] = []

  await table.insertRowsOrThrow([rowA, rowB])
  table.event.subscribe("valueChanged", (rows) => {
    snapshots.push(rows)
  })

  await table.clearTable()

  expect(snapshots).toHaveLength(1)
  expect(snapshots[0]).toEqual([])

  snapshots[0]?.push(createRow({ id: "extra" }))

  expect(await table.getRows(() => true)).toEqual([])
  expect(snapshots[0]).toEqual([createRow({ id: "extra" })])
})

test("BaseTable.getRow returns a cloned row and keeps predicate mutations isolated", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  const foundRow = await table.getRow((row) => {
    row.label = "mutated-in-getter"
    row.meta.rank = 99
    return row.id === rowA.id
  })

  foundRow!.label = "mutated-in-result"
  foundRow!.meta.rank = 100

  expect(foundRow).toEqual({
    ...rowA,
    label: "mutated-in-result",
    meta: {
      rank: 100,
    },
  })
  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)
})

test("BaseTable.getRows returns cloned rows and keeps predicate mutations isolated", async () => {
  const table = createTestTable()
  const [rowA, rowB, rowC] = createRows()

  await table.insertRowsOrThrow([rowA, rowB, rowC])

  const foundRows = await table.getRows((row) => {
    row.status = "mutated"
    return row.count >= 2
  })

  foundRows[0]!.status = "changed-after-read"

  expect(foundRows).toEqual([
    {
      ...rowB,
      status: "changed-after-read",
    },
    rowC,
  ])
  expect(await table.getRows((row) => row.count >= 2)).toEqual([rowB, rowC])
})

test("BaseTable.insertRowOrThrow inserts one row, emits snapshots, and rejects duplicate uniques", async () => {
  const table = createTestTable()
  const [rowA] = createRows()
  const snapshots: TestRow[][] = []

  table.event.subscribe("valueChanged", (rows) => {
    snapshots.push(rows)
  })

  const insertedRow = await table.insertRowOrThrow(rowA)
  insertedRow.meta.rank = 100
  snapshots[0]![0]!.label = "mutated-snapshot"

  await expect(table.insertRowOrThrow(rowA)).rejects.toThrow(
    'Row with unique "row-1" already exists',
  )
  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)
  expect(snapshots).toHaveLength(1)
})

test("BaseTable.insertRow returns undefined for duplicate uniques and inserts missing rows", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(await table.insertRow(rowA)).toBeUndefined()
  expect(await table.insertRow(rowB)).toEqual(rowB)
  expect(await table.getRows(() => true)).toEqual([rowA, rowB])
})

test("BaseTable.insertRowsOrThrow inserts a batch and rejects duplicate uniques inside the batch", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()
  const duplicateBatch = [
    rowA,
    createRow({
      id: rowA.id,
      label: "duplicate",
      count: 9,
      meta: {
        rank: 9,
      },
    }),
  ]

  const insertedRows = await table.insertRowsOrThrow([rowA, rowB])
  insertedRows[0]!.meta.rank = 100

  await expect(table.insertRowsOrThrow(duplicateBatch)).rejects.toThrow(
    'Duplicate row unique "row-1" found in batch',
  )
  expect(await table.getRows(() => true)).toEqual([rowA, rowB])
})

test("BaseTable.simpleUpdateRowOrThrow returns the merged stored row", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  const updatedRow = await table.simpleUpdateRowOrThrow({
    id: rowA.id,
    label: "beta",
    count: 8,
    meta: {
      rank: 8,
    },
  })

  expect(updatedRow).toEqual({
    ...rowA,
    label: "beta",
    count: 8,
    meta: {
      rank: 8,
    },
  })
  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(updatedRow)
})

test("BaseTable.simpleUpdateRow returns merged rows and undefined for missing uniques", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(
    await table.simpleUpdateRow({
      id: rowA.id,
      label: "simple",
      count: 6,
      meta: {
        rank: 6,
      },
    }),
  ).toEqual({
    ...rowA,
    label: "simple",
    count: 6,
    meta: {
      rank: 6,
    },
  })
  expect(await table.simpleUpdateRow(createRow({ id: "missing" }))).toBeUndefined()
})

test("BaseTable.simpleUpdateRowsOrThrow merges each row and rejects duplicate batch uniques", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowsOrThrow([rowA, rowB])

  const updatedRows = await table.simpleUpdateRowsOrThrow([
    {
      id: rowA.id,
      label: "alpha-updated",
      count: 11,
      meta: {
        rank: 11,
      },
    },
    {
      id: rowB.id,
      label: "beta-updated",
      count: 12,
      meta: {
        rank: 12,
      },
    },
  ])

  expect(updatedRows).toEqual([
    {
      ...rowA,
      label: "alpha-updated",
      count: 11,
      meta: {
        rank: 11,
      },
    },
    {
      ...rowB,
      label: "beta-updated",
      count: 12,
      meta: {
        rank: 12,
      },
    },
  ])

  await expect(
    table.simpleUpdateRowsOrThrow([
      createRow({ id: rowA.id }),
      createRow({ id: rowA.id, label: "duplicate" }),
    ]),
  ).rejects.toThrow('Duplicate row unique "row-1" found in batch')
})

test("BaseTable.updateRowOrThrow updates one matching row and rejects invalid transitions", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  const updatedRow = await table.updateRowOrThrow(
    (row) => row.id === rowA.id,
    (row) => ({
      ...row,
      label: "updated",
      count: row.count + 5,
      meta: {
        rank: row.meta.rank + 5,
      },
    }),
  )

  expect(updatedRow).toEqual({
    ...rowA,
    label: "updated",
    count: 6,
    meta: {
      rank: 6,
    },
  })
  await expect(
    table.updateRowOrThrow(
      (row) => row.id === "missing",
      (row) => row,
    ),
  ).rejects.toThrow("Row not found.")
  await expect(
    table.updateRowOrThrow(
      (row) => row.id === rowA.id,
      (row) => ({
        ...row,
        id: "changed",
      }),
    ),
  ).rejects.toThrow("Unique cannot be changed")
})

test("BaseTable.updateRow returns undefined when no row matches or the unique changes", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(
    await table.updateRow(
      (row) => row.id === rowA.id,
      (row) => ({
        ...row,
        label: "updated-by-updateRow",
      }),
    ),
  ).toEqual({
    ...rowA,
    label: "updated-by-updateRow",
  })
  expect(
    await table.updateRow(
      (row) => row.id === "missing",
      (row) => row,
    ),
  ).toBeUndefined()
  expect(
    await table.updateRow(
      (row) => row.id === rowA.id,
      (row) => ({
        ...row,
        id: "changed",
      }),
    ),
  ).toBeUndefined()
})

test("BaseTable.updateRows updates all matching rows and isolates predicate mutations", async () => {
  const table = createTestTable()
  const [rowA, rowB, rowC] = createRows()

  await table.insertRowsOrThrow([rowA, rowB, rowC])

  const updatedRows = await table.updateRows(
    (row) => {
      row.status = "mutated-in-getter"
      return row.count >= 2
    },
    (row) => ({
      ...row,
      count: row.count + 10,
    }),
  )

  expect(updatedRows).toEqual([
    {
      ...rowB,
      count: 12,
    },
    {
      ...rowC,
      count: 13,
    },
  ])
  expect(await table.getRow((row) => row.id === rowA.id)).toEqual(rowA)

  await expect(
    table.updateRows(
      () => true,
      (row) => ({
        ...row,
        id: `${row.id}-changed`,
      }),
    ),
  ).rejects.toThrow("Unique cannot be changed")
})

test("BaseTable.upsertRow inserts new rows and returns merged stored rows for updates", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  expect(await table.upsertRow(rowA)).toEqual(rowA)
  expect(
    await table.upsertRow({
      id: rowA.id,
      label: "upserted",
      count: 20,
      meta: {
        rank: 20,
      },
    }),
  ).toEqual({
    ...rowA,
    label: "upserted",
    count: 20,
    meta: {
      rank: 20,
    },
  })
  expect(await table.upsertRow(rowB)).toEqual(rowB)
})

test("BaseTable.upsertRows returns merged stored rows and rejects duplicate batch uniques", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(
    await table.upsertRows([
      {
        id: rowA.id,
        label: "merged",
        count: 21,
        meta: {
          rank: 21,
        },
      },
      rowB,
    ]),
  ).toEqual([
    {
      ...rowA,
      label: "merged",
      count: 21,
      meta: {
        rank: 21,
      },
    },
    rowB,
  ])

  await expect(
    table.upsertRows([createRow({ id: rowA.id }), createRow({ id: rowA.id, label: "duplicate" })]),
  ).rejects.toThrow('Duplicate row unique "row-1" found in batch')
})

test("BaseTable.simpleDeleteRowOrThrow deletes by unique and returns the stored row", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(
    await table.simpleDeleteRowOrThrow({
      id: rowA.id,
      label: "ignored",
      count: 0,
      meta: {
        rank: 0,
      },
    }),
  ).toEqual(rowA)
  await expect(table.simpleDeleteRowOrThrow(createRow({ id: "missing" }))).rejects.toThrow(
    "Row not found",
  )
})

test("BaseTable.simpleDeleteRow returns undefined when the unique does not exist", async () => {
  const table = createTestTable()
  const [rowA] = createRows()

  await table.insertRowOrThrow(rowA)

  expect(
    await table.simpleDeleteRow({
      id: rowA.id,
      label: "ignored",
      count: 0,
      meta: {
        rank: 0,
      },
    }),
  ).toEqual(rowA)
  expect(await table.simpleDeleteRow(createRow({ id: "missing" }))).toBeUndefined()
})

test("BaseTable.simpleDeleteRows returns stored rows and rejects duplicate batch uniques", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowsOrThrow([rowA, rowB])

  expect(
    await table.simpleDeleteRows([
      {
        id: rowA.id,
        label: "ignored",
        count: 0,
        meta: {
          rank: 0,
        },
      },
      {
        id: rowB.id,
        label: "ignored",
        count: 0,
        meta: {
          rank: 0,
        },
      },
    ]),
  ).toEqual([rowA, rowB])

  await table.insertRowsOrThrow([rowA, rowB])
  await expect(
    table.simpleDeleteRows([
      createRow({ id: rowA.id }),
      createRow({ id: rowA.id, label: "duplicate" }),
    ]),
  ).rejects.toThrow('Duplicate row unique "row-1" found in batch')
})

test("BaseTable.deleteRowOrThrow deletes one matched row and rejects zero or many matches", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowsOrThrow([rowA, rowB])

  expect(await table.deleteRowOrThrow((row) => row.id === rowA.id)).toEqual(rowA)
  await expect(table.deleteRowOrThrow((row) => row.id === "missing")).rejects.toThrow(
    "Row not found.",
  )

  await table.insertRowOrThrow(rowA)
  await expect(table.deleteRowOrThrow((row) => row.count >= 1)).rejects.toThrow(
    "Multiple rows found",
  )
})

test("BaseTable.deleteRow returns undefined for no matches and throws for multiple matches", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()

  await table.insertRowsOrThrow([rowA, rowB])

  await expect(table.deleteRow((row) => row.count >= 1)).rejects.toThrow("Multiple rows found")
  expect(await table.deleteRow((row) => row.id === rowA.id)).toEqual(rowA)
  expect(await table.deleteRow((row) => row.id === "missing")).toBeUndefined()
})

test("BaseTable.deleteRows deletes all matched rows and keeps predicate mutations isolated", async () => {
  const table = createTestTable()
  const [rowA, rowB, rowC] = createRows()

  await table.insertRowsOrThrow([rowA, rowB, rowC])

  expect(
    await table.deleteRows((row) => {
      row.status = "mutated-in-getter"
      return row.count >= 2
    }),
  ).toEqual([rowB, rowC])
  expect(await table.getRows(() => true)).toEqual([rowA])
})

test("BaseTable event valueChanged publishes cloned snapshots for successive mutations", async () => {
  const table = createTestTable()
  const [rowA, rowB] = createRows()
  const snapshots: TestRow[][] = []

  table.event.subscribe("valueChanged", (rows) => {
    snapshots.push(rows)
  })

  await table.insertRowOrThrow(rowA)
  await table.upsertRow({
    id: rowA.id,
    label: "updated",
    count: 30,
    meta: {
      rank: 30,
    },
  })
  await table.insertRowOrThrow(rowB)
  await table.deleteRow((row) => row.id === rowB.id)

  snapshots[0]![0]!.label = "mutated-outside"

  expect(snapshots).toEqual([
    [
      {
        ...rowA,
        label: "mutated-outside",
      },
    ],
    [
      {
        ...rowA,
        label: "updated",
        count: 30,
        meta: {
          rank: 30,
        },
      },
    ],
    [
      {
        ...rowA,
        label: "updated",
        count: 30,
        meta: {
          rank: 30,
        },
      },
      rowB,
    ],
    [
      {
        ...rowA,
        label: "updated",
        count: 30,
        meta: {
          rank: 30,
        },
      },
    ],
  ])
  expect(await table.getRows(() => true)).toEqual([
    {
      ...rowA,
      label: "updated",
      count: 30,
      meta: {
        rank: 30,
      },
    },
  ])
})