class Asciidoctor::Reader

def apply_attribute_value_subs(value)
  if value.match(REGEXP[:pass_macro_basic])
    # copy match for Ruby 1.8.7 compat
    m = $~
    subs = []
    if !m[1].empty?
      subs = @document.resolve_subs(m[1])
    end
    if !subs.empty?
      @document.apply_subs(m[2], subs)
    else
      m[2]
    end
  else
    @document.apply_header_subs(value)
  end
end

def attribute_overridden?(key)
  @overrides.has_key?(key) || @overrides.has_key?(key + '!')
end

def chomp_last!
  @lines.last.chomp! unless @lines.empty?
  nil
end

def consume_comments(opts = {})
  comment_lines = []
  while !@lines.empty?
    next_line = peek_line
    if opts[:include_blanks] && next_line.strip.empty?
      comment_lines << get_line
    elsif match = next_line.match(REGEXP[:comment_blk])
      comment_lines << get_line
      comment_lines.push(*(grab_lines_until(:terminator => match[0], :preserve_last_line => true)))
      comment_lines << get_line
    elsif next_line.match(REGEXP[:comment])
      comment_lines << get_line
    else
      break
    end
  end
  comment_lines
end

def consume_line_comments
  comment_lines = []
  while !@lines.empty?
    if peek_line.match(REGEXP[:comment])
      comment_lines << get_line
    else
      break
    end
  end
  comment_lines
end

def empty?
  @lines.empty?
end

def get_line
  @lines.shift
end

def grab_lines_until(options = {}, &block)
  buffer = []
  finis = false
  get_line if options[:skip_first_line]
  # save options to locals for minor optimization
  terminator = options[:terminator]
  terminator.chomp! if terminator
  break_on_blank_lines = options[:break_on_blank_lines]
  break_on_list_continuation = options[:break_on_list_continuation]
  while (this_line = self.get_line)
    Asciidoctor.debug { "Reader processing line: '#{this_line}'" }
    finis = true if terminator && this_line.chomp == terminator
    finis = true if !finis && break_on_blank_lines && this_line.strip.empty?
    finis = true if !finis && break_on_list_continuation && this_line.chomp == LIST_CONTINUATION
    finis = true if !finis && block && yield(this_line)
    if finis
      self.unshift(this_line) if options[:preserve_last_line]
      buffer << this_line if options[:grab_last_line]
      break
    end
    if options[:skip_line_comments] && this_line.match(REGEXP[:comment])
      # skip it
    else
      buffer << this_line
    end
  end
  buffer
end

def has_lines?
  !@lines.empty?
end

def initialize(data = [], document = nil, overrides = nil, &block)
  # if document is nil, we assume this is a preprocessed string
  if document.nil?
    @lines = data.is_a?(String) ? data.lines.entries : data.dup
  elsif !data.empty?
    @overrides = overrides || {}
    @document = document
    process(data.is_a?(String) ? data.lines.entries : data, &block)
  else
    @lines = []
  end
  @source = @lines.join
end

def peek_line
  @lines.first.dup if @lines.first
end

def process(data, &block)
  raw_source = []
  include_depth = @document.attr('include-depth', 0).to_i
  data.each do |line|
    if inc = line.match(REGEXP[:include_macro])
      if inc[0].start_with? '\\'
        raw_source << line[1..-1]
      # if running in SafeMode::SECURE or greater, don't process
      # this directive (or should we swallow it?)
      elsif @document.safe >= SafeMode::SECURE
        raw_source << line
      # assume that if a block is given, the developer wants
      # to handle when and how to process the include, even
      # if the include-depth attribute is 0
      elsif block_given?
        raw_source.concat yield(inc[1])
      elsif include_depth > 0
        raw_source.concat File.readlines(@document.normalize_asset_path(inc[1], 'include file'))
      else
        raw_source << line
      end
    else
      raw_source << line
    end
  end
  skip_to = nil
  continuing_value = nil
  continuing_key = nil
  @lines = []
  raw_source.each do |line|
    # normalize line ending to LF (purging occurrences of CRLF)
    line = "#{line.rstrip}\n"
    if skip_to
      skip_to = nil if line.match(skip_to)
    elsif continuing_value
      close_continue = false
      # Lines that start with whitespace and end with a '+' are
      # a continuation, so gobble them up into `value`
      if line.match(REGEXP[:attr_continue])
        continuing_value += ' ' + $1.rstrip
      # An empty line ends a continuation
      elsif line.strip.empty?
        raw_source.unshift(line)
        close_continue = true
      else
        # If this continued line isn't empty and doesn't end with a +, then
        # this is the end of the continuation, no matter what the next line
        # does.
        continuing_value += ' ' + line.strip
        close_continue = true
      end
      if close_continue
        unless attribute_overridden? continuing_key
          @document.attributes[continuing_key] = apply_attribute_value_subs(continuing_value)
        end
        continuing_key = nil
        continuing_value = nil
      end
    elsif line.match(REGEXP[:ifdef_macro])
      attr = $2
      skip = case $1
             when 'ifdef';  !@document.attributes.has_key?(attr)
             when 'ifndef'; @document.attributes.has_key?(attr)
             end
      skip_to = /^endif::#{attr}\[\]\s*\n/ if skip
    elsif line.match(REGEXP[:attr_assign])
      key = sanitize_attribute_name($1)
      value = $2
      if value.match(REGEXP[:attr_continue])
        # attribute value continuation line; grab lines until we run out
        # of continuation lines
        continuing_key = key
        continuing_value = $1.rstrip  # strip off the spaces and +
      else
        unless attribute_overridden? key
          @document.attributes[key] = apply_attribute_value_subs(value)
          if key == 'backend'
            @document.update_backend_attributes()
          end
        end
      end
    elsif line.match(REGEXP[:attr_delete])
      key = sanitize_attribute_name($1)
      unless attribute_overridden? key
        @document.attributes.delete(key)
      end
    elsif !line.match(REGEXP[:endif_macro])
      while line.match(REGEXP[:attr_conditional])
        value = @document.attributes.has_key?($1) ? $2 : ''
        line.sub!(REGEXP[:attr_conditional], value)
      end
      # NOTE leave line comments in as they play a role in flow (such as a list divider)
      @lines << line
    end
  end
  # Process bibliography references, so they're available when text
  # before the reference is being rendered.
  # FIXME we don't have support for bibliography lists yet, so disable for now
  # plus, this should be done while we are walking lines above
  #@lines.each do |line|
  #  if biblio = line.match(REGEXP[:biblio])
  #    @document.register(:ids, biblio[1])
  #  end
  #end
end

def sanitize_attribute_name(name)
  name.gsub(/[^\w\-]/, '').downcase
end

def skip_blank
  skipped = 0
  while has_lines? && @lines.first.strip.empty?
    @lines.shift
    skipped += 1
  end
  skipped
end

def skip_list_continuation
  if has_lines? && @lines.first.chomp == '+'
    @lines.shift
  end
  nil
end

def unshift(*new_lines)
  @lines.unshift(*new_lines) if !new_lines.empty?
  nil
end