class Mocha::Mock

def __expectations__
  @expectations
end

def __expire__(origin)
  @expired = origin || true
end

def __verified__?(assertion_counter = nil)
  @expectations.verified?(assertion_counter)
end

def all_expectations
  @receiver.mocks.inject(ExpectationList.new) { |e, m| e + m.__expectations__ }
end

def any_expectations?
  @expectations.any?
end

def check_expiry
  return unless @expired
  origin = @expired == true ? 'one test' : @expired
  sentences = [
    "#{mocha_inspect} was instantiated in #{origin} but it is receiving invocations within another test.",
    'This can lead to unintended interactions between tests and hence unexpected test failures.',
    'Ensure that every test correctly cleans up any state that it introduces.'
  ]
  raise StubbingError.new(sentences.join(' '), caller)
end

def check_responder_responds_to(symbol)
  if @responder && !@responder.respond_to?(symbol) # rubocop:disable Style/GuardClause
    raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}"
  end
end

def ensure_method_not_already_defined(method_name)
  __singleton_class__.send(:undef_method, method_name) if __singleton_class__.method_defined?(method_name) || __singleton_class__.private_method_defined?(method_name)
end

def expects(method_name_or_hash, backtrace = nil)
  expectation = nil
  iterator = ArgumentIterator.new(method_name_or_hash)
  iterator.each do |*args|
    method_name = args.shift
    ensure_method_not_already_defined(method_name)
    expectation = Expectation.new(self, method_name, backtrace)
    expectation.in_sequence(@mockery.sequences.last) if @mockery.sequences.any?
    expectation.returns(args.shift) unless args.empty?
    @expectations.add(expectation)
  end
  expectation
end

def handle_method_call(symbol, arguments, block)
  check_expiry
  check_responder_responds_to(symbol)
  invocation = Invocation.new(self, symbol, arguments, block)
  if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(invocation))
    matching_expectation_allowing_invocation.invoke(invocation)
  elsif (matching_expectation = all_expectations.match(invocation, ignoring_order: true)) || (!matching_expectation && !@everything_stubbed)
    raise_unexpected_invocation_error(invocation, matching_expectation)
  end
end

def initialize(mockery, name = nil, receiver = nil)
  @mockery = mockery
  @name = name || DefaultName.new(self)
  @receiver = receiver || DefaultReceiver.new(self)
  @expectations = ExpectationList.new
  @everything_stubbed = false
  @responder = nil
  @unexpected_invocation = nil
  @expired = false
end

def inspect
  mocha_inspect
end

def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
  handle_method_call(symbol, arguments, block)
end

def mocha_inspect
  @name.mocha_inspect
end

def raise_unexpected_invocation_error(invocation, matching_expectation)
  if @unexpected_invocation.nil?
    @unexpected_invocation = invocation
    matching_expectation.invoke(invocation) if matching_expectation
    call_description = @unexpected_invocation.call_description
    if matching_expectation && !matching_expectation.in_correct_order?
      call_description += ' invoked out of order'
    end
    message = "#{call_description}\n#{@mockery.mocha_inspect}"
  else
    message = @unexpected_invocation.short_call_description
  end
  raise ExpectationErrorFactory.build("unexpected invocation: #{message}", caller)
end

def respond_to_missing?(symbol, _include_all)
  if @responder
    @responder.respond_to?(symbol)
  else
    @everything_stubbed || all_expectations.matches_method?(symbol)
  end
end

def responds_like(responder)
  @responder = responder
  self
end

def responds_like_instance_of(responder_class)
  responds_like(responder_class.allocate)
end

def stub_everything
  @everything_stubbed = true
end

def stubs(method_name_or_hash, backtrace = nil)
  expectation = nil
  iterator = ArgumentIterator.new(method_name_or_hash)
  iterator.each do |*args|
    method_name = args.shift
    ensure_method_not_already_defined(method_name)
    expectation = Expectation.new(self, method_name, backtrace)
    expectation.at_least(0)
    expectation.in_sequence(@mockery.sequences.last) if @mockery.sequences.any?
    expectation.returns(args.shift) unless args.empty?
    @expectations.add(expectation)
  end
  expectation
end

def unstub(*method_names)
  method_names.each do |method_name|
    @expectations.remove_all_matching_method(method_name)
  end
end