module Brief
  class Publisher

    class << self
      attr_accessor :defined, :aliases
    end

    self.defined ||= {}
    self.aliases ||= {}

    def self.find query
      query = query.join(" ") if query.respond_to?(:to_ary)

      if defined[query].nil? && aliases.has_key?(query)
        return find(aliases[query])
      end

      result = defined[query]

      result
    end

    def self.publisher publisher_name
      defined[key]
    end

    def self.define publisher_name, &config
      obj = defined[publisher_name] ||= Brief::Publisher.new(publisher_name)
      obj.instance_eval(&config) if block_given?

      aliases[publisher_name.downcase] ||= obj.name

      obj.aliases.each do |alias_name|
        aliases[alias_name.to_s] ||= obj.name
      end

      obj
    end

    def process document
      @manager = Brief::Publisher::HandlerManager.new(self, document).run
    end

    attr_accessor :command_alias, :sample, :name, :options

    def initialize(name, options={})
      @name           = name
      @options        = options
      @command_alias  = options[:command_alias]

      @before_blocks = {}
    end

    def before event_name, &block
      (@before_blocks[event_name.to_sym] ||= []).push(block)
    end

    def run_before_hooks event_name, &success
      results = Array(@before_blocks[event_name.to_sym]).map do |hook|
        hook.call if hook.respond_to?(:call)
      end

      unless results.any? {|r| r == false }
        instance_eval(&success) if block_given?
      end
    end

    def required_inputs
      @options[:required_inputs] ||= {}
    end

    def requires_input field, options={}
      cfg = required_inputs.fetch(field.to_sym) { options }
      cfg.reverse_merge(options)
    end

    def levels &block
      @state = :levels
      instance_eval(&block) if block_given?
    end

    def sample sample_markdown=nil
      options[:sample] = "#{sample_markdown}".gsub(/^\s+/,'') if sample_markdown
      options[:sample]
    end

    def aliases *values
      @command_aliases ||= []
      @command_aliases += values
      @command_aliases.uniq
    end

    def maximum_level
      @maximum_level
    end

    def current_level
      @current_level || 1
    end

    def order *levels
      @order = levels if levels && levels.length > 0
      @order || maximum_level.times.map {|n| n + 1 }
    end

    def level level_number, &block
      @state          = :level
      @maximum_level  = [@current_level || 0, level_number].compact.map(&:to_i).max
      @current_level  = level_number
      instance_eval(&block) if block_given?
    end

    def level_config
      @level_config ||= Hashie::Mash.new({})
    end

    def config_for_level level
      level_config["level_#{level}".to_sym] ||= {}
    end

    def current_level_config
      config_for_level(current_level)
    end

    def desc description
      current_level_config[:description] = description
    end

    def define_handler handler, options={}
      if options.is_a?(String)
        options = {klass: options.classify}
      end

      current_level_config[handler] = options
    end

    def replaces_items_from_level n, options={}
      current_level_config[:replace_options] = options
    end

  end
end