require 'metaractor/version'
require 'interactor'
require 'metaractor/errors'
require 'metaractor/handle_errors'
require 'metaractor/context_errors'
require 'metaractor/parameters'
require 'metaractor/run_with_context'
require 'metaractor/context_validity'
require 'metaractor/chain_failures'
require 'metaractor/fail_from_context'
require 'metaractor/context_has_key'
require 'metaractor/failure_output'
require 'i18n'
require 'metaractor/namespace'

module Metaractor
  def self.included(base)
    base.class_eval do
      include Interactor
      Metaractor.modules.each do |hsh|
        case hsh[:method]
        when :include
          include hsh[:module]
        when :prepend
          prepend hsh[:module]
        end
      end
    end
  end

  def self.configure
    yield self
  end

  def self.modules
    @modules ||= default_modules
  end

  def self.modules=(mods)
    @modules = mods
  end

  def self.default_modules
    [
      { module: Metaractor::HandleErrors, method: :include },
      { module: Metaractor::Parameters, method: :include },
      { module: Metaractor::RunWithContext, method: :include },
      { module: Metaractor::ChainFailures, method: :include },
      { module: Metaractor::Namespace, method: :include }
    ]
  end

  def self.include_module(mod)
    modules << { module: mod, method: :include }
  end

  def self.prepend_module(mod)
    modules << { module: mod, method: :prepend }
  end

  def self.format_hash(hash)
    if @hash_formatter.nil?
      @hash_formatter = default_hash_formatter
    end

    @hash_formatter.call(hash)
  end

  def self.default_hash_formatter
    ->(hash){ hash.inspect }
  end

  def self.hash_formatter
    @hash_formatter
  end

  def self.hash_formatter=(callable)
    @hash_formatter = callable
  end

  def self.types
    @types ||= {}
  end

  def self.register_type(type, callable)
    types[type] = callable
  end

  def self.clear_types!
    @types = {}
  end
end