class SemanticLogger::Appender::Http

def compress_data(data)
  str = StringIO.new
  gz  = Zlib::GzipWriter.new(str)
  gz << data
  gz.close
  str.string
end

def default_formatter
  SemanticLogger::Formatters::Json.new
end

def delete(request_uri = path)
  request = Net::HTTP::Delete.new(request_uri, @header)
  process_request(request)
end

def initialize(url:,
               compress: false,
               ssl: {},
               username: nil,
               password: nil,
               header: {},
               proxy_url: :ENV,
               open_timeout: 2.0,
               read_timeout: 1.0,
               continue_timeout: 1.0,
               **args,
               &block)
  @url              = url
  @proxy_url        = proxy_url
  @ssl_options      = ssl
  @username         = username
  @password         = password
  @compress         = compress
  @open_timeout     = open_timeout
  @read_timeout     = read_timeout
  @continue_timeout = continue_timeout
  # On Ruby v2.0 and greater, Net::HTTP.new already uses a persistent connection if the server allows it
  @header = {
    "Accept"       => "application/json",
    "Content-Type" => "application/json",
    "Connection"   => "keep-alive",
    "Keep-Alive"   => "300"
  }.merge(header)
  @header["Content-Encoding"] = "gzip" if @compress
  uri     = URI.parse(@url)
  @server = uri.host
  unless @server
    raise(ArgumentError, "Invalid format for :url: #{@url.inspect}. Should be similar to: 'http://hostname:port/path'")
  end
  @port     = uri.port
  @username = uri.user if !@username && uri.user
  @password = uri.password if !@password && uri.password
  @path     = uri.path
  # Path cannot be empty
  @path     = "/" if @path == ""
  if uri.scheme == "https"
    @ssl_options[:use_ssl] = true
    @ssl_options[:verify_mode] ||= OpenSSL::SSL::VERIFY_PEER
    @port                      ||= HTTP.https_default_port
  else
    @port ||= HTTP.http_default_port
  end
  @proxy_uri = URI.parse(@proxy_url) if @proxy_url && @proxy_url != :ENV
  @http = nil
  super(**args, &block)
  reopen
end

def log(log)
  message = formatter.call(log, self)
  logger.trace(message)
  post(message)
end

def post(body, request_uri = path)
  request = Net::HTTP::Post.new(request_uri, @header)
  process_request(request, body)
end

def process_request(request, body = nil)
  if body
    request.body = compress ? compress_data(body) : body
  end
  request.basic_auth(@username, @password) if @username
  response = @http.request(request)
  if response.is_a?(Net::HTTPSuccess)
    true
  else
    # Failures are logged to the global semantic logger failsafe logger (Usually stderr or file)
    logger.error("Bad HTTP response from: #{url} code: #{response.code}, #{response.body}")
    false
  end
rescue RuntimeError => e
  reopen
  raise e
end

def put(body, request_uri = path)
  request = Net::HTTP::Put.new(request_uri, @header)
  process_request(request, body)
end

def reopen
  # Close open connection if any
  begin
    @http&.finish
  rescue IOError
    nil
  end
  @http = if @proxy_uri
            Net::HTTP.new(server, port, @proxy_uri.host, @proxy_uri.port, @proxy_uri.user, @proxy_uri.password)
          else
            Net::HTTP.new(server, port, @proxy_url)
          end
  if @ssl_options
    @http.methods.grep(/\A(\w+)=\z/) do |meth|
      key = Regexp.last_match(1).to_sym
      @ssl_options.key?(key) || next
      @http.__send__(meth, @ssl_options[key])
    end
  end
  @http.open_timeout     = @open_timeout
  @http.read_timeout     = @read_timeout
  @http.continue_timeout = @continue_timeout
  @http.start
end