# beacon_chain
# Copyright (c) 2019-2022 Status Research & Development GmbH
# Licensed and distributed under either of
#   * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT).
#   * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.

{.push raises: [Defect].}

import
  chronos,
  ../consensus_object_pools/block_clearance_light_client,
  ../networking/eth2_network,
  ../beacon_clock,
  ./request_manager

logScope:
  topics = "optsync"

type
  MsgTrustedBlockProcessor* =
    proc(signedBlock: ForkedMsgTrustedSignedBeaconBlock): Future[void] {.
      gcsafe, raises: [Defect].}

  SyncStrategy {.pure.} = enum
    None,
    RequestManager,
    SyncManager

  LCOptimisticSync* = ref object
    network: Eth2Node
    getBeaconTime: GetBeaconTimeFn
    optimisticProcessor: MsgTrustedBlockProcessor
    safeSlotsToImportOptimistically: uint16
    lcBlocks: LCBlocks
    blockVerifier: request_manager.BlockVerifier
    requestManager: RequestManager
    finalizedBid, optimisticBid, optimisticCandidateBid: BlockId
    finalizedIsExecutionBlock: Option[bool]
    syncStrategy: SyncStrategy
    syncFut, processFut: Future[void]

# https://github.com/ethereum/consensus-specs/blob/v1.2.0-rc.1/sync/optimistic.md
proc reportOptimisticCandidateBlock(optSync: LCOptimisticSync) {.gcsafe.} =
  if optSync.processFut != nil:
    return

  # Check if finalized is execution block (implies that justified is, too)
  if optSync.finalizedIsExecutionBlock.isNone:
    let
      finalizedSlot = optSync.lcBlocks.getFinalizedSlot()
      finalizedBlock = optSync.lcBlocks.getBlockAtSlot(finalizedSlot)
    if finalizedBlock.isOk:
      optSync.finalizedIsExecutionBlock =
        withBlck(finalizedBlock.get):
          when stateFork >= BeaconStateFork.Bellatrix:
            some blck.message.body.is_execution_block()
          else:
            some false

  let
    currentSlot = optSync.lcBlocks.getHeadSlot()
    signedBlock =
      if optSync.finalizedIsExecutionBlock.get(false):
        # If finalized is execution block, can import any later block
        optSync.lcBlocks.getLatestBlockThroughSlot(currentSlot)
      else:
        # Else, block must be deep (min `SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY`)
        let
          minAge = optSync.safeSlotsToImportOptimistically
          maxSlot = max(currentSlot, minAge.Slot) - minAge.uint64
        optSync.lcBlocks.getLatestBlockThroughSlot(maxSlot)
  if signedBlock.isOk:
    let bid = signedBlock.get.toBlockId()
    if bid.slot > optSync.optimisticCandidateBid.slot:
      optSync.optimisticCandidateBid = bid
      optSync.processFut = optSync.optimisticProcessor(signedBlock.get)

      proc handleFinishedProcess(future: pointer) =
        optSync.processFut = nil
        optSync.reportOptimisticCandidateBlock()

      optSync.processFut.addCallback(handleFinishedProcess)

proc initLCOptimisticSync*(
    network: Eth2Node,
    getBeaconTime: GetBeaconTimeFn,
    optimisticProcessor: MsgTrustedBlockProcessor,
    safeSlotsToImportOptimistically: uint16): LCOptimisticSync =
  const numExtraSlots = 2 * SLOTS_PER_EPOCH.int + 1
  let maxSlots = safeSlotsToImportOptimistically.int + numExtraSlots

  let optSync = LCOptimisticSync(
    network: network,
    getBeaconTime: getBeaconTime,
    optimisticProcessor: optimisticProcessor,
    safeSlotsToImportOptimistically: safeSlotsToImportOptimistically,
    lcBlocks: initLCBlocks(maxSlots))

  proc blockVerifier(signedBlock: ForkedSignedBeaconBlock):
      Future[Result[void, BlockError]] =
    let res = optSync.lcBlocks.addBlock(signedBlock)
    if res.isOk:
      if optSync.syncStrategy == SyncStrategy.RequestManager:
        let root = optSync.lcBlocks.getBackfillRoot()
        if root.isSome:
          optSync.requestManager.fetchAncestorBlocks(
            @[FetchRecord(root: root.get)])
        else:
          if not optSync.syncFut.finished:
            optSync.syncFut.cancel()

      optSync.reportOptimisticCandidateBlock()

    let resfut = newFuture[Result[void, BlockError]]("lcOptSyncBlockVerifier")
    resfut.complete(res)
    resfut

  optSync.blockVerifier = blockVerifier
  optSync.requestManager = RequestManager.init(network, optSync.blockVerifier)

  optSync

proc start*(optSync: LCOptimisticSync) =
  optSync.requestManager.start()

func supportsRetarget(syncStrategy: SyncStrategy): bool =
  case syncStrategy
  of SyncStrategy.None, SyncStrategy.RequestManager:
    true
  of SyncStrategy.SyncManager:
    false

proc syncUsingRequestManager(optSync: LCOptimisticSync) {.async.} =
  let startTick = Moment.now()

  var cancellationRequested = false
  while not cancellationRequested:
    let root = optSync.lcBlocks.getBackfillRoot()
    if root.isNone:
      break

    if optSync.requestManager.inpQueue.empty:
      optSync.requestManager.fetchAncestorBlocks(@[FetchRecord(root: root.get)])

    try:
      await chronos.sleepAsync(chronos.seconds(10))
    except CancelledError as exc:
      cancellationRequested = true

  debug "LC optimistic sync complete",
    headSlot = optSync.lcBlocks.getHeadSlot(),
    finalizedSlot = optSync.lcBlocks.getFinalizedSlot(),
    backfillSlot = optSync.lcBlocks.getBackfillSlot(),
    frontfillSlot = optSync.lcBlocks.getFrontfillSlot(),
    syncStrategy = optSync.syncStrategy,
    cancellationRequested,
    syncDur = Moment.now() - startTick

