class Asciidoctor::Reader

def advance
  shift ? true : false
end

def cursor
  Cursor.new @file, @dir, @path, @lineno
end

def cursor_at_line lineno
  Cursor.new @file, @dir, @path, lineno
end

def cursor_at_mark
  @mark ? Cursor.new(*@mark) : cursor
end

def cursor_at_prev_line
  Cursor.new @file, @dir, @path, @lineno - 1
end

def cursor_before_mark
  if @mark
    m_file, m_dir, m_path, m_lineno = @mark
    Cursor.new m_file, m_dir, m_path, m_lineno - 1
  else
    Cursor.new @file, @dir, @path, @lineno - 1
  end
end

def discard_save
  @saved = nil
end

def empty?
  if @lines.empty?
    @look_ahead = 0
    true
  else
    false
  end
end

def has_more_lines?
  if @lines.empty?
    @look_ahead = 0
    false
  else
    true
  end
end

def initialize data = nil, cursor = nil, opts = {}
  if !cursor
    @file = nil
    @dir = '.'
    @path = '<stdin>'
    @lineno = 1
  elsif ::String === cursor
    @file = cursor
    @dir, @path = ::File.split @file
    @lineno = 1
  else
    if (@file = cursor.file)
      @dir = cursor.dir || (::File.dirname @file)
      @path = cursor.path || (::File.basename @file)
    else
      @dir = cursor.dir || '.'
      @path = cursor.path || '<stdin>'
    end
    @lineno = cursor.lineno || 1
  end
  @lines = (@source_lines = prepare_lines data, opts).reverse
  @mark = nil
  @look_ahead = 0
  @process_lines = true
  @unescape_next_line = false
  @unterminated = nil
  @saved = nil
end

