class Asciidoctor::Reader

def advance direct = true
  !!read_line(direct)
end

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

def eof?
  !has_more_lines?
end

def has_more_lines?
  !(@eof || (@eof = peek_line.nil?))
end

def initialize data = nil, cursor = nil, opts = {:normalize => false}
  if !cursor
    @file = @dir = nil
    @path = '<stdin>'
    @lineno = 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
  elsif cursor.is_a? ::String
    @file = cursor
    @dir, @path = ::File.split @file
    @lineno = 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
  else
    @file = cursor.file
    @dir = cursor.dir
    @path = cursor.path || '<stdin>'
    if @file
      unless @dir
        # REVIEW might to look at this assignment closer
        @dir = ::File.dirname @file
        @dir = nil if @dir == '.' # right?
      end
      unless cursor.path
        @path = ::File.basename @file
      end
    end
    @lineno = cursor.lineno || 1 # IMPORTANT lineno assignment must proceed prepare_lines call!
  end
  @lines = data ? (prepare_lines data, opts) : []
  @source_lines = @lines.dup
  @eof = @lines.empty?
  @look_ahead = 0
  @process_lines = true
  @unescape_next_line = false
end

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

def lines
  @lines.dup
end

def next_line_empty?
  peek_line.nil_or_empty?
end

def peek_line direct = false
  if direct || @look_ahead > 0
    @unescape_next_line ? @lines[0][1..-1] : @lines[0]
  elsif @eof || @lines.empty?
    @eof = true
    @look_ahead = 0
    nil
  else
    # 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 proxy lines
    if !(line = process_line @lines[0])
      peek_line
    else
      line
    end
  end
end

def peek_lines num = 1, direct = true
  old_look_ahead = @look_ahead
  result = []
  num.times do
    if (line = read_line direct)
      result << line
    else
      break
    end
  end
  unless result.empty?
    result.reverse_each {|line| unshift line }
    @look_ahead = old_look_ahead if direct
  end
  result
end

def prepare_lines data, opts = {}
  if data.is_a? ::String
    if opts[:normalize]
      Helpers.normalize_lines_from_string data
    else
      data.split EOL
    end
  else
    if opts[:normalize]
      Helpers.normalize_lines_array data
    else
      data.dup
    end
  end
end

def prev_line_info
  %(#{@path}: line #{@lineno - 1})
end

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

def read
  read_lines * EOL
end

def read_line direct = false
  if direct || @look_ahead > 0 || has_more_lines?
    shift
  else
    nil
  end
end

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

def read_lines_until options = {}
  result = []
  advance if options[:skip_first_line]
  if @process_lines && options[:skip_processing]
    @process_lines = false
    restore_process_lines = true
  else
    restore_process_lines = false
  end
  if (terminator = options[:terminator])
    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_line_comments = options[:skip_line_comments]
  line_read = false
  line_restored = false
  
  complete = false
  while !complete && (line = read_line)
    complete = while true
      break true if terminator && line == terminator
      # QUESTION: can we get away with line.empty? here?
      break true if break_on_blank_lines && line.empty?
      if break_on_list_continuation && line_read && line == LIST_CONTINUATION
        options[:preserve_last_line] = true
        break true
      end
      break true if block_given? && (yield line)
      break false
    end
    if complete
      if options[:read_last_line]
        result << line
        line_read = true
      end
      if options[:preserve_last_line]
        restore_line line
        line_restored = true
      end
    else
      unless skip_line_comments && line.start_with?('//') && CommentLineRx =~ line
        result << line
        line_read = true
      end
    end
  end
  if restore_process_lines
    @process_lines = true
    @look_ahead -= 1 if line_restored && !terminator
  end
  result
end

def replace_line replacement
  advance
  unshift replacement
  nil
end

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

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

def skip_comment_lines opts = {}
  return [] if eof?
  comment_lines = []
  include_blank_lines = opts[:include_blank_lines]
  while (next_line = peek_line)
    if include_blank_lines && next_line.empty?
      comment_lines << shift
    elsif (commentish = next_line.start_with?('//')) && (match = CommentBlockRx.match(next_line))
      comment_lines << shift
      comment_lines.push(*(read_lines_until(:terminator => match[0], :read_last_line => true, :skip_processing => true)))
    elsif commentish && CommentLineRx =~ next_line
      comment_lines << shift
    else
      break
    end
  end
  comment_lines
end

def skip_line_comments
  return [] if eof?
  comment_lines = []
  # optimized code for shortest execution path
  while (next_line = peek_line)
    if CommentLineRx =~ next_line
      comment_lines << shift
    else
      break
    end
  end
  comment_lines
end

def source
  @source_lines * EOL
end

def string
  @lines * EOL
end

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

def to_s
  line_info
end

def unshift line
  @lineno -= 1
  @look_ahead += 1
  @eof = false
  @lines.unshift line
end

def unshift_line line_to_restore
  unshift line_to_restore
  nil
end

def unshift_lines lines_to_restore
  # QUESTION is it faster to use unshift(*lines_to_restore)?
  lines_to_restore.reverse_each {|line| unshift line }
  nil
end