class Dry::Schema::ProcessorSteps

def [](name)
  steps[name]
end

def []=(name, value)
  steps[name] = Step.new(type: :core, name: name, executor: value)
end

def after(name, &block)
  after_steps[name] ||= EMPTY_ARRAY.dup
  after_steps[name] << Step.new(type: :after, name: name, executor: block)
  after_steps[name].sort_by!(&:path)
  self
end

def before(name, &block)
  before_steps[name] ||= EMPTY_ARRAY.dup
  before_steps[name] << Step.new(type: :before, name: name, executor: block)
  before_steps[name].sort_by!(&:path)
  self
end

def call(result)
  STEPS_IN_ORDER.each do |name|
    before_steps[name]&.each { |step| step&.(result) }
    steps[name]&.(result)
    after_steps[name]&.each { |step| step&.(result) }
  end
  result
end

def import_callbacks(path, other)
  other.before_steps.each do |name, steps|
    before_steps[name] ||= []
    before_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
  end
  other.after_steps.each do |name, steps|
    after_steps[name] ||= []
    after_steps[name].concat(steps.map { |step| step.scoped(path) }).sort_by!(&:path)
  end
end

def key_map
  @key_map ||= self[:key_coercer].executor.key_map
end

def merge(other)
  ProcessorSteps.new(
    before_steps: merge_callbacks(before_steps, other.before_steps),
    after_steps: merge_callbacks(after_steps, other.after_steps)
  )
end

def merge_callbacks(left, right)
  left.merge(right) do |_key, oldval, newval|
    (oldval + newval).sort_by(&:path)
  end
end

def rule_applier
  @rule_applier ||= steps[:rule_applier].executor
end

def type_schema
  @type_schema ||= steps[:value_coercer].executor.type_schema
end