class PDF::Reader::Buffer

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

def find_first_xref_offset
  @io.seek(-1024, IO::SEEK_END) rescue @io.seek(0)
  data = @io.read(1024)
  # 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
  lines[eof_index+1].to_i
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"
  if @tokens[0].match(/\d+/) && @tokens[1].match(/\d+/)
    @tokens[0] = PDF::Reader::Reference.new(@tokens[0].to_i, @tokens[1].to_i)
    @tokens[1] = nil
    @tokens[2] = nil
    @tokens.compact!
  end
end

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

def prepare_hex_token
  str = ""
  finished = false
  while !finished
    byte = @io.getbyte
    if byte.nil?
      finished = true # unbalanced params
    elsif (48..57).include?(byte) || (65..90).include?(byte) || (97..122).include?(byte)
      str << byte.chr
    elsif byte <= 32
      # ignore it
    else
      @tokens << str if str.size > 0
      @tokens << ">" if byte != 0x3E # '>'
      @tokens << byte.chr
      finished = true
    end
  end
end

def prepare_inline_token
  str = ""
  buffer = []
  until buffer[0] =~ /\s/ && buffer[1, 2] == ["E", "I"]
    chr = @io.read(1)
    buffer << chr
    if buffer.length > 3
      str << buffer.shift
    end
  end
  @tokens << string_token(str.strip)
  @io.seek(-3, IO::SEEK_CUR) unless chr.nil?
end

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

def prepare_regular_token
  tok = ""
  while byte = @io.getbyte
    case byte
    when 0x25
      # comment, ignore everything until the next EOL char
      done = false
      while !done
        byte = @io.getbyte
        done = true if byte.nil? || byte == 0x0A || byte == 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 = ""
      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 = ""
      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 << byte.chr
      end
      tok = ""
      break
    when 0x28, 0x5B, 0x7B
      # opening delimiter, start of new token
      @tokens << tok if tok.size > 0
      @tokens << byte.chr
      tok = ""
      break
    when 0x29, 0x5D, 0x7D
      # closing delimiter
      @tokens << tok if tok.size > 0
      @tokens << byte.chr
      tok = ""
      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].include?(peek_byte)
      tok = ""
      break
    else
      tok << byte.chr
    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 == "\r\n"
      # do nothing
    elsif str[0,1] == "\n"
      @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 "(" then :literal_string
  when "<" then :hex_string
  when "stream" then :stream
  when "ID"
    if in_content_stream?  && @tokens[-2] != "/"
      :inline
    else
      :regular
    end
  else
    :regular
  end
end

def string_token(token)
  def token.to_token
    to_s
  end
  token
end

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