import
  bitops, chronicles, options, tables,
  ssz, beacon_chain_db, state_transition, extras,
  beacon_node_types, metrics,
  spec/[crypto, datatypes, digest, helpers]

declareCounter beacon_reorgs_total, "Total occurrences of reorganizations of the chain" # On fork choice

logScope: topics = "blkpool"

func parent*(bs: BlockSlot): BlockSlot =
  BlockSlot(
    blck: if bs.slot > bs.blck.slot: bs.blck else: bs.blck.parent,
    slot: bs.slot - 1
  )

func link(parent, child: BlockRef) =
  doAssert (not (parent.root == Eth2Digest() or child.root == Eth2Digest())),
    "blocks missing root!"
  doAssert parent.root != child.root, "self-references not allowed"

  child.parent = parent
  parent.children.add(child)

func isAncestorOf*(a, b: BlockRef): bool =
  var b = b
  var depth = 0
  const maxDepth = (100'i64 * 365 * 24 * 60 * 60 div SECONDS_PER_SLOT.int)
  while true:
    if a == b: return true

    # for now, use an assert for block chain length since a chain this long
    # indicates a circular reference here..
    doAssert depth < maxDepth
    depth += 1

    if a.slot >= b.slot or b.parent.isNil:
      return false

    doAssert b.slot > b.parent.slot
    b = b.parent

func init*(T: type BlockRef, root: Eth2Digest, slot: Slot): BlockRef =
  BlockRef(
    root: root,
    slot: slot
  )

func init*(T: type BlockRef, root: Eth2Digest, blck: BeaconBlock): BlockRef =
  BlockRef.init(root, blck.slot)

func findAncestorBySlot*(blck: BlockRef, slot: Slot): BlockSlot =
  ## Find the first ancestor that has a slot number less than or equal to `slot`
  doAssert(not blck.isNil)
  var ret = blck

  while ret.parent != nil and ret.slot > slot:
    ret = ret.parent

  BlockSlot(blck: ret, slot: slot)

proc init*(T: type BlockPool, db: BeaconChainDB): BlockPool =
  # TODO we require that the db contains both a head and a tail block -
  #      asserting here doesn't seem like the right way to go about it however..

  let
    tailBlockRoot = db.getTailBlock()
    headBlockRoot = db.getHeadBlock()

  doAssert tailBlockRoot.isSome(), "Missing tail block, database corrupt?"
  doAssert headBlockRoot.isSome(), "Missing head block, database corrupt?"

  let
    tailRoot = tailBlockRoot.get()
    tailBlock = db.getBlock(tailRoot).get()
    tailRef = BlockRef.init(tailRoot, tailBlock)
    headRoot = headBlockRoot.get()

  var
    blocks = {tailRef.root: tailRef}.toTable()
    latestStateRoot = Option[Eth2Digest]()
    headRef: BlockRef

  if headRoot != tailRoot:
    var curRef: BlockRef

    for root, blck in db.getAncestors(headRoot):
      if root == tailRef.root:
        doAssert(not curRef.isNil)
        link(tailRef, curRef)
        curRef = curRef.parent
        break

      let newRef = BlockRef.init(root, blck)
      if curRef == nil:
        curRef = newRef
        headRef = newRef
      else:
        link(newRef, curRef)
        curRef = curRef.parent
      blocks[curRef.root] = curRef
      trace "Populating block pool", key = curRef.root, val = curRef

      if latestStateRoot.isNone() and db.containsState(blck.state_root):
        latestStateRoot = some(blck.state_root)

    doAssert curRef == tailRef,
      "head block does not lead to tail, database corrupt?"
  else:
    headRef = tailRef

  var blocksBySlot = initTable[Slot, seq[BlockRef]]()
  for _, b in tables.pairs(blocks):
    let slot = db.getBlock(b.root).get().slot
    blocksBySlot.mgetOrPut(slot, @[]).add(b)

  let
    # The head state is necessary to find out what we considered to be the
    # finalized epoch last time we saved something.
    headStateRoot =
      if latestStateRoot.isSome():
        latestStateRoot.get()
      else:
        db.getBlock(tailRef.root).get().state_root

    # TODO right now, because we save a state at every epoch, this *should*
    #      be the latest justified state or newer, meaning it's enough for
    #      establishing what we consider to be the finalized head. This logic
    #      will need revisiting however
    headState = db.getState(headStateRoot).get()
    finalizedHead =
      headRef.findAncestorBySlot(
        headState.finalized_checkpoint.epoch.compute_start_slot_at_epoch())
    justifiedSlot =
      headState.current_justified_checkpoint.epoch.compute_start_slot_at_epoch()
    justifiedHead = headRef.findAncestorBySlot(justifiedSlot)
    head = Head(blck: headRef, justified: justifiedHead)

  doAssert justifiedHead.slot >= finalizedHead.slot,
    "justified head comes before finalized head - database corrupt?"

  debug "Block pool initialized",
    head = head.blck, finalizedHead, tail = tailRef,
    totalBlocks = blocks.len, totalKnownSlots = blocksBySlot.len

  BlockPool(
    pending: initTable[Eth2Digest, BeaconBlock](),
    missing: initTable[Eth2Digest, MissingBlock](),
    blocks: blocks,
    blocksBySlot: blocksBySlot,
    tail: tailRef,
    head: head,
    finalizedHead: finalizedHead,
    db: db,
    heads: @[head]
  )

proc addSlotMapping(pool: BlockPool, br: BlockRef) =
  proc addIfMissing(s: var seq[BlockRef], v: BlockRef) =
    if v notin s:
      s.add(v)
  pool.blocksBySlot.mgetOrPut(br.slot, @[]).addIfMissing(br)

proc delSlotMapping(pool: BlockPool, br: BlockRef) =
  var blks = pool.blocksBySlot.getOrDefault(br.slot)
  if blks.len != 0:
    let i = blks.find(br)
    if i >= 0: blks.del(i)
    if blks.len == 0:
      pool.blocksBySlot.del(br.slot)
    else:
      pool.blocksBySlot[br.slot] = blks

proc updateStateData*(
  pool: BlockPool, state: var StateData, bs: BlockSlot) {.gcsafe.}

proc add*(
    pool: var BlockPool, state: var StateData, blockRoot: Eth2Digest,
    blck: BeaconBlock): BlockRef {.gcsafe.}

proc addResolvedBlock(
    pool: var BlockPool, state: var StateData, blockRoot: Eth2Digest,
    blck: BeaconBlock, parent: BlockRef): BlockRef =
  logScope: pcs = "block_resolution"

  let blockRef = BlockRef.init(blockRoot, blck)
  link(parent, blockRef)

  pool.blocks[blockRoot] = blockRef
  trace "Populating block pool", key = blockRoot, val = blockRef

  pool.addSlotMapping(blockRef)

  # Resolved blocks should be stored in database
  pool.db.putBlock(blockRoot, blck)

  # TODO this is a bit ugly - we update state.data outside of this function then
  #      set the rest here - need a blockRef to update it. Clean this up -
  #      hopefully it won't be necessary by the time hash caching and the rest
  #      is done..
  doAssert state.data.data.slot == blockRef.slot
  state.blck = blockRef

  # This block *might* have caused a justification - make sure we stow away
  # that information:
  let justifiedSlot =
    state.data.data.current_justified_checkpoint.epoch.compute_start_slot_at_epoch()

  var foundHead: Option[Head]
  for head in pool.heads.mitems():
    if head.blck.isAncestorOf(blockRef):
      if head.justified.slot != justifiedSlot:
        head.justified = blockRef.findAncestorBySlot(justifiedSlot)

      head.blck = blockRef

      foundHead = some(head)
      break

  if foundHead.isNone():
    foundHead = some(Head(
      blck: blockRef,
      justified: blockRef.findAncestorBySlot(justifiedSlot)))
    pool.heads.add(foundHead.get())

  info "Block resolved",
    blck = shortLog(blck),
    blockRoot = shortLog(blockRoot),
    justifiedRoot = shortLog(foundHead.get().justified.blck.root),
    justifiedSlot = shortLog(foundHead.get().justified.slot),
    cat = "filtering"

  # Now that we have the new block, we should see if any of the previously
  # unresolved blocks magically become resolved
  # TODO there are more efficient ways of doing this that don't risk
  #      running out of stack etc
  # TODO This code is convoluted because when there are more than ~1.5k
  #      blocks being synced, there's a stack overflow as `add` gets called
  #      for the whole chain of blocks. Instead we use this ugly field in `pool`
  #      which could be avoided by refactoring the code
  if not pool.inAdd:
    pool.inAdd = true
    defer: pool.inAdd = false
    var keepGoing = true
    while keepGoing:
      let retries = pool.pending
      for k, v in retries:
        discard pool.add(state, k, v)
      # Keep going for as long as the pending pool is shrinking
      # TODO inefficient! so what?
      keepGoing = pool.pending.len < retries.len
  blockRef

proc add*(
    pool: var BlockPool, state: var StateData, blockRoot: Eth2Digest,
    blck: BeaconBlock): BlockRef {.gcsafe.} =
  ## return the block, if resolved...
  ## the state parameter may be updated to include the given block, if
  ## everything checks out
  # TODO reevaluate passing the state in like this
  doAssert blockRoot == signing_root(blck)

  logScope: pcs = "block_addition"

  # Already seen this block??
  if blockRoot in pool.blocks:
    debug "Block already exists",
      blck = shortLog(blck),
      blockRoot = shortLog(blockRoot),
      cat = "filtering"

    return pool.blocks[blockRoot]

  pool.missing.del(blockRoot)

  # If the block we get is older than what we finalized already, we drop it.
  # One way this can happen is that we start resolving a block and finalization
  # happens in the meantime - the block we requested will then be stale
  # by the time it gets here.
  if blck.slot <= pool.finalizedHead.slot:
    debug "Old block, dropping",
      blck = shortLog(blck),
      tailSlot = shortLog(pool.tail.slot),
      blockRoot = shortLog(blockRoot),
      cat = "filtering"

    return

  let parent = pool.blocks.getOrDefault(blck.parent_root)

  if parent != nil:
    # The block might have been in either of these - we don't want any more
    # work done on its behalf
    pool.pending.del(blockRoot)

    # The block is resolved, now it's time to validate it to ensure that the
    # blocks we add to the database are clean for the given state

    # TODO if the block is from the future, we should not be resolving it (yet),
    #      but maybe we should use it as a hint that our clock is wrong?
    updateStateData(pool, state, BlockSlot(blck: parent, slot: blck.slot - 1))

    if not state_transition(state.data, blck, {}):
      # TODO find a better way to log all this block data
      notice "Invalid block",
        blck = shortLog(blck),
        blockRoot = shortLog(blockRoot),
        cat = "filtering"

      return

    return pool.addResolvedBlock(state, blockRoot, blck, parent)

  pool.pending[blockRoot] = blck

  # TODO possibly, it makes sense to check the database - that would allow sync
  #      to simply fill up the database with random blocks the other clients
  #      think are useful - but, it would also risk filling the database with
  #      junk that's not part of the block graph

  if blck.parent_root in pool.missing or
      blck.parent_root in pool.pending:
    return

  # This is an unresolved block - put its parent on the missing list for now...
  # TODO if we receive spam blocks, one heurestic to implement might be to wait
  #      for a couple of attestations to appear before fetching parents - this
  #      would help prevent using up network resources for spam - this serves
  #      two purposes: one is that attestations are likely to appear for the
  #      block only if it's valid / not spam - the other is that malicious
  #      validators that are not proposers can sign invalid blocks and send
  #      them out without penalty - but signing invalid attestations carries
  #      a risk of being slashed, making attestations a more valuable spam
  #      filter.
  # TODO when we receive the block, we don't know how many others we're missing
  #      from that branch, so right now, we'll just do a blind guess
  debug "Unresolved block (parent missing)",
    blck = shortLog(blck),
    blockRoot = shortLog(blockRoot),
    cat = "filtering"

  let parentSlot = blck.slot - 1

  pool.missing[blck.parent_root] = MissingBlock(
    slots:
      # The block is at least two slots ahead - try to grab whole history
      if parentSlot > pool.head.blck.slot:
        parentSlot - pool.head.blck.slot
      else:
        # It's a sibling block from a branch that we're missing - fetch one
        # epoch at a time
        max(1.uint64, SLOTS_PER_EPOCH.uint64 -
          (parentSlot.uint64 mod SLOTS_PER_EPOCH.uint64))
  )

func getRef*(pool: BlockPool, root: Eth2Digest): BlockRef =
  ## Retrieve a resolved block reference, if available
  pool.blocks.getOrDefault(root, nil)

proc getBlockRange*(pool: BlockPool, headBlock: Eth2Digest,
                    startSlot: Slot, skipStep: Natural,
                    output: var openarray[BlockRef]): Natural =
  ## This function populates an `output` buffer of blocks
  ## with a range starting from `startSlot` and skipping
  ## every `skipTest` number of blocks.
  ##
  ## Please note that the function may not necessarily
  ## populate the entire buffer. The values will be written
  ## in a way such that the last block is placed at the end
  ## of the buffer while the first indices of the buffer
  ## may remain unwritten.
  ##
  ## The result value of the function will be the index of
  ## the first block in the resulting buffer. If no values
  ## were written to the buffer, the result will be equal to
  ## `buffer.len`. In other words, you can use the function
  ## like this:
  ##
  ## var buffer: array[N, BlockRef]
  ## let startPos = pool.getBlockRange(headBlock, startSlot, skipStep, buffer)
  ## for i in startPos ..< buffer.len:
  ##   echo buffer[i].slot
  ##
  result = output.len

  trace "getBlockRange entered", headBlock, startSlot, skipStep

  var b = pool.getRef(headBlock)
  if b == nil:
    trace "head block not found", headBlock
    return

  trace "head block found", headBlock = b

  if b.slot < startSlot:
    trace "head block is older than startSlot", headBlockSlot = b.slot, startSlot
    return

  template skip(n: int) =
    let targetSlot = b.slot - Slot(n)
    while b.slot > targetSlot:
      if b.parent == nil:
        trace "stopping at parentless block", slot = b.slot, root = b.root
        return
      trace "skipping block", nextBlock = b.parent
      b = b.parent

  # We must compute the last block that is eligible for inclusion
  # in the results. This will be a block with a slot number that's
  # aligned to the stride of the requested block range, so we first
  # compute the steps needed to get to an aligned position:
  var blocksToSkip = b.slot.int mod skipStep
  let alignedHeadSlot = b.slot.int - blocksToSkip

  # Then we see if this aligned position is within our wanted
  # range. If it's outside it, we must skip more blocks:
  let lastWantedSlot = startSlot.int + (output.len - 1) * skipStep
  if alignedHeadSlot > lastWantedSlot:
    blocksToSkip += (alignedHeadSlot - lastWantedSlot)

  # Finally, we skip the computed number of blocks
  trace "aligning head", blocksToSkip
  skip blocksToSkip

  # From here, we can just write out the requested block range:
  while b != nil and b.slot >= startSlot and result > 0:
    dec result
    output[result] = b
    trace "getBlockRange result", position = result, blockSlot = b.slot
    skip skipStep

proc get*(pool: BlockPool, blck: BlockRef): BlockData =
  ## Retrieve the associated block body of a block reference
  doAssert (not blck.isNil), "Trying to get nil BlockRef"

  let data = pool.db.getBlock(blck.root)
  doAssert data.isSome, "BlockRef without backing data, database corrupt?"

  BlockData(data: data.get(), refs: blck)

proc get*(pool: BlockPool, root: Eth2Digest): Option[BlockData] =
  ## Retrieve a resolved block reference and its associated body, if available
  let refs = pool.getRef(root)

  if not refs.isNil:
    some(pool.get(refs))
  else:
    none(BlockData)

func getOrResolve*(pool: var BlockPool, root: Eth2Digest): BlockRef =
  ## Fetch a block ref, or nil if not found (will be added to list of
  ## blocks-to-resolve)
  result = pool.getRef(root)

  if result.isNil:
    pool.missing[root] = MissingBlock(slots: 1)

iterator blockRootsForSlot*(pool: BlockPool, slot: Slot): Eth2Digest =
  for br in pool.blocksBySlot.getOrDefault(slot, @[]):
    yield br.root

func checkMissing*(pool: var BlockPool): seq[FetchRecord] =
  ## Return a list of blocks that we should try to resolve from other client -
  ## to be called periodically but not too often (once per slot?)
  var done: seq[Eth2Digest]

  for k, v in pool.missing.mpairs():
    if v.tries > 8:
      done.add(k)
    else:
      inc v.tries

  for k in done:
    # TODO Need to potentially remove from pool.pending - this is currently a
    #      memory leak here!
    pool.missing.del(k)

  # simple (simplistic?) exponential backoff for retries..
  for k, v in pool.missing.pairs():
    if v.tries.popcount() == 1:
      result.add(FetchRecord(root: k, historySlots: v.slots))

proc skipAndUpdateState(
    state: var HashedBeaconState, blck: BeaconBlock, flags: UpdateFlags,
    afterUpdate: proc (state: HashedBeaconState)): bool =

  process_slots(state, blck.slot - 1)
  afterUpdate(state)

  let ok  = state_transition(state, blck, flags)

  afterUpdate(state)

  ok

proc maybePutState(pool: BlockPool, state: HashedBeaconState, blck: BlockRef) =
  # TODO we save state at every epoch start but never remove them - we also
  #      potentially save multiple states per slot if reorgs happen, meaning
  #      we could easily see a state explosion
  # TODO this is out of sync with epoch def now, I think -- (slot + 1) mod foo.
  logScope: pcs = "save_state_at_epoch_start"


  if state.data.slot mod SLOTS_PER_EPOCH == 0:
    if not pool.db.containsState(state.root):
      info "Storing state",
        stateSlot = shortLog(state.data.slot),
        stateRoot = shortLog(state.root),
        cat = "caching"
      pool.db.putState(state.root, state.data)
      # TODO this should be atomic with the above write..
      pool.db.putStateRoot(blck.root, state.data.slot, state.root)

proc rewindState(pool: BlockPool, state: var StateData, bs: BlockSlot):
    seq[BlockData] =
  logScope: pcs = "replay_state"

  var ancestors = @[pool.get(bs.blck)]
  # Common case: the last block applied is the parent of the block to apply:
  if not bs.blck.parent.isNil and state.blck.root == bs.blck.parent.root and
      state.data.data.slot < bs.slot:
    return ancestors

  # It appears that the parent root of the proposed new block is different from
  # what we expected. We will have to rewind the state to a point along the
  # chain of ancestors of the new block. We will do this by loading each
  # successive parent block and checking if we can find the corresponding state
  # in the database.

  var
    stateRoot = pool.db.getStateRoot(bs.blck.root, bs.slot)
    curBs = bs
  while stateRoot.isNone():
    let parBs = curBs.parent()
    if parBs.blck.isNil:
      break # Bug probably!

    if parBs.blck != curBs.blck:
      ancestors.add(pool.get(parBs.blck))

    if (let tmp = pool.db.getStateRoot(parBs.blck.root, parBs.slot); tmp.isSome()):
      if pool.db.containsState(tmp.get):
        stateRoot = tmp
        break

    curBs = parBs

  if stateRoot.isNone():
    # TODO this should only happen if the database is corrupt - we walked the
    #      list of parent blocks and couldn't find a corresponding state in the
    #      database, which should never happen (at least we should have the
    #      tail state in there!)
    error "Couldn't find ancestor state root!",
      blockRoot = shortLog(bs.blck.root),
      cat = "crash"
    doAssert false, "Oh noes, we passed big bang!"

  let
    ancestor = ancestors[^1]
    ancestorState = pool.db.getState(stateRoot.get())

  if ancestorState.isNone():
    # TODO this should only happen if the database is corrupt - we walked the
    #      list of parent blocks and couldn't find a corresponding state in the
    #      database, which should never happen (at least we should have the
    #      tail state in there!)
    error "Couldn't find ancestor state or block parent missing!",
      blockRoot = shortLog(bs.blck.root),
      cat = "crash"
    doAssert false, "Oh noes, we passed big bang!"

  trace "Replaying state transitions",
    stateSlot = shortLog(state.data.data.slot),
    ancestorStateRoot = shortLog(ancestor.data.state_root),
    ancestorStateSlot = shortLog(ancestorState.get().slot),
    slot = shortLog(bs.slot),
    blockRoot = shortLog(bs.blck.root),
    ancestors = ancestors.len,
    cat = "replay_state"

  state.data.data = ancestorState.get()
  state.data.root = stateRoot.get()
  state.blck = ancestor.refs

  ancestors

proc updateStateData*(pool: BlockPool, state: var StateData, bs: BlockSlot) =
  ## Rewind or advance state such that it matches the given block and slot -
  ## this may include replaying from an earlier snapshot if blck is on a
  ## different branch or has advanced to a higher slot number than slot
  ## If slot is higher than blck.slot, replay will fill in with empty/non-block
  ## slots, else it is ignored

  # We need to check the slot because the state might have moved forwards
  # without blocks
  if state.blck.root == bs.blck.root and state.data.data.slot <= bs.slot:
    if state.data.data.slot != bs.slot:
      # Might be that we're moving to the same block but later slot
      process_slots(state.data, bs.slot)
      pool.maybePutState(state.data, bs.blck)

    return # State already at the right spot

  let ancestors = rewindState(pool, state, bs)

  # If we come this far, we found the state root. The last block on the stack
  # is the one that produced this particular state, so we can pop it
  # TODO it might be possible to use the latest block hashes from the state to
  #      do this more efficiently.. whatever!

  # Time to replay all the blocks between then and now. We skip one because
  # it's the one that we found the state with, and it has already been
  # applied
  for i in countdown(ancestors.len - 2, 0):
    let ok =
      skipAndUpdateState(state.data, ancestors[i].data, {skipValidation}) do(
        state: HashedBeaconState):
      pool.maybePutState(state, ancestors[i].refs)
    doAssert ok, "Blocks in database should never fail to apply.."

  # TODO check if this triggers rest of state transition, or should
  process_slots(state.data, bs.slot)
  pool.maybePutState(state.data, bs.blck)

  state.blck = bs.blck

proc loadTailState*(pool: BlockPool): StateData =
  ## Load the state associated with the current tail in the pool
  let stateRoot = pool.db.getBlock(pool.tail.root).get().state_root
  StateData(
    data: HashedBeaconState(
      data: pool.db.getState(stateRoot).get(),
      root: stateRoot),
    blck: pool.tail
  )

proc delBlockAndState(pool: BlockPool, blockRoot: Eth2Digest) =
  if (let blk = pool.db.getBlock(blockRoot); blk.isSome):
    pool.db.delState(blk.get.stateRoot)
    pool.db.delBlock(blockRoot)

proc delFinalizedStateIfNeeded(pool: BlockPool, b: BlockRef) =
  # Delete finalized state for block `b` from the database, that doesn't need
  # to be kept for replaying.
  # TODO: Currently the protocol doesn't provide a way to request states,
  # so we don't need any of the finalized states, and thus remove all of them
  # (except the most recent)
  if (let blk = pool.db.getBlock(b.root); blk.isSome):
    pool.db.delState(blk.get.stateRoot)

proc setTailBlock(pool: BlockPool, newTail: BlockRef) =
  ## Advance tail block, pruning all the states and blocks with older slots
  let oldTail = pool.tail
  let fromSlot = oldTail.slot.uint64
  let toSlot = newTail.slot.uint64 - 1
  assert(toSlot > fromSlot)
  for s in fromSlot .. toSlot:
    for b in pool.blocksBySlot.getOrDefault(s.Slot, @[]):
      pool.delBlockAndState(b.root)
      b.children = @[]
      b.parent = nil
      pool.blocks.del(b.root)
      pool.pending.del(b.root)
      pool.missing.del(b.root)

    pool.blocksBySlot.del(s.Slot)

  pool.db.putTailBlock(newTail.root)
  pool.tail = newTail
  pool.addSlotMapping(newTail)
  info "Tail block updated",
    slot = newTail.slot,
    root = shortLog(newTail.root)

proc updateHead*(pool: BlockPool, state: var StateData, blck: BlockRef) =
  ## Update what we consider to be the current head, as given by the fork
  ## choice.
  ## The choice of head affects the choice of finalization point - the order
  ## of operations naturally becomes important here - after updating the head,
  ## blocks that were once considered potential candidates for a tree will
  ## now fall from grace, or no longer be considered resolved.
  doAssert blck.parent != nil or blck.slot == 0
  logScope: pcs = "fork_choice"

  if pool.head.blck == blck:
    info "No head block update",
      headBlockRoot = shortLog(blck.root),
      headBlockSlot = shortLog(blck.slot),
      cat = "fork_choice"

    return

  let
    lastHead = pool.head
  pool.db.putHeadBlock(blck.root)

  # Start off by making sure we have the right state
  updateStateData(pool, state, BlockSlot(blck: blck, slot: blck.slot))
  let justifiedSlot = state.data.data
                           .current_justified_checkpoint
                           .epoch
                           .compute_start_slot_at_epoch()
  pool.head = Head(blck: blck, justified: blck.findAncestorBySlot(justifiedSlot))

  if lastHead.blck != blck.parent:
    info "Updated head block (new parent)",
      lastHeadRoot = shortLog(lastHead.blck.root),
      parentRoot = shortLog(blck.parent.root),
      stateRoot = shortLog(state.data.root),
      headBlockRoot = shortLog(state.blck.root),
      stateSlot = shortLog(state.data.data.slot),
      justifiedEpoch = shortLog(state.data.data.current_justified_checkpoint.epoch),
      finalizedEpoch = shortLog(state.data.data.finalized_checkpoint.epoch),
      cat = "fork_choice"

    # A reasonable criterion for "reorganizations of the chain"
    # TODO if multiple heads have gotten skipped, could fire at
    # spurious times - for example when multiple blocks have been added between
    # head updates
    beacon_reorgs_total.inc()
  else:
    info "Updated head block",
      stateRoot = shortLog(state.data.root),
      headBlockRoot = shortLog(state.blck.root),
      stateSlot = shortLog(state.data.data.slot),
      justifiedEpoch = shortLog(state.data.data.current_justified_checkpoint.epoch),
      finalizedEpoch = shortLog(state.data.data.finalized_checkpoint.epoch),
      cat = "fork_choice"

  let
    finalizedEpochStartSlot = state.data.data.finalized_checkpoint.epoch.compute_start_slot_at_epoch()
    # TODO there might not be a block at the epoch boundary - what then?
    finalizedHead = blck.findAncestorBySlot(finalizedEpochStartSlot)

  doAssert (not finalizedHead.blck.isNil),
    "Block graph should always lead to a finalized block"

  if finalizedHead != pool.finalizedHead:
    info "Finalized block",
      finalizedBlockRoot = shortLog(finalizedHead.blck.root),
      finalizedBlockSlot = shortLog(finalizedHead.slot),
      headBlockRoot = shortLog(blck.root),
      headBlockSlot = shortLog(blck.slot),
      cat = "fork_choice"

    pool.finalizedHead = finalizedHead

    var cur = finalizedHead.blck
    while cur != pool.finalizedHead.blck:
      # Finalization means that we choose a single chain as the canonical one -
      # it also means we're no longer interested in any branches from that chain
      # up to the finalization point

      # TODO technically, if we remove from children the gc should free the block
      #      because it should become orphaned, via mark&sweep if nothing else,
      #      though this needs verification
      # TODO what about attestations? we need to drop those too, though they
      #      *should* be pretty harmless
      # TODO remove from database as well.. here, or using some GC-like setup
      #      that periodically cleans it up?
      for child in cur.parent.children:
        if child != cur:
          pool.blocks.del(child.root)
          pool.delBlockAndState(child.root)
          pool.delSlotMapping(child)
        else:
          pool.delFinalizedStateIfNeeded(child)
      cur.parent.children = @[cur]
      cur = cur.parent

    let hlen = pool.heads.len
    for i in 0..<hlen:
      let n = hlen - i - 1
      if pool.heads[n].blck.slot < pool.finalizedHead.blck.slot:
        # By definition, the current head should be newer than the finalized
        # head, so we'll never delete it here
        pool.heads.del(n)

  # Calculate new tail block and set it
  # New tail should be WEAK_SUBJECTIVITY_PERIOD * 2 older than finalizedHead
  const tailSlotInterval = WEAK_SUBJECTVITY_PERIOD * 2
  if finalizedEpochStartSlot - GENESIS_SLOT > tailSlotInterval:
    let tailSlot = finalizedEpochStartSlot - tailSlotInterval
    let newTail = finalizedHead.blck.findAncestorBySlot(tailSlot)
    pool.setTailBlock(newTail.blck)

func latestJustifiedBlock*(pool: BlockPool): BlockSlot =
  ## Return the most recent block that is justified and at least as recent
  ## as the latest finalized block

  doAssert pool.heads.len > 0,
    "We should have at least the genesis block in heaads"
  doAssert (not pool.head.blck.isNil()),
    "Genesis block will be head, if nothing else"

  # Prefer stability: use justified block from current head to break ties!
  result = pool.head.justified
  for head in pool.heads[1 ..< ^0]:
    if head.justified.slot > result.slot:
      result = head.justified

proc preInit*(
    T: type BlockPool, db: BeaconChainDB, state: BeaconState, blck: BeaconBlock) =
  # write a genesis state, the way the BlockPool expects it to be stored in
  # database
  # TODO probably should just init a blockpool with the freshly written
  #      state - but there's more refactoring needed to make it nice - doing
  #      a minimal patch for now..
  let
    blockRoot = signing_root(blck)

  notice "New database from snapshot",
    blockRoot = shortLog(blockRoot),
    stateRoot = shortLog(blck.state_root),
    fork = state.fork,
    validators = state.validators.len(),
    cat = "initialization"

  db.putState(state)
  db.putBlock(blck)
  db.putTailBlock(blockRoot)
  db.putHeadBlock(blockRoot)
  db.putStateRoot(blockRoot, blck.slot, blck.state_root)