class FastImage

# File lib/fastimage.rb, line 182
def initialize(uri, options={})
  @uri = uri
  @options = {
    :type_only        => false,
    :timeout          => DefaultTimeout,
    :raise_on_failure => false,
    :proxy            => nil,
    :http_header      => {}
  }.merge(options)

  @property = @options[:type_only] ? :type : :size

  @type, @state = nil

  if uri.respond_to?(:read)
    fetch_using_read(uri)
  elsif uri.start_with?('data:')
    fetch_using_base64(uri)
  else
    begin
      @parsed_uri = URI.parse(uri)
    rescue URI::InvalidURIError
      fetch_using_file_open
    else
      if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
        fetch_using_http
      else
        fetch_using_file_open
      end
    end
  end

  raise SizeNotFound if @options[:raise_on_failure] && @property == :size && !@size

rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
  ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
  raise ImageFetchFailure if @options[:raise_on_failure]
rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
  raise ImageFetchFailure if @options[:raise_on_failure]
rescue UnknownImageType
  raise UnknownImageType if @options[:raise_on_failure]
rescue CannotParseImage
  if @options[:raise_on_failure]
    if @property == :size
      raise SizeNotFound
    else
      raise ImageFetchFailure
    end
  end

ensure
  uri.rewind if uri.respond_to?(:rewind)

end

# File lib/fastimage.rb, line 136
def self.size(uri, options={})
  new(uri, options).size
end

# File lib/fastimage.rb, line 178
def self.type(uri, options={})
  new(uri, options.merge(:type_only=>true)).type
end

# File lib/fastimage.rb, line 389
def fetch_using_base64(uri)
  data = uri.split(',')[1]
  fetch_using_read StringIO.new(Base64.decode64(data))
end

# File lib/fastimage.rb, line 355
def fetch_using_file_open
  @content_length = File.size?(@uri)
  File.open(@uri) do |s|
    fetch_using_read(s)
  end
end

# File lib/fastimage.rb, line 239
def fetch_using_http
  @redirect_count = 0

  fetch_using_http_from_parsed_uri
end

# File lib/fastimage.rb, line 245
def fetch_using_http_from_parsed_uri
  http_header = {'Accept-Encoding' => 'identity'}.merge(@options[:http_header])

  setup_http
  @http.request_get(@parsed_uri.request_uri, http_header) do |res|
    if res.is_a?(Net::HTTPRedirection) && @redirect_count < 4
      @redirect_count += 1
      begin
        newly_parsed_uri = URI.parse(res['Location'])
        # The new location may be relative - check for that
        if protocol_relative_url?(res['Location'])
          @parsed_uri = URI.parse("#{@parsed_uri.scheme}:#{res['Location']}")
        elsif newly_parsed_uri.scheme != "http" && newly_parsed_uri.scheme != "https"
          @parsed_uri.path = res['Location']
        else
          @parsed_uri = newly_parsed_uri
        end
      rescue URI::InvalidURIError
      else
        fetch_using_http_from_parsed_uri
        break
      end
    end

    raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)

    @content_length = res.content_length

    read_fiber = Fiber.new do
      res.read_body do |str|
        Fiber.yield str
      end
    end

    case res['content-encoding']
    when 'deflate', 'gzip', 'x-gzip'
      begin
        gzip = Zlib::GzipReader.new(FiberStream.new(read_fiber))
      rescue FiberError, Zlib::GzipFile::Error
        raise CannotParseImage
      end

      read_fiber = Fiber.new do
        while data = gzip.readline
          Fiber.yield data
        end
      end
    end

    parse_packets FiberStream.new(read_fiber)

    break  # needed to actively quit out of the fetch
  end
end

# File lib/fastimage.rb, line 331
def fetch_using_read(readable)
  # Pathnames respond to read, but always return the first
  # chunk of the file unlike an IO (even though the
  # docuementation for it refers to IO). Need to supply
  # an offset in this case.
  if readable.is_a?(Pathname)
    read_fiber = Fiber.new do
      offset = 0
      while str = readable.read(LocalFileChunkSize, offset)
        Fiber.yield str
        offset += LocalFileChunkSize
      end
    end
  else
    read_fiber = Fiber.new do
      while str = readable.read(LocalFileChunkSize)
        Fiber.yield str
      end
    end
  end

  parse_packets FiberStream.new(read_fiber)
end

# File lib/fastimage.rb, line 362
def parse_packets(stream)
  @stream = stream

  begin
    result = send("parse_#{@property}")
    if result
      # extract exif orientation if it was found
      if @property == :size && result.size == 3
        @orientation = result.pop
      else
        @orientation = 1
      end

      instance_variable_set("@#{@property}", result)
    else
      raise CannotParseImage
    end
  rescue FiberError
    raise CannotParseImage
  end
end

# File lib/fastimage.rb, line 384
def parse_size
  @type = parse_type unless @type
  send("parse_size_for_#{@type}")
end

# File lib/fastimage.rb, line 566
def parse_size_for_bmp
  d = @stream.read(32)[14..28]
  header = d.unpack("C")[0]

  result = if header == 40
             d[4..-1].unpack('l<l<')
           else
             d[4..8].unpack('SS')
           end

  # ImageHeight is expressed in pixels. The absolute value is necessary because ImageHeight can be negative
  [result.first, result.last.abs]
end

# File lib/fastimage.rb, line 515
def parse_size_for_gif
  @stream.read(11)[6..10].unpack('SS')
end

