class Parser::Source::TreeRewriter

def action_summary
  replacements = as_replacements
  case replacements.size
  when 0 then return 'empty'
  when 1..3 then #ok
  else
    replacements = replacements.first(3)
    suffix = '…'
  end
  parts = replacements.map do |(range, str)|
    if str.empty? # is this a deletion?
      "-#{range.to_range}"
    elsif range.size == 0 # is this an insertion?
      "+#{str.inspect}@#{range.begin_pos}"
    else # it is a replacement
      "^#{str.inspect}@#{range.to_range}"
    end
  end
  parts << suffix if suffix
  parts.join(', ')
end

def as_nested_actions
  @action_root.nested_actions
end

def as_replacements
  @action_root.ordered_replacements
end

def check_policy_validity
  invalid = @policy.values - ACTIONS
  raise ArgumentError, "Invalid policy: #{invalid.join(', ')}" unless invalid.empty?
end

def check_range_validity(range)
  if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
    raise IndexError, "The range #{range.to_range} is outside the bounds of the source"
  end
  range
end

def combine(range, attributes)
  range = check_range_validity(range)
  action = TreeRewriter::Action.new(range, @enforcer, **attributes)
  @action_root = @action_root.combine(action)
  self
end

def empty?
  @action_root.empty?
end

def enforce_policy(event)
  return if @policy[event] == :accept
  return unless (values = yield)
  trigger_policy(event, **values)
end

def import!(foreign_rewriter, offset: 0)
  return self if foreign_rewriter.empty?
  contracted = foreign_rewriter.action_root.contract
  merge_effective_range = ::Parser::Source::Range.new(
    @source_buffer,
    contracted.range.begin_pos + offset,
    contracted.range.end_pos + offset,
  )
  check_range_validity(merge_effective_range)
  merge_with = contracted.moved(@source_buffer, offset)
  @action_root = @action_root.combine(merge_with)
  self
end

def in_transaction?
  @in_transaction
end

def initialize(source_buffer,
               crossing_deletions: :accept,
               different_replacements: :accept,
               swallowed_insertions: :accept)
  @diagnostics = Diagnostic::Engine.new
  @diagnostics.consumer = -> diag { $stderr.puts diag.render }
  @source_buffer = source_buffer
  @in_transaction = false
  @policy = {crossing_deletions: crossing_deletions,
             different_replacements: different_replacements,
             swallowed_insertions: swallowed_insertions}.freeze
  check_policy_validity
  @enforcer = method(:enforce_policy)
  # We need a range that would be jugded as containing all other ranges,
  # including 0...0 and size...size:
  all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
  @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
end

def insert_after(range, content)
  wrap(range, nil, content)
end

def insert_after_multi(range, text)
  self.class.warn_of_deprecation
  insert_after(range, text)
end

def insert_before(range, content)
  wrap(range, content, nil)
end

def insert_before_multi(range, text)
  self.class.warn_of_deprecation
  insert_before(range, text)
end

def inspect
  "#<#{self.class} #{source_buffer.name}: #{action_summary}>"
end

def merge(with)
  dup.merge!(with)
end

def merge!(with)
  raise 'TreeRewriter are not for the same source_buffer' unless
    source_buffer == with.source_buffer
  @action_root = @action_root.combine(with.action_root)
  self
end

def process
  source     = @source_buffer.source
  chunks = []
  last_end = 0
  @action_root.ordered_replacements.each do |range, replacement|
    chunks << source[last_end...range.begin_pos] << replacement
    last_end = range.end_pos
  end
  chunks << source[last_end...source.length]
  chunks.join
end

def remove(range)
  replace(range, ''.freeze)
end

def replace(range, content)
  combine(range, replacement: content)
end

def transaction
  unless block_given?
    raise "#{self.class}##{__method__} requires block"
  end
  previous = @in_transaction
  @in_transaction = true
  restore_root = @action_root
  yield
  restore_root = nil
  self
ensure
  @action_root = restore_root if restore_root
  @in_transaction = previous
end

def trigger_policy(event, range: raise, conflict: nil, **arguments)
  action = @policy[event] || :raise
  diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], event, arguments, range)
  @diagnostics.process(diag)
  if conflict
    range, *highlights = conflict
    diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], :"#{event}_conflict", arguments, range, highlights)
    @diagnostics.process(diag)
  end
  raise Parser::ClobberingError, "Parser::Source::TreeRewriter detected clobbering" if action == :raise
end

def wrap(range, insert_before, insert_after)
  combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
end