class Concurrent::Promises::BlockedPromise

def self.add_delayed(delayed1, delayed2)
  if delayed1 && delayed2
    delayed1.push delayed2
    delayed1
  else
    delayed1 || delayed2
  end
end

def self.new_blocked_by(blockers, *args, &block)
  delayed = blockers.reduce(nil) { |d, f| add_delayed d, f.promise.delayed_because }
  promise = new(delayed, blockers.size, *args, &block)
  blockers.each_with_index { |f, i| f.add_callback_notify_blocked promise, i }
  promise
end

def self.new_blocked_by1(blocker, *args, &block)
  blocker_delayed = blocker.promise.delayed_because
  promise         = new(blocker_delayed, 1, *args, &block)
  blocker.add_callback_notify_blocked promise, 0
  promise
end

def self.new_blocked_by2(blocker1, blocker2, *args, &block)
  blocker_delayed1 = blocker1.promise.delayed_because
  blocker_delayed2 = blocker2.promise.delayed_because
  delayed          = if blocker_delayed1 && blocker_delayed2
                       # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
                       LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
                     else
                       blocker_delayed1 || blocker_delayed2
                     end
  promise          = new(delayed, 2, *args, &block)
  blocker1.add_callback_notify_blocked promise, 0
  blocker2.add_callback_notify_blocked promise, 1
  promise
end

def blocked_by
  blocked_by = []
  ObjectSpace.each_object(AbstractEventFuture) { |o| blocked_by.push o if o.blocks.include? self }
  blocked_by
end

def clear_and_propagate_touch(stack_or_element = @Delayed)
  return if stack_or_element.nil?
  if stack_or_element.is_a? LockFreeStack
    stack_or_element.clear_each { |element| clear_and_propagate_touch element }
  else
    stack_or_element.touch unless stack_or_element.nil? # if still present
  end
end

def delayed_because
  @Delayed
end

def initialize(delayed, blockers_count, future)
  super(future)
  @Delayed   = delayed
  @Countdown = AtomicFixnum.new blockers_count
end

def on_blocker_resolution(future, index)
  countdown  = process_on_blocker_resolution(future, index)
  resolvable = resolvable?(countdown, future, index)
  on_resolvable(future, index) if resolvable
end

def on_resolvable(resolved_future, index)
  raise NotImplementedError
end

def process_on_blocker_resolution(future, index)
  @Countdown.decrement
end

def resolvable?(countdown, future, index)
  countdown.zero?
end

def touch
  clear_and_propagate_touch
end