# File lib/fastimage.rb, line 508
def parse_size_for_ico
  icons = @stream.read(6)[4..5].unpack('v').first
  sizes = icons.times.map { @stream.read(16).unpack('C2').map { |x| x == 0 ? 256 : x } }.sort_by { |w,h| w * h }
  sizes.last
end

# File lib/fastimage.rb, line 523
def parse_size_for_jpeg
  exif = nil
  loop do
    @state = case @state
    when nil
      @stream.skip(2)
      :started
    when :started
      @stream.read_byte == 0xFF ? :sof : :started
    when :sof
      case @stream.read_byte
      when 0xe1 # APP1
        skip_chars = @stream.read_int - 2
        data = @stream.read(skip_chars)
        io = StringIO.new(data)
        if io.read(4) == "Exif"
          io.read(2)
          exif = Exif.new(IOStream.new(io)) rescue nil
        end
        :started
      when 0xe0..0xef
        :skipframe
      when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF
        :readsize
      when 0xFF
        :sof
      else
        :skipframe
      end
    when :skipframe
      skip_chars = @stream.read_int - 2
      @stream.skip(skip_chars)
      :started
    when :readsize
      @stream.skip(3)
      height = @stream.read_int
      width = @stream.read_int
      width, height = height, width if exif && exif.rotated?
      return [width, height, exif ? exif.orientation : 1]
    end
  end
end

# File lib/fastimage.rb, line 519
def parse_size_for_png
  @stream.read(25)[16..24].unpack('NN')
end

# File lib/fastimage.rb, line 697
def parse_size_for_psd
  @stream.read(26).unpack("x14NN").reverse
end

# File lib/fastimage.rb, line 771
def parse_size_for_svg
  svg = Svg.new(@stream)
  svg.width_and_height
end

# File lib/fastimage.rb, line 688
def parse_size_for_tiff
  exif = Exif.new(@stream)
  if exif.rotated?
    [exif.height, exif.width, exif.orientation]
  else
    [exif.width, exif.height, exif.orientation]
  end
end

# File lib/fastimage.rb, line 580
def parse_size_for_webp
  vp8 = @stream.read(16)[12..15]
  _len = @stream.read(4).unpack("V")
  case vp8
  when "VP8 "
    parse_size_vp8
  when "VP8L"
    parse_size_vp8l
  when "VP8X"
    parse_size_vp8x
  else
    nil
  end
end

# File lib/fastimage.rb, line 595
def parse_size_vp8
  w, h = @stream.read(10).unpack("@6vv")
  [w & 0x3fff, h & 0x3fff]
end

# File lib/fastimage.rb, line 600
def parse_size_vp8l
  @stream.skip(1) # 0x2f
  b1, b2, b3, b4 = @stream.read(4).bytes.to_a
  [1 + (((b2 & 0x3f) << 8) | b1), 1 + (((b4 & 0xF) << 10) | (b3 << 2) | ((b2 & 0xC0) >> 6))]
end

# File lib/fastimage.rb, line 606
def parse_size_vp8x
  flags = @stream.read(4).unpack("C")[0]
  b1, b2, b3, b4, b5, b6 = @stream.read(6).unpack("CCCCCC")
  width, height = 1 + b1 + (b2 << 8) + (b3 << 16), 1 + b4 + (b5 << 8) + (b6 << 16)

  if flags & 8 > 0 # exif
    # parse exif for orientation
    # TODO: find or create test images for this
  end

  return [width, height]
end

# File lib/fastimage.rb, line 470
def parse_type
  parsed_type = case @stream.peek(2)
  when "BM"
    :bmp
  when "GI"
    :gif
  when 0xff.chr + 0xd8.chr
    :jpeg
  when 0x89.chr + "P"
    :png
  when "II", "MM"
    :tiff
  when '8B'
    :psd
  when "\0\0"
    # ico has either a 1 (for ico format) or 2 (for cursor) at offset 3
    case @stream.peek(3).bytes.to_a.last
    when 1 then :ico
    when 2 then :cur
    end
  when "RI"
    :webp if @stream.peek(12)[8..11] == "WEBP"
  when "<s"
    :svg
  when /<[?!]/
    # Peek 10 more chars each time, and if end of file is reached just raise
    # unknown. We assume the <svg tag cannot be within 10 chars of the end of
    # the file, and is within the first 250 chars.
    begin
      :svg if (1..25).detect {|n| @stream.peek(10 * n).include?("<svg")}
    rescue FiberError
      nil
    end
  end

  parsed_type or raise UnknownImageType
end

# File lib/fastimage.rb, line 300
def protocol_relative_url?(url)
  url.start_with?("//")
end

# File lib/fastimage.rb, line 304
def proxy_uri
  begin
    if @options[:proxy]
      proxy = URI.parse(@options[:proxy])
    else
      proxy = ENV['http_proxy'] && ENV['http_proxy'] != "" ? URI.parse(ENV['http_proxy']) : nil
    end
  rescue URI::InvalidURIError
    proxy = nil
  end
  proxy
end

# File lib/fastimage.rb, line 317
def setup_http
  proxy = proxy_uri

  if proxy
    @http = Net::HTTP::Proxy(proxy.host, proxy.port).new(@parsed_uri.host, @parsed_uri.port)
  else
    @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
  end
  @http.use_ssl = (@parsed_uri.scheme == "https")
  @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  @http.open_timeout = @options[:timeout]
  @http.read_timeout = @options[:timeout]
end