class Mocha::Expectation

def add_in_sequence_ordering_constraint(sequence)
  sequence.constrain_as_next_in_sequence(self)
end

def add_ordering_constraint(ordering_constraint)
  @ordering_constraints << ordering_constraint
end

def add_side_effect(side_effect)
  @side_effects << side_effect
end

def at_least(minimum_number_of_times)
  @cardinality.at_least(minimum_number_of_times)
  self
end

def at_least_once
  at_least(1)
end

def at_most(maximum_number_of_times)
  @cardinality.at_most(maximum_number_of_times)
  self
end

def at_most_once
  at_most(1)
end

def definition_location
  filter = BacktraceFilter.new
  filter.filtered(backtrace)[0]
end

def in_correct_order?
  @ordering_constraints.all?(&:allows_invocation_now?)
end

def in_sequence(sequence, *sequences)
  sequences.unshift(sequence).each { |seq| add_in_sequence_ordering_constraint(seq) }
  self
end

def initialize(mock, expected_method_name, backtrace = nil)
  @mock = mock
  @method_matcher = MethodMatcher.new(expected_method_name.to_sym)
  @parameters_matcher = ParametersMatcher.new
  @block_matcher = BlockMatchers::OptionalBlock.new
  @ordering_constraints = []
  @side_effects = []
  @cardinality = Cardinality.new.exactly(1)
  @return_values = ReturnValues.new
  @yield_parameters = YieldParameters.new
  @backtrace = backtrace || caller
end

def inspect
  address = __id__ * 2
  address += 0x100000000 if address < 0
  "#<Expectation:0x#{format('%<address>x', address: address)} #{mocha_inspect} >"
end

def invocations_allowed?
  @cardinality.invocations_allowed?
end

def invoke(invocation)
  perform_side_effects
  @cardinality << invocation
  invocation.call(@yield_parameters, @return_values)
end

def match?(invocation, ignoring_order: false)
  order_independent_match = @method_matcher.match?(invocation.method_name) && @parameters_matcher.match?(invocation.arguments) && @block_matcher.match?(invocation.block)
  ignoring_order ? order_independent_match : order_independent_match && in_correct_order?
end

def matches_method?(method_name)
  @method_matcher.match?(method_name)
end

def method_signature
  signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
  signature << " #{@block_matcher.mocha_inspect}" if @block_matcher.mocha_inspect
  signature
end

def mocha_inspect
  message = "#{@cardinality.anticipated_times}, #{@cardinality.invoked_times}: #{method_signature}"
  message << "; #{@ordering_constraints.map(&:mocha_inspect).join('; ')}" unless @ordering_constraints.empty?
  if Mocha.configuration.display_matching_invocations_on_failure?
    message << @cardinality.actual_invocations
  end
  message
end

def multiple_yields(*parameter_groups)
  @yield_parameters.add(*parameter_groups)
  self
end

def never
  @cardinality.exactly(0)
  self
end

def once
  @cardinality.exactly(1)
  self
end

def ordering_constraints_not_allowing_invocation_now
  @ordering_constraints.reject(&:allows_invocation_now?)
end

def perform_side_effects
  @side_effects.each(&:perform)
end

def raises(exception = RuntimeError, message = nil)
  @return_values += ReturnValues.new(ExceptionRaiser.new(exception, message))
  self
end

def returns(*values)
  @return_values += ReturnValues.build(*values)
  self
end

def satisfied?
  @cardinality.satisfied?
end

def then(state = nil)
  add_side_effect(ChangeStateSideEffect.new(state)) if state
  self
end

def throws(tag, object = nil)
  @return_values += ReturnValues.new(Thrower.new(tag, object))
  self
end

def times(range)
  @cardinality.times(range)
  self
end

def twice
  @cardinality.exactly(2)
  self
end

def used?
  @cardinality.used?
end

def verified?(assertion_counter = nil)
  assertion_counter.increment if assertion_counter && @cardinality.needs_verifying?
  @cardinality.verified?
end

def when(state_predicate)
  add_ordering_constraint(InStateOrderingConstraint.new(state_predicate))
  self
end

def with(*expected_parameters_or_matchers, &matching_block)
  @parameters_matcher = ParametersMatcher.new(expected_parameters_or_matchers, self, &matching_block)
  self
end

def with_block_given
  @block_matcher = BlockMatchers::BlockGiven.new
  self
end

def with_no_block_given
  @block_matcher = BlockMatchers::NoBlockGiven.new
  self
end

def yields(*parameters)
  multiple_yields(parameters)
end