class PDF::Reader::Buffer

def check_size_is_non_zero
  @io.seek(-1, IO::SEEK_END)
  @io.seek(0)
rescue Errno::EINVAL
  raise MalformedPDFError, "PDF file is empty"
end

def empty?
  prepare_tokens if @tokens.size < 3
  @tokens.empty?
end

def find_first_xref_offset
  check_size_is_non_zero
  @io.seek(-TRAILING_BYTECOUNT, IO::SEEK_END) rescue @io.seek(0)
  data = @io.read(TRAILING_BYTECOUNT)
  raise MalformedPDFError, "PDF does not contain EOF marker" if data.nil?
  # the PDF 1.7 spec (section #3.4) says that EOL markers can be either \r, \n, or both.
  lines = data.split(/[\n\r]+/).reverse
  eof_index = lines.index { |l| l.strip[/^%%EOF/] }
  raise MalformedPDFError, "PDF does not contain EOF marker" if eof_index.nil?
  raise MalformedPDFError, "PDF EOF marker does not follow offset" if eof_index >= lines.size-1
  offset = lines[eof_index+1].to_i
  # a byte offset < 0 doesn't make much sense. This is unlikely to happen, but in theory some
  # corrupted PDFs might have a line that looks like a negative int preceding the `%%EOF`
  raise MalformedPDFError, "invalid xref offset" if offset < 0
  offset
end

def in_content_stream?
  @in_content_stream ? true : false
end

def initialize(io, opts = {})
  @io = io
  @tokens = []
  @in_content_stream = opts[:content_stream]
  @io.seek(opts[:seek]) if opts[:seek]
  @pos = @io.pos
end

def merge_indirect_reference
  return if @tokens.size < 3
  return if @tokens[2] != "R"
  token_one = @tokens[0]
  token_two = @tokens[1]
  if token_one.is_a?(String) && token_two.is_a?(String) && token_one.match(DIGITS_ONLY) && token_two.match(DIGITS_ONLY)
    @tokens[0] = PDF::Reader::Reference.new(token_one.to_i, token_two.to_i)
    @tokens.delete_at(2)
    @tokens.delete_at(1)
  end
end

def peek_byte
  byte = @io.getbyte
  @io.seek(-1, IO::SEEK_CUR) if byte
  byte
end

def prepare_hex_token
  str = "".dup
  loop do
    byte = @io.getbyte
    if byte.nil?
      break
    elsif (48..57).include?(byte) || (65..90).include?(byte) || (97..122).include?(byte)
      str << byte
    elsif byte <= 32
      # ignore it
    else
      @tokens << str if str.size > 0
      @tokens << ">" if byte != 0x3E # '>'
      @tokens << byte.chr
      break
    end
  end
end

def prepare_inline_token
  idstart = @io.pos
  prevchr = ''
  eisize = 0 # how many chars in the end marker
  seeking = 'E' # what are we looking for now?
  loop do
    chr = @io.read(1)
    break if chr.nil?
    case seeking
    when 'E'
      if chr == 'E'
        seeking = 'I'
        if WHITE_SPACE.include? prevchr
          eisize = 3 # include whitespace in delimiter, i.e. drop from data
        else # assume the EI immediately follows the data
          eisize = 2 # leave prevchr in data
        end
      end
    when 'I'
      if chr == 'I'
        seeking = ''
      else
        seeking = 'E'
      end
    when ''
      if WHITE_SPACE.include? chr
        eisize += 1 # Drop trailer
        break
      else
        seeking = 'E'
      end
    end
    prevchr = chr.is_a?(String) ? chr : ''
  end
  unless seeking == ''
    raise MalformedPDFError, "EI terminator not found"
  end
  eiend = @io.pos
  @io.seek(idstart, IO::SEEK_SET)
  str = @io.read(eiend - eisize - idstart) # get the ID content
  @tokens << str.freeze if str
end

