class Pry::Hooks

def self.default
  hooks = new
  hooks.add_hook(:before_session, :default) do |_out, _target, pry_instance|
    next if pry_instance.quiet?
    pry_instance.run_command('whereami --quiet')
  end
  hooks
end

def add_hook(event_name, hook_name, callable = nil, &block)
  event_name = event_name.to_s
  # do not allow duplicates, but allow multiple `nil` hooks
  # (anonymous hooks)
  if hook_exists?(event_name, hook_name) && !hook_name.nil?
    raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
  end
  raise ArgumentError, "Must provide a block or callable." if !block && !callable
  # ensure we only have one anonymous hook
  @hooks[event_name].delete_if { |h, _k| h.nil? } if hook_name.nil?
  if block
    @hooks[event_name] << [hook_name, block]
  elsif callable
    @hooks[event_name] << [hook_name, callable]
  end
  self
end

def clear_event_hooks(event_name)
  @hooks[event_name.to_s] = []
end

def delete_hook(event_name, hook_name)
  deleted_callable = nil
  @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
    if current_hook_name == hook_name
      deleted_callable = callable
      true
    else
      false
    end
  end
  deleted_callable
end

def errors
  @errors ||= []
end

def exec_hook(event_name, *args, &block)
  @hooks[event_name.to_s].map do |_hook_name, callable|
    begin
      callable.call(*args, &block)
    rescue RescuableException => e
      errors << e
      e
    end
  end.last
end

def get_hook(event_name, hook_name)
  hook = @hooks[event_name.to_s].find do |current_hook_name, _callable|
    current_hook_name == hook_name
  end
  hook.last if hook
end

def get_hooks(event_name)
  Hash[@hooks[event_name.to_s]]
end

def hook_count(event_name)
  @hooks[event_name.to_s].size
end

def hook_exists?(event_name, hook_name)
  @hooks[event_name.to_s].map(&:first).include?(hook_name)
end

def initialize
  @hooks = Hash.new { |h, k| h[k] = [] }
end

def initialize_copy(_orig)
  hooks_dup = @hooks.dup
  @hooks.each do |k, v|
    hooks_dup[k] = v.dup
  end
  @hooks = hooks_dup
end

def merge(other)
  dup.tap do |v|
    v.merge!(other)
  end
end

def merge!(other)
  @hooks.merge!(other.dup.hooks) do |_key, array, other_array|
    temp_hash = {}
    output = []
    (array + other_array).reverse_each do |pair|
      temp_hash[pair.first] ||= output.unshift(pair)
    end
    output
  end
  self
end