class Spec::Mocks::BaseExpectation

def and_raise(exception=Exception)
  @exception_to_raise = exception
end

def and_return(*values, &return_block)
  Kernel::raise AmbiguousReturnError unless @method_block.nil?
  case values.size
    when 0 then value = nil
    when 1 then value = values[0]
  else
    value = values
    @consecutive = true
    @expected_received_count = values.size if !ignoring_args? &&
                                              @expected_received_count < values.size
  end
  @return_block = block_given? ? return_block : lambda { value }
  # Ruby 1.9 - see where this is used below
  @ignore_args = !block_given?
end

def and_throw(symbol)
  @symbol_to_throw = symbol
end

def and_yield(*args)
  @args_to_yield << args
  self
end

def build_child(expected_from, method_block, expected_received_count, opts={})
  child = clone
  child.expected_from = expected_from
  child.method_block = method_block
  child.expected_received_count = expected_received_count
  new_gen = error_generator.clone
  new_gen.opts = opts
  child.error_generator = new_gen
  child.args_to_yield = @args_to_yield.clone
  child
end

def called_max_times?
  @expected_received_count != :any && @expected_received_count > 0 &&
    @actual_received_count >= @expected_received_count
end

def error_generator_opts=(opts={})
  @error_generator.opts = opts
end

def expected_args
  @args_expectation.args
end

def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={})
  @error_generator = error_generator
  @error_generator.opts = opts
  @expected_from = expected_from
  @sym = sym
  @method_block = method_block
  @return_block = nil
  @actual_received_count = 0
  @expected_received_count = expected_received_count
  @args_expectation = ArgumentExpectation.new([ArgumentConstraints::AnyArgsConstraint.new])
  @consecutive = false
  @exception_to_raise = nil
  @symbol_to_throw = nil
  @order_group = expectation_ordering
  @at_least = nil
  @at_most = nil
  @args_to_yield = []
end

def invoke(args, block)
  if @expected_received_count == 0
    @actual_received_count += 1
    @error_generator.raise_expectation_error @sym, @expected_received_count, @actual_received_count, *args
  end
  
  @order_group.handle_order_constraint self
  begin
    Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
    Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
    
    
    if !@method_block.nil?
      default_return_val = invoke_method_block(args)
    elsif @args_to_yield.size > 0
      default_return_val = invoke_with_yield(block)
    else
      default_return_val = nil
    end
    
    if @consecutive
      return invoke_consecutive_return_block(args, block)
    elsif @return_block
      return invoke_return_block(args, block)
    else
      return default_return_val
    end
  ensure
    @actual_received_count += 1
  end
end

def invoke_consecutive_return_block(args, block)
  args << block unless block.nil?
  value = @return_block.call(*args)
  
  index = [@actual_received_count, value.size-1].min
  value[index]
end

def invoke_method_block(args)
  begin
    @method_block.call(*args)
  rescue => detail
    @error_generator.raise_block_failed_error @sym, detail.message
  end
end

def invoke_return_block(args, block)
  args << block unless block.nil?
  # Ruby 1.9 - when we set @return_block to return values
  # regardless of arguments, any arguments will result in
  # a "wrong number of arguments" error
  if @ignore_args
    @return_block.call()
  else
    @return_block.call(*args)
  end
end

def invoke_with_yield(block)
  if block.nil?
    @error_generator.raise_missing_block_error @args_to_yield
  end
  value = nil
  @args_to_yield.each do |args_to_yield_this_time|
    if block.arity > -1 && args_to_yield_this_time.length != block.arity
      @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
    end
    value = block.call(*args_to_yield_this_time)
  end
  value
end

def matches(sym, args)
  @sym == sym and @args_expectation.args_match?(args)
end