import pkg/chronos
import codex/contracts
import ../asynctest
import ../ethertest
import ./time
import ./helpers/mockprovider

# to see supportive information in the test output
# use `-d:"chronicles_enabled_topics:testProvider:DEBUG` option
# when compiling the test file
logScope:
  topics = "testProvider"

suite "Provider (Mock)":
  test "blockNumberForEpoch returns the earliest block when its timestamp " &
    "is greater than the given epoch time and the earliest block is not " &
    "block number 0 (genesis block)":
    let mockProvider = newMockProvider(
      numberOfBlocks = 10,
      earliestBlockNumber = 1,
      earliestBlockTimestamp = 10,
      timeIntervalBetweenBlocks = 10,
    )

    let (earliestBlockNumber, earliestTimestamp) =
      await mockProvider.blockNumberAndTimestamp(BlockTag.earliest)

    let epochTime = earliestTimestamp - 1

    let actual =
      await mockProvider.blockNumberForEpoch(epochTime.truncate(SecondsSince1970))

    check actual == earliestBlockNumber

  test "blockNumberForEpoch returns the earliest block when its timestamp " &
    "is equal to the given epoch time":
    let mockProvider = newMockProvider(
      numberOfBlocks = 10,
      earliestBlockNumber = 0,
      earliestBlockTimestamp = 10,
      timeIntervalBetweenBlocks = 10,
    )

    let (earliestBlockNumber, earliestTimestamp) =
      await mockProvider.blockNumberAndTimestamp(BlockTag.earliest)

    let epochTime = earliestTimestamp

    let actual =
      await mockProvider.blockNumberForEpoch(epochTime.truncate(SecondsSince1970))

    check earliestBlockNumber == 0.u256
    check actual == earliestBlockNumber

  test "blockNumberForEpoch returns the latest block when its timestamp " &
    "is equal to the given epoch time":
    let mockProvider = newMockProvider(
      numberOfBlocks = 10,
      earliestBlockNumber = 0,
      earliestBlockTimestamp = 10,
      timeIntervalBetweenBlocks = 10,
    )

    let (latestBlockNumber, latestTimestamp) =
      await mockProvider.blockNumberAndTimestamp(BlockTag.latest)

    let epochTime = latestTimestamp

    let actual =
      await mockProvider.blockNumberForEpoch(epochTime.truncate(SecondsSince1970))

    check actual == latestBlockNumber

ethersuite "Provider":
  proc mineNBlocks(provider: JsonRpcProvider, n: int) {.async.} =
    for _ in 0 ..< n:
      discard await provider.send("evm_mine")

  test "blockNumberForEpoch finds closest blockNumber for given epoch time":
    proc createBlockHistory(
        n: int, blockTime: int
    ): Future[seq[(UInt256, UInt256)]] {.async.} =
      var blocks: seq[(UInt256, UInt256)] = @[]
      for _ in 0 ..< n:
        await ethProvider.advanceTime(blockTime.u256)
        let (blockNumber, blockTimestamp) =
          await ethProvider.blockNumberAndTimestamp(BlockTag.latest)
        # collect blocknumbers and timestamps
        blocks.add((blockNumber, blockTimestamp))
      blocks

    proc printBlockNumbersAndTimestamps(blocks: seq[(UInt256, UInt256)]) =
      for (blockNumber, blockTimestamp) in blocks:
        debug "Block", blockNumber = blockNumber, timestamp = blockTimestamp

    type Expectations = tuple[epochTime: UInt256, expectedBlockNumber: UInt256]

    # We want to test that timestamps at the block boundaries, in the middle,
    # and towards lower and upper part of the range are correctly mapped to
    # the closest block number.
    # For example: assume we have the following two blocks with
    # the corresponding block numbers and timestamps:
    # block1: (291, 1728436100)
    # block2: (292, 1728436110)
    # To test that binary search correctly finds the closest block number,
    # we will test the following timestamps:
    # 1728436100 => 291
    # 1728436104 => 291
    # 1728436105 => 292
    # 1728436106 => 292
    # 1728436110 => 292
    proc generateExpectations(blocks: seq[(UInt256, UInt256)]): seq[Expectations] =
      var expectations: seq[Expectations] = @[]
      for i in 0 ..< blocks.len - 1:
        let (startNumber, startTimestamp) = blocks[i]
        let (endNumber, endTimestamp) = blocks[i + 1]
        let middleTimestamp = (startTimestamp + endTimestamp) div 2
        let lowerExpectation = (middleTimestamp - 1, startNumber)
        expectations.add((startTimestamp, startNumber))
        expectations.add(lowerExpectation)
        if middleTimestamp.truncate(int64) - startTimestamp.truncate(int64) <
            endTimestamp.truncate(int64) - middleTimestamp.truncate(int64):
          expectations.add((middleTimestamp, startNumber))
        else:
          expectations.add((middleTimestamp, endNumber))
        let higherExpectation = (middleTimestamp + 1, endNumber)
        expectations.add(higherExpectation)
        if i == blocks.len - 2:
          expectations.add((endTimestamp, endNumber))
      expectations

    proc printExpectations(expectations: seq[Expectations]) =
      debug "Expectations", numberOfExpectations = expectations.len
      for (epochTime, expectedBlockNumber) in expectations:
        debug "Expectation",
          epochTime = epochTime, expectedBlockNumber = expectedBlockNumber

    # mark the beginning of the history for our test
    await ethProvider.mineNBlocks(1)

    # set average block time - 10s - we use larger block time
    # then expected in Linea for more precise testing of the binary search
    let averageBlockTime = 10

    # create a history of N blocks
    let N = 10
    let blocks = await createBlockHistory(N, averageBlockTime)

    printBlockNumbersAndTimestamps(blocks)

    # generate expectations for block numbers
    let expectations = generateExpectations(blocks)
    printExpectations(expectations)

    # validate expectations
    for (epochTime, expectedBlockNumber) in expectations:
      debug "Validating",
        epochTime = epochTime, expectedBlockNumber = expectedBlockNumber
      let actualBlockNumber =
        await ethProvider.blockNumberForEpoch(epochTime.truncate(SecondsSince1970))
      check actualBlockNumber == expectedBlockNumber