class RuboCop::Cop::Corrector

def initialize(source_buffer, corrections = [])
  @source_buffer = source_buffer
  raise 'source_buffer should be a Parser::Source::Buffer' unless \
    source_buffer.is_a? Parser::Source::Buffer
  @corrections = corrections
  @source_rewriter = Parser::Source::TreeRewriter.new(
    source_buffer,
    different_replacements: :raise,
    swallowed_insertions: :raise,
    crossing_deletions: :accept
  )
  @diagnostics = []
  # Don't print warnings to stderr if corrections conflict with each other
  @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
    @diagnostics << diagnostic
  end
end

def insert_after(range, content)
  validate_range range
  @source_rewriter.insert_after(range, content)
end

def insert_before(range, content)
  validate_range range
  # TODO: Fix Cops using bad ranges instead
  if range.end_pos > @source_buffer.source.size
    range = range.with(end_pos: @source_buffer.source.size)
  end
  @source_rewriter.insert_before(range, content)
end

def remove(range)
  validate_range range
  @source_rewriter.remove(range)
end

def remove_leading(range, size)
  validate_range range
  to_remove = Parser::Source::Range.new(range.source_buffer,
                                        range.begin_pos,
                                        range.begin_pos + size)
  @source_rewriter.remove(to_remove)
end

def remove_preceding(range, size)
  validate_range range
  to_remove = Parser::Source::Range.new(range.source_buffer,
                                        range.begin_pos - size,
                                        range.begin_pos)
  @source_rewriter.remove(to_remove)
end

def remove_trailing(range, size)
  validate_range range
  to_remove = Parser::Source::Range.new(range.source_buffer,
                                        range.end_pos - size,
                                        range.end_pos)
  @source_rewriter.remove(to_remove)
end

def replace(range, content)
  validate_range range
  @source_rewriter.replace(range, content)
end

def rewrite
  # rubocop:disable Lint/HandleExceptions
  @corrections.each do |correction|
    begin
      @source_rewriter.transaction do
        correction.call(self)
      end
    rescue ::Parser::ClobberingError
    end
  end
  # rubocop:enable Lint/HandleExceptions
  @source_rewriter.process
end

def validate_range(range)
  return if range.source_buffer == @source_buffer
  unless range.source_buffer.is_a?(Parser::Source::Buffer)
    # actually this should be enforced by parser gem
    raise 'Corrector expected range source buffer to be a '\
          "Parser::Source::Buffer, but got #{range.source_buffer.class}"
  end
  raise "Correction target buffer #{range.source_buffer.object_id} "\
        "name:#{range.source_buffer.name.inspect}"\
        " is not current #{@source_buffer.object_id} "\
        "name:#{@source_buffer.name.inspect} under investigation"
end