def line_info
  %(#{@path}: line #{@lineno})
end

def lines
  @lines.reverse
end

def mark
  @mark = @file, @dir, @path, @lineno
end

def next_line_empty?
  peek_line.nil_or_empty?
end

def peek_line direct = false
  while true
    next_line = @lines[-1]
    if direct || @look_ahead > 0
      return @unescape_next_line ? (next_line.slice 1, next_line.length) : next_line
    elsif next_line
      # FIXME the problem with this approach is that we aren't
      # retaining the modified line (hence the @unescape_next_line tweak)
      # perhaps we need a stack of proxied lines
      if (line = process_line next_line)
        return line
      end
    else
      @look_ahead = 0
      return
    end
  end
end

def peek_lines num = nil, direct = false
  old_look_ahead = @look_ahead
  result = []
  (num || MAX_INT).times do
    if (line = direct ? shift : read_line)
      result << line
    else
      @lineno -= 1 if direct
      break
    end
  end
  unless result.empty?
    unshift_all result
    @look_ahead = old_look_ahead if direct
  end
  result
end

def prepare_lines data, opts = {}
  if (normalize = opts[:normalize])
    ::Array === data ? (Helpers.prepare_source_array data, normalize != :chomp) : (Helpers.prepare_source_string data, normalize != :chomp)
  elsif ::Array === data
    data.drop 0
  elsif data
    data.chomp.split LF, -1
  else
    []
  end
rescue
  if (::Array === data ? data.join : data.to_s).valid_encoding?
    raise
  else
    raise ::ArgumentError, 'source is either binary or contains invalid Unicode data'
  end
end

def process_line line
  @look_ahead += 1 if @process_lines
  line
end

def read
  read_lines.join LF
end

def read_line
  # has_more_lines? triggers preprocessor
  shift if @look_ahead > 0 || has_more_lines?
end

def read_lines
  lines = []
  # has_more_lines? triggers preprocessor
  lines << shift while has_more_lines?
  lines
end

def read_lines_until options = {}
  result = []
  if @process_lines && options[:skip_processing]
    @process_lines = false
    restore_process_lines = true
  end
  if (terminator = options[:terminator])
    start_cursor = options[:cursor] || cursor
    break_on_blank_lines = false
    break_on_list_continuation = false
  else
    break_on_blank_lines = options[:break_on_blank_lines]
    break_on_list_continuation = options[:break_on_list_continuation]
  end
  skip_comments = options[:skip_line_comments]
  line_read = line_restored = nil
  shift if options[:skip_first_line]
  while (line = read_line)
    if terminator ? line == terminator : ((break_on_blank_lines && line.empty?) ||
        (break_on_list_continuation && line_read && line == LIST_CONTINUATION && (options[:preserve_last_line] = true)) ||
        (block_given? && (yield line)))
      result << line if options[:read_last_line]
      if options[:preserve_last_line]
        unshift line
        line_restored = true
      end
      break
    end
    unless skip_comments && (line.start_with? '//') && !(line.start_with? '///')
      result << line
      line_read = true
    end
  end
  if restore_process_lines
    @process_lines = true
    @look_ahead -= 1 if line_restored && !terminator
  end
  if terminator && terminator != line && (context = options.fetch :context, terminator)
    start_cursor = cursor_at_mark if start_cursor == :at_mark
    logger.warn message_with_context %(unterminated #{context} block), source_location: start_cursor
    @unterminated = true
  end
  result
end

def replace_next_line replacement
  shift
  unshift replacement
  true
end

def restore_save
  if @saved
    @saved.each do |name, val|
      instance_variable_set name, val
    end
    @saved = nil
  end
end

def save
  @saved = {}.tap do |accum|
    instance_variables.each do |name|
      unless name == :@saved || name == :@source_lines
        accum[name] = ::Array === (val = instance_variable_get name) ? (val.drop 0) : val
      end
    end
  end
  nil
end

def shift
  @lineno += 1
  @look_ahead -= 1 unless @look_ahead == 0
  @lines.pop
end

def skip_blank_lines
  return if empty?
  num_skipped = 0
  # optimized code for shortest execution path
  while (next_line = peek_line)
    if next_line.empty?
      shift
      num_skipped += 1
    else
      return num_skipped
    end
  end
end

def skip_comment_lines
  return if empty?
  while (next_line = peek_line) && !next_line.empty?
    if next_line.start_with? '//'
      if next_line.start_with? '///'
        if (ll = next_line.length) > 3 && next_line == '/' * ll
          read_lines_until terminator: next_line, skip_first_line: true, read_last_line: true, skip_processing: true, context: :comment
        else
          break
        end
      else
        shift
      end
    else
      break
    end
  end
  nil
end

def skip_line_comments
  return [] if empty?
  comment_lines = []
  # optimized code for shortest execution path
  while (next_line = peek_line) && !next_line.empty?
    if next_line.start_with? '//'
      comment_lines << shift
    else
      break
    end
  end
  comment_lines
end

def source
  @source_lines.join LF
end

def string
  @lines.reverse.join LF
end

def terminate
  @lineno += @lines.size
  @lines.clear
  @look_ahead = 0
  nil
end

def to_s
  %(#<#{self.class}@#{object_id} {path: #{@path.inspect}, line: #{@lineno}}>)
end

def unshift line
  @lineno -= 1
  @look_ahead += 1
  @lines.push line
  nil
end

def unshift_all lines_to_restore
  @lineno -= lines_to_restore.size
  @look_ahead += lines_to_restore.size
  if lines_to_restore.respond_to? :reverse
    @lines.push(*lines_to_restore.reverse)
  else
    lines_to_restore.reverse_each {|it| @lines.push it }
  end
  nil
end

def unshift_all lines_to_restore
  @lineno -= lines_to_restore.size
  @look_ahead += lines_to_restore.size
  @lines.push(*lines_to_restore.reverse)
  nil
end

def unshift_line line_to_restore
  unshift line_to_restore
  nil
end

def unshift_lines lines_to_restore
  unshift_all lines_to_restore
end