class Promise

# File lib/promise.rb, line 23
def self.all(enumerable)
  Group.new(new, enumerable).promise
end

# File lib/promise.rb, line 27
def self.map_value(obj)
  if obj.is_a?(Promise)
    obj.then { |value| yield value }
  else
    yield obj
  end
end

# File lib/promise.rb, line 39
def initialize
  @state = :pending
end

# File lib/promise.rb, line 18
def self.resolve(obj = nil)
  return obj if obj.is_a?(self)
  new.tap { |promise| promise.fulfill(obj) }
end

# File lib/promise.rb, line 35
def self.sync(obj)
  obj.is_a?(Promise) ? obj.sync : obj
end

# File lib/promise.rb, line 86
def fulfill(value = nil)
  return self unless pending?

  if value.is_a?(Promise)
    case value.state
    when :fulfilled
      fulfill(value.value)
    when :rejected
      reject(value.reason)
    else
      @source = value
      value.subscribe(self, nil, nil)
    end
  else
    @source = nil

    @state = :fulfilled
    @value = value

    notify_fulfillment if defined?(@observers)
  end

  self
end

# File lib/promise.rb, line 47
def fulfilled?
  state.equal?(:fulfilled)
end

# File lib/promise.rb, line 43
def pending?
  state.equal?(:pending)
end

# File lib/promise.rb, line 111
def reject(reason = nil)
  return self unless pending?

  @source = nil
  @state = :rejected
  @reason = reason_coercion(reason || Error)

  notify_rejection if defined?(@observers)

  self
end

# File lib/promise.rb, line 51
def rejected?
  state.equal?(:rejected)
end

# File lib/promise.rb, line 72
def rescue(&block)
  self.then(nil, block)
end

# File lib/promise.rb, line 145
def subscribe(observer, on_fulfill_arg, on_reject_arg)
  raise Error, 'Non-pending promises can not be observed' unless pending?

  unless observer.is_a?(Observer)
    raise ArgumentError, 'Expected `observer` to be a `Promise::Observer`'
  end

  @observers ||= []
  @observers.push(observer, on_fulfill_arg, on_reject_arg)
end

# File lib/promise.rb, line 77
def sync
  if pending?
    wait
    raise BrokenError if pending?
  end
  raise reason if rejected?
  value
end

# File lib/promise.rb, line 55
def then(on_fulfill = nil, on_reject = nil, &block)
  on_fulfill ||= block
  next_promise = self.class.new

  case state
  when :fulfilled
    defer { next_promise.promise_fulfilled(value, on_fulfill) }
  when :rejected
    defer { next_promise.promise_rejected(reason, on_reject) }
  else
    next_promise.source = self
    subscribe(next_promise, on_fulfill, on_reject)
  end

  next_promise
end

# File lib/promise.rb, line 125
def wait
  while source
    saved_source = source
    saved_source.wait
    break if saved_source.equal?(source)
  end
end

# File lib/promise.rb, line 159
def defer
  yield
end

# File lib/promise.rb, line 163
def promise_fulfilled(value, on_fulfill)
  if on_fulfill
    settle_from_handler(value, &on_fulfill)
  else
    fulfill(value)
  end
end

# File lib/promise.rb, line 171
def promise_rejected(reason, on_reject)
  if on_reject
    settle_from_handler(reason, &on_reject)
  else
    reject(reason)
  end
end

# File lib/promise.rb, line 191
def notify_fulfillment
  defer do
    @observers.each_slice(3) do |observer, on_fulfill_arg|
      observer.promise_fulfilled(value, on_fulfill_arg)
    end

    @observers = nil
  end
end

# File lib/promise.rb, line 201
def notify_rejection
  defer do
    @observers.each_slice(3) do |observer, _on_fulfill_arg, on_reject_arg|
      observer.promise_rejected(reason, on_reject_arg)
    end

    @observers = nil
  end
end

# File lib/promise.rb, line 181
def reason_coercion(reason)
  case reason
  when Exception
    reason.set_backtrace(caller) unless reason.backtrace
  when Class
    reason = reason_coercion(reason.new) if reason <= Exception
  end
  reason
end

# File lib/promise.rb, line 211
def settle_from_handler(value)
  fulfill(yield(value))
rescue => ex
  reject(ex)
end