class RuboCop::Cop::Layout::AlignHash

def adjust(corrector, delta, range)
  if delta > 0
    corrector.insert_before(range, ' ' * delta)
  elsif delta < 0
    range = range_between(range.begin_pos - delta.abs, range.begin_pos)
    corrector.remove(range)
  end
end

def alignment_for(pair)
  if pair.hash_rocket?
    alignment_for_hash_rockets
  else
    alignment_for_colons
  end
end

def alignment_for_colons
  @alignment_for_colons ||=
    new_alignment('EnforcedColonStyle')
end

def alignment_for_hash_rockets
  @alignment_for_hash_rockets ||=
    new_alignment('EnforcedHashRocketStyle')
end

def autocorrect(node)
  # We can't use the instance variable inside the lambda. That would
  # just give each lambda the same reference and they would all get the
  # last value of each. A local variable fixes the problem.
  key_delta = column_deltas[:key] || 0
  if !node.value
    correct_no_value(key_delta, node.source_range)
  else
    correct_key_value(key_delta, node.key.source_range,
                      node.value.source_range,
                      node.loc.operator)
  end
end

def check_pairs(node)
  first_pair = node.pairs.first
  self.column_deltas = alignment_for(first_pair)
                       .deltas_for_first_pair(first_pair, node)
  add_offense(first_pair) unless good_alignment?
  node.children.each do |current|
    self.column_deltas = alignment_for(current)
                         .deltas(first_pair, current)
    add_offense(current) unless good_alignment?
  end
end

def correct_key_value(key_delta, key, value, separator)
  # We can't use the instance variable inside the lambda. That would
  # just give each lambda the same reference and they would all get the
  # last value of each. Some local variables fix the problem.
  separator_delta = column_deltas[:separator] || 0
  value_delta     = column_deltas[:value] || 0
  key_column = key.column
  key_delta = -key_column if key_delta < -key_column
  lambda do |corrector|
    adjust(corrector, key_delta, key)
    adjust(corrector, separator_delta, separator)
    adjust(corrector, value_delta, value)
  end
end

def correct_no_value(key_delta, key)
  ->(corrector) { adjust(corrector, key_delta, key) }
end

def double_splat?(node)
  node.children.last.is_a?(Symbol)
end

def good_alignment?
  column_deltas.values.all?(&:zero?)
end

def ignore_hash_argument?(node)
  case cop_config['EnforcedLastArgumentHashStyle']
  when 'always_inspect'  then false
  when 'always_ignore'   then true
  when 'ignore_explicit' then node.braces?
  when 'ignore_implicit' then !node.braces?
  end
end

def new_alignment(key)
  case cop_config[key]
  when 'key'       then KeyAlignment.new
  when 'table'     then TableAlignment.new
  when 'separator' then SeparatorAlignment.new
  else raise "Unknown #{key}: #{cop_config[key]}"
  end
end

def on_hash(node)
  return if ignored_node?(node)
  return if node.pairs.empty? || node.single_line?
  return unless alignment_for_hash_rockets.checkable_layout?(node) &&
                alignment_for_colons.checkable_layout?(node)
  check_pairs(node)
end

def on_send(node)
  return if double_splat?(node)
  return unless node.arguments?
  last_argument = node.last_argument
  return unless last_argument.hash_type? &&
                ignore_hash_argument?(last_argument)
  ignore_node(last_argument)
end