proc syncUsingSyncManager(optSync: LCOptimisticSync) {.async.} =
  let startTick = Moment.now()

  func getLocalHeadSlot(): Slot =
    optSync.lcBlocks.getHeadSlot() + 1

  proc getLocalWallSlot(): Slot =
    optSync.getBeaconTime().slotOrZero

  var cancellationRequested = false
  func getProgressSlot(): Slot =
    if not cancellationRequested:
      optSync.lcBlocks.getBackfillSlot()
    else:
      # Report out-of-band completion of sync
      optSync.lcBlocks.getFrontfillSlot()

  func getFinalizedSlot(): Slot =
    getProgressSlot()

  func getBackfillSlot(): Slot =
    getProgressSlot()

  func getFrontfillSlot(): Slot =
    optSync.lcBlocks.getFrontfillSlot()

  let lcOptSyncManager = newSyncManager[Peer, PeerID](
    optSync.network.peerPool, SyncQueueKind.Backward, getLocalHeadSlot,
    getLocalWallSlot, getFinalizedSlot, getBackfillSlot, getFrontfillSlot,
    progressPivot = optSync.lcBlocks.getHeadSlot(), optSync.blockVerifier,
    maxHeadAge = 0, flags = {SyncManagerFlag.NoMonitor}, ident = "lcOptSync")
  lcOptSyncManager.start()
  while lcOptSyncManager.inProgress:
    try:
      await chronos.sleepAsync(chronos.seconds(10))
    except CancelledError as exc:
      cancellationRequested = true

  debug "LC optimistic sync complete",
    headSlot = optSync.lcBlocks.getHeadSlot(),
    finalizedSlot = optSync.lcBlocks.getFinalizedSlot(),
    backfillSlot = optSync.lcBlocks.getBackfillSlot(),
    frontfillSlot = optSync.lcBlocks.getFrontfillSlot(),
    syncStrategy = optSync.syncStrategy,
    cancellationRequested,
    syncDur = Moment.now() - startTick

proc continueSync(optSync: LCOptimisticSync) {.gcsafe.} =
  let
    currentHeadSlot = optSync.lcBlocks.getHeadSlot()
    targetHeadSlot = optSync.optimisticBid.slot
    headDiff =
      if targetHeadSlot > currentHeadSlot:
        targetHeadSlot - currentHeadSlot
      else:
        currentHeadSlot - targetHeadSlot

    currentFinalizedSlot = optSync.lcBlocks.getFinalizedSlot()
    targetFinalizedSlot = optSync.finalizedBid.slot

    backfillSlot = optSync.lcBlocks.getBackfillSlot()
    frontfillSlot = optSync.lcBlocks.getFrontfillSlot()
    syncDistance =
      if backfillSlot > frontfillSlot:
        backfillSlot - frontfillSlot
      else:
        0

  # If sync is complete, work is done
  if currentHeadSlot == targetHeadSlot and
      currentFinalizedSlot == targetFinalizedSlot and
      syncDistance == 0:
    return

  # Cancel ongoing sync if sync target jumped
  if headDiff >= SLOTS_PER_EPOCH and optSync.syncFut != nil:
    if not optSync.syncFut.finished:
      optSync.syncFut.cancel()
    return

  # When retargeting ongoing sync is not possible, cancel on finality change
  if not optSync.syncStrategy.supportsRetarget:
    if currentFinalizedSlot != targetFinalizedSlot and optSync.syncFut != nil:
      if not optSync.syncFut.finished:
        optSync.syncFut.cancel()
    return

  # Set new sync target
  let
    finalizedBid = optSync.finalizedBid
    optimisticBid = optSync.optimisticBid
  doAssert optimisticBid.slot >= finalizedBid.slot
  if optSync.lcBlocks.getHeadSlot() != optimisticBid.slot:
    optSync.lcBlocks.setHeadBid(optimisticBid)
  if optSync.lcBlocks.getFinalizedSlot() != finalizedBid.slot:
    optSync.lcBlocks.setFinalizedBid(finalizedBid)
    optSync.finalizedIsExecutionBlock.reset()
    optSync.reportOptimisticCandidateBlock()

  if optSync.syncFut == nil:
    # Select sync strategy
    optSync.syncFut =
      if headDiff >= SLOTS_PER_EPOCH:
        optSync.syncStrategy = SyncStrategy.SyncManager
        optSync.syncUsingSyncManager()
      else:
        optSync.syncStrategy = SyncStrategy.RequestManager
        optSync.syncUsingRequestManager()

    # Continue syncing until complete
    proc handleFinishedSync(future: pointer) =
      optSync.syncStrategy.reset()
      optSync.syncFut = nil
      optSync.continueSync()
    optSync.syncFut.addCallback(handleFinishedSync)

proc setOptimisticHeader*(
    optSync: LCOptimisticSync, optimisticHeader: BeaconBlockHeader) =
  optSync.optimisticBid = optimisticHeader.toBlockId
  optSync.continueSync()

proc setFinalizedHeader*(
    optSync: LCOptimisticSync, finalizedHeader: BeaconBlockHeader) =
  optSync.finalizedBid = finalizedHeader.toBlockId
  if optSync.finalizedBid.slot > optSync.optimisticBid.slot:
    optSync.optimisticBid = optSync.finalizedBid
  optSync.continueSync()