def prepare_literal_token
  str = "".dup
  count = 1
  while count > 0
    byte = @io.getbyte
    if byte.nil?
      count = 0 # unbalanced params
    elsif byte == 0x5C
      str << byte << @io.getbyte
    elsif byte == 0x28 # "("
      str << "("
      count += 1
    elsif byte == 0x29 # ")"
      count -= 1
      str << ")" unless count == 0
    else
      str << byte unless count == 0
    end
  end
  @tokens << str if str.size > 0
  @tokens << ")"
end

def prepare_regular_token
  tok = "".dup
  loop do
    byte = @io.getbyte
    case byte
    when nil
      break
    when 0x25
      # comment, ignore everything until the next EOL char
      loop do
        commentbyte = @io.getbyte
        break if commentbyte.nil? || commentbyte == 0x0A || commentbyte == 0x0D
      end
    when *TOKEN_WHITESPACE
      # white space, token finished
      @tokens << tok if tok.size > 0
      #If the token was empty, chomp the rest of the whitespace too
      while TOKEN_WHITESPACE.include?(peek_byte) && tok.size == 0
        @io.getbyte
      end
      tok = "".dup
      break
    when 0x3C
      # opening delimiter '<', start of new token
      @tokens << tok if tok.size > 0
      if peek_byte == 0x3C # check if token is actually '<<'
        @io.getbyte
        @tokens << "<<"
      else
        @tokens << "<"
      end
      tok = "".dup
      break
    when 0x3E
      # closing delimiter '>', start of new token
      @tokens << tok if tok.size > 0
      if peek_byte == 0x3E # check if token is actually '>>'
        @io.getbyte
        @tokens << ">>"
      else
        @tokens << ">"
      end
      tok = "".dup
      break
    when 0x28, 0x5B, 0x7B
      # opening delimiter, start of new token
      @tokens << tok if tok.size > 0
      @tokens << byte.chr
      tok = "".dup
      break
    when 0x29, 0x5D, 0x7D
      # closing delimiter
      @tokens << tok if tok.size > 0
      @tokens << byte.chr
      tok = "".dup
      break
    when 0x2F
      # PDF name, start of new token
      @tokens << tok if tok.size > 0
      @tokens << byte.chr
      @tokens << "" if byte == 0x2F && ([nil, 0x20, 0x0A] + TOKEN_DELIMITER).include?(peek_byte)
      tok = "".dup
      break
    else
      tok << byte
    end
  end
  @tokens << tok if tok.size > 0
end

def prepare_tokens
  10.times do
    case state
    when :literal_string then prepare_literal_token
    when :hex_string     then prepare_hex_token
    when :regular        then prepare_regular_token
    when :inline         then prepare_inline_token
    end
  end
  save_pos
end

def read(bytes, opts = {})
  reset_pos
  if opts[:skip_eol]
    @io.seek(-1, IO::SEEK_CUR)
    str = @io.read(2)
    if str.nil?
      return nil
    elsif str == CRLF # This MUST be done before checking for CR alone
      # do nothing
    elsif str[0, 1] == LF || str[0, 1] == CR # LF or CR alone
      @io.seek(-1, IO::SEEK_CUR)
    else
      @io.seek(-2, IO::SEEK_CUR)
    end
  end
  bytes = @io.read(bytes)
  save_pos
  bytes
end

def reset_pos
  @io.seek(@pos) if @io.pos != @pos
end

def save_pos
  @pos = @io.pos
end

def state
  case @tokens.last
  when LEFT_PAREN then :literal_string
  when LESS_THAN then :hex_string
  when STREAM then :stream
  when ID
    if in_content_stream?  && @tokens[-2] != FWD_SLASH
      :inline
    else
      :regular
    end
  else
    :regular
  end
end

def token
  reset_pos
  prepare_tokens if @tokens.size < 3
  merge_indirect_reference
  prepare_tokens if @tokens.size < 3
  @tokens.shift
end