module Concurrent::Promises::FactoryMethods

def any_event(*futures_and_or_events)
  any_event_on default_executor, *futures_and_or_events
end

def any_event_on(default_executor, *futures_and_or_events)
  AnyResolvedEventPromise.new_blocked_by(futures_and_or_events, default_executor).event
end

def any_fulfilled_future(*futures_and_or_events)
  any_fulfilled_future_on default_executor, *futures_and_or_events
end

def any_fulfilled_future_on(default_executor, *futures_and_or_events)
  AnyFulfilledFuturePromise.new_blocked_by(futures_and_or_events, default_executor).future
end

def any_resolved_future(*futures_and_or_events)
  any_resolved_future_on default_executor, *futures_and_or_events
end

def any_resolved_future_on(default_executor, *futures_and_or_events)
  AnyResolvedFuturePromise.new_blocked_by(futures_and_or_events, default_executor).future
end

def delay(*args, &task)
  delay_on default_executor, *args, &task
end

def delay_on(default_executor, *args, &task)
  event = DelayPromise.new(default_executor).event
  task ? event.chain(*args, &task) : event
end

def fulfilled_future(value, default_executor = self.default_executor)
  resolved_future true, value, nil, default_executor
end

def future(*args, &task)
  future_on(default_executor, *args, &task)
end

def future_on(default_executor, *args, &task)
  ImmediateEventPromise.new(default_executor).future.then(*args, &task)
end

def make_future(argument = nil, default_executor = self.default_executor)
  case argument
  when AbstractEventFuture
    # returning wrapper would change nothing
    argument
  when Exception
    rejected_future argument, default_executor
  when nil
    resolved_event default_executor
  else
    fulfilled_future argument, default_executor
  end
end

def rejected_future(reason, default_executor = self.default_executor)
  resolved_future false, nil, reason, default_executor
end

def resolvable_event
  resolvable_event_on default_executor
end

def resolvable_event_on(default_executor = self.default_executor)
  ResolvableEventPromise.new(default_executor).future
end

def resolvable_future
  resolvable_future_on default_executor
end

def resolvable_future_on(default_executor = self.default_executor)
  ResolvableFuturePromise.new(default_executor).future
end

def resolved_event(default_executor = self.default_executor)
  ImmediateEventPromise.new(default_executor).event
end

def resolved_future(fulfilled, value, reason, default_executor = self.default_executor)
  ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
end

def schedule(intended_time, *args, &task)
  schedule_on default_executor, intended_time, *args, &task
end

def schedule_on(default_executor, intended_time, *args, &task)
  event = ScheduledPromise.new(default_executor, intended_time).event
  task ? event.chain(*args, &task) : event
end

def zip_events(*futures_and_or_events)
  zip_events_on default_executor, *futures_and_or_events
end

def zip_events_on(default_executor, *futures_and_or_events)
  ZipEventsPromise.new_blocked_by(futures_and_or_events, default_executor).event
end

def zip_futures(*futures_and_or_events)
  zip_futures_on default_executor, *futures_and_or_events
end

def zip_futures_on(default_executor, *futures_and_or_events)
  ZipFuturesPromise.new_blocked_by(futures_and_or_events, default_executor).future
end