class Dry::Schema::Messages::Abstract

def self.build(options = EMPTY_HASH)
  messages = new
  messages.configure do |config|
    options.each do |key, value|
      config.public_send(:"#{key}=", value)
    end
    config.root = "#{config.top_namespace}.#{config.root}"
    config.rule_lookup_paths = config.rule_lookup_paths.map { |path|
      "#{config.top_namespace}.#{path}"
    }
    yield(config) if block_given?
  end
  messages.prepare
end

def self.setting_names
  @setting_names ||= settings.map { _1.name.to_sym }
end

def call(predicate, options)
  options = {locale: default_locale, **options}
  opts = options.reject { |k,| config.lookup_options.include?(k) }
  path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
  return unless path
  result = get(path, opts)
  [
    Template.new(
      messages: self,
      key: path,
      options: opts
    ),
    result[:meta]
  ]
end

def custom_top_namespace?(path)
  path.to_s == DEFAULT_MESSAGES_PATH.to_s && config.top_namespace != DEFAULT_MESSAGES_ROOT
end

def default_locale
  config.default_locale
end

def filled_lookup_paths(tokens)
  config.lookup_paths.map { |path| path % tokens }
end

def interpolatable_data(_key, _options, **_data)
  raise NotImplementedError
end

def interpolate(_key, _options, **_data)
  raise NotImplementedError
end

def key?(_key, _options = EMPTY_HASH)
  raise NotImplementedError
end

def looked_up_paths(predicate, options)
  tokens = lookup_tokens(predicate, options)
  filled_lookup_paths(tokens)
end

def lookup_paths(predicate, options)
  tokens = lookup_tokens(predicate, options)
  filled_lookup_paths(tokens)
end

def lookup_tokens(predicate, options)
  options.merge(
    predicate: predicate,
    root: options[:not] ? "#{root}.not" : root,
    arg_type: config.arg_types[options[:arg_type]],
    val_type: config.val_types[options[:val_type]],
    message_type: options[:message_type] || :failure
  )
end

def namespaced(namespace)
  Dry::Schema::Messages::Namespaced.new(namespace, self)
end

def root
  config.root
end

def rule(name, options = {})
  tokens = {name: name, locale: options.fetch(:locale, default_locale)}
  path = rule_lookup_paths(tokens).detect { |key| key?(key, options) }
  rule = get(path, options) if path
  rule.is_a?(Hash) ? rule[:text] : rule
end

def rule_lookup_paths(tokens)
  config.rule_lookup_paths.map { |key| key % tokens }
end

def translate(key, locale: default_locale)
  t["#{config.top_namespace}.#{key}", locale: locale]
end