# frozen_string_literal: true

module HTTPX
  module Plugins
    #
    # This plugin adds compression support. Namely it:
    #
    # * Compresses the request body when passed a supported "Content-Encoding" mime-type;
    # * Decompresses the response body from a supported "Content-Encoding" mime-type;
    #
    # It supports both *gzip* and *deflate*.
    #
    # https://gitlab.com/honeyryderchuck/httpx/wikis/Compression
    #
    module Compression
      class << self
        def configure(klass)
          klass.plugin(:"compression/gzip")
          klass.plugin(:"compression/deflate")
        end

        def extra_options(options)
          encodings = Module.new do
            extend Registry
          end
          options.merge(encodings: encodings)
        end
      end

      module OptionsMethods
        def option_compression_threshold_size(value)
          bytes = Integer(value)
          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?

          bytes
        end

        def option_encodings(value)
          raise TypeError, ":encodings must be a registry" unless value.respond_to?(:registry)

          value
        end
      end

      module RequestMethods
        def initialize(*)
          super
          # forego compression in the Range cases
          if @headers.key?("range")
            @headers.delete("accept-encoding")
          else
            @headers["accept-encoding"] ||= @options.encodings.registry.keys
          end
        end
      end

      module RequestBodyMethods
        def initialize(*, options)
          super
          return if @body.nil?

          threshold = options.compression_threshold_size
          return if threshold && !unbounded_body? && @body.bytesize < threshold

          @headers.get("content-encoding").each do |encoding|
            next if encoding == "identity"

            @body = Encoder.new(@body, options.encodings.registry(encoding).deflater)
          end
          @headers["content-length"] = @body.bytesize unless unbounded_body?
        end
      end

      module ResponseBodyMethods
        using ArrayExtensions::FilterMap

        attr_reader :encodings

        def initialize(*)
          @encodings = []

          super

          return unless @headers.key?("content-encoding")

          # remove encodings that we are able to decode
          @headers["content-encoding"] = @headers.get("content-encoding") - @encodings

          compressed_length = if @headers.key?("content-length")
            @headers["content-length"].to_i
          else
            Float::INFINITY
          end

          @_inflaters = @headers.get("content-encoding").filter_map do |encoding|
            next if encoding == "identity"

            inflater = @options.encodings.registry(encoding).inflater(compressed_length)
            # do not uncompress if there is no decoder available. In fact, we can't reliably
            # continue decompressing beyond that, so ignore.
            break unless inflater

            @encodings << encoding
            inflater
          end

          # this can happen if the only declared encoding is "identity"
          remove_instance_variable(:@_inflaters) if @_inflaters.empty?
        end

        def write(chunk)
          return super unless defined?(@_inflaters) && !chunk.empty?

          chunk = decompress(chunk)
          super(chunk)
        end

        private

        def decompress(buffer)
          @_inflaters.reverse_each do |inflater|
            buffer = inflater.inflate(buffer)
          end
          buffer
        end
      end

      class Encoder
        attr_reader :content_type

        def initialize(body, deflater)
          @content_type = body.content_type
          @body = body.respond_to?(:read) ? body : StringIO.new(body.to_s)
          @buffer = StringIO.new("".b, File::RDWR)
          @deflater = deflater
        end

        def each(&blk)
          return enum_for(__method__) unless blk

          return deflate(&blk) if @buffer.size.zero?

          @buffer.rewind
          @buffer.each(&blk)
        end

        def bytesize
          deflate
          @buffer.size
        end

        private

        def deflate(&blk)
          return unless @buffer.size.zero?

          @body.rewind
          @deflater.deflate(@body, @buffer, chunk_size: 16_384, &blk)
        end
      end
    end
    register_plugin :compression, Compression
  end
end