/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.vertx.rxjava.core.http;

import java.util.Map;
import rx.Observable;
import rx.Single;
import io.vertx.core.http.StreamPriority;
import java.util.List;
import io.vertx.core.http.HttpVersion;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;

Represents a client-side HTTP response.
 Vert.x provides you with one of these via the handler that was provided when creating the HttpClientRequest or that was set on the HttpClientRequest instance. 
 It implements ReadStream so it can be used with Pump to pump data with flow control. 
 NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen. /**
 * Represents a client-side HTTP response.
 * <p>
 * Vert.x provides you with one of these via the handler that was provided when creating the {@link io.vertx.rxjava.core.http.HttpClientRequest}
 * or that was set on the {@link io.vertx.rxjava.core.http.HttpClientRequest} instance.
 * <p>
 * It implements {@link io.vertx.rxjava.core.streams.ReadStream} so it can be used with
 * {@link io.vertx.rxjava.core.streams.Pump} to pump data with flow control.
 *
 * <p/>
 * NOTE: This class has been automatically generated from the {@link io.vertx.core.http.HttpClientResponse original} non RX-ified interface using Vert.x codegen.
 */

@io.vertx.lang.rx.RxGen(io.vertx.core.http.HttpClientResponse.class)
public class HttpClientResponse implements io.vertx.rxjava.core.streams.ReadStream<io.vertx.rxjava.core.buffer.Buffer> {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    HttpClientResponse that = (HttpClientResponse) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.rx.TypeArg<HttpClientResponse> __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new HttpClientResponse((io.vertx.core.http.HttpClientResponse) obj),
    HttpClientResponse::getDelegate
  );

  private final io.vertx.core.http.HttpClientResponse delegate;
  
  public HttpClientResponse(io.vertx.core.http.HttpClientResponse delegate) {
    this.delegate = delegate;
  }

  public io.vertx.core.http.HttpClientResponse getDelegate() {
    return delegate;
  }

  private rx.Observable<io.vertx.rxjava.core.buffer.Buffer> observable;

  public synchronized rx.Observable<io.vertx.rxjava.core.buffer.Buffer> toObservable() {
    if (observable == null) {
      java.util.function.Function<io.vertx.core.buffer.Buffer, io.vertx.rxjava.core.buffer.Buffer> conv = io.vertx.rxjava.core.buffer.Buffer::newInstance;
      observable = io.vertx.rx.java.RxHelper.toObservable(delegate, conv);
    }
    return observable;
  }

  
Pause this stream and return a  to transfer the elements of this stream to a destination .

The stream will be resumed when the pipe will be wired to a WriteStream.
Returns:
a pipe/**
   * Pause this stream and return a  to transfer the elements of this stream to a destination .
   * <p/>
   * The stream will be resumed when the pipe will be wired to a <code>WriteStream</code>.
   * @return a pipe
   */
  public io.vertx.rxjava.core.streams.Pipe<io.vertx.rxjava.core.buffer.Buffer> pipe() { 
    io.vertx.rxjava.core.streams.Pipe<io.vertx.rxjava.core.buffer.Buffer> ret = io.vertx.rxjava.core.streams.Pipe.newInstance(delegate.pipe(), (io.vertx.lang.rx.TypeArg)io.vertx.rxjava.core.buffer.Buffer.__TYPE_ARG);
    return ret;
  }

  
Like ReadStream.pipeTo but with no completion handler. 
Params:
dst – /**
   * Like {@link io.vertx.rxjava.core.streams.ReadStream#pipeTo} but with no completion handler.
   * @param dst 
   */
  public void pipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer> dst) { 
    delegate.pipeTo(dst.getDelegate());
  }

  
Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be
called with the result.
Params:
dst – the destination write stream
handler – /**
   * Pipe this <code>ReadStream</code> to the <code>WriteStream</code>.
   * <p>
   * Elements emitted by this stream will be written to the write stream until this stream ends or fails.
   * <p>
   * Once this stream has ended or failed, the write stream will be ended and the <code>handler</code> will be
   * called with the result.
   * @param dst the destination write stream
   * @param handler 
   */
  public void pipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer> dst, Handler<AsyncResult<Void>> handler) { 
    delegate.pipeTo(dst.getDelegate(), handler);
  }

    
Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be
called with the result.
Params:
dst – the destination write stream
Returns:
Deprecated:
use rxPipeTo instead/**
   * Pipe this <code>ReadStream</code> to the <code>WriteStream</code>.
   * <p>
   * Elements emitted by this stream will be written to the write stream until this stream ends or fails.
   * <p>
   * Once this stream has ended or failed, the write stream will be ended and the <code>handler</code> will be
   * called with the result.
   * @param dst the destination write stream
   * @return 
   * @deprecated use {@link #rxPipeTo} instead
   */
  @Deprecated()
  public Observable<Void> pipeToObservable(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer> dst) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pipeTo(dst, handler.toHandler());
    return handler;
  }

  
Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be
called with the result.
Params:
dst – the destination write stream
Returns:
/**
   * Pipe this <code>ReadStream</code> to the <code>WriteStream</code>.
   * <p>
   * Elements emitted by this stream will be written to the write stream until this stream ends or fails.
   * <p>
   * Once this stream has ended or failed, the write stream will be ended and the <code>handler</code> will be
   * called with the result.
   * @param dst the destination write stream
   * @return 
   */
  public Single<Void> rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer> dst) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pipeTo(dst, fut);
    }));
  }

  public io.vertx.rxjava.core.http.HttpClientResponse fetch(long amount) { 
    delegate.fetch(amount);
    return this;
  }

  public io.vertx.rxjava.core.http.HttpClientResponse resume() { 
    delegate.resume();
    return this;
  }

  public io.vertx.rxjava.core.http.HttpClientResponse exceptionHandler(Handler<Throwable> handler) { 
    delegate.exceptionHandler(handler);
    return this;
  }

  public io.vertx.rxjava.core.http.HttpClientResponse handler(Handler<io.vertx.rxjava.core.buffer.Buffer> handler) { 
    delegate.handler(new Handler<io.vertx.core.buffer.Buffer>() {
      public void handle(io.vertx.core.buffer.Buffer event) {
        handler.handle(io.vertx.rxjava.core.buffer.Buffer.newInstance(event));
      }
    });
    return this;
  }

  public io.vertx.rxjava.core.http.HttpClientResponse pause() { 
    delegate.pause();
    return this;
  }

  public io.vertx.rxjava.core.http.HttpClientResponse endHandler(Handler<Void> endHandler) { 
    delegate.endHandler(endHandler);
    return this;
  }

  
Returns:
the version of the response/**
   * @return the version of the response
   */
  public HttpVersion version() { 
    HttpVersion ret = delegate.version();
    return ret;
  }

  
Returns:
the status code of the response/**
   * @return the status code of the response
   */
  public int statusCode() { 
    int ret = delegate.statusCode();
    return ret;
  }

  
Returns:
the status message of the response/**
   * @return the status message of the response
   */
  public String statusMessage() { 
    String ret = delegate.statusMessage();
    return ret;
  }

  
Returns:
the headers/**
   * @return the headers
   */
  public io.vertx.rxjava.core.MultiMap headers() { 
    if (cached_0 != null) {
      return cached_0;
    }
    io.vertx.rxjava.core.MultiMap ret = io.vertx.rxjava.core.MultiMap.newInstance(delegate.headers());
    cached_0 = ret;
    return ret;
  }

  
Return the first header value with the specified name
Params:
headerName – the header name
Returns:
the header value/**
   * Return the first header value with the specified name
   * @param headerName the header name
   * @return the header value
   */
  public String getHeader(String headerName) { 
    String ret = delegate.getHeader(headerName);
    return ret;
  }

  
Return the first trailer value with the specified name
Params:
trailerName – the trailer name
Returns:
the trailer value/**
   * Return the first trailer value with the specified name
   * @param trailerName the trailer name
   * @return the trailer value
   */
  public String getTrailer(String trailerName) { 
    String ret = delegate.getTrailer(trailerName);
    return ret;
  }

  
Returns:
the trailers/**
   * @return the trailers
   */
  public io.vertx.rxjava.core.MultiMap trailers() { 
    if (cached_1 != null) {
      return cached_1;
    }
    io.vertx.rxjava.core.MultiMap ret = io.vertx.rxjava.core.MultiMap.newInstance(delegate.trailers());
    cached_1 = ret;
    return ret;
  }

  
Returns:
the Set-Cookie headers (including trailers)/**
   * @return the Set-Cookie headers (including trailers)
   */
  public List<String> cookies() { 
    if (cached_2 != null) {
      return cached_2;
    }
    List<String> ret = delegate.cookies();
    cached_2 = ret;
    return ret;
  }

  
Convenience method for receiving the entire request body in one piece.

This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until
the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.
Params:
bodyHandler – This handler will be called after all the body has been received
Returns:
/**
   * Convenience method for receiving the entire request body in one piece.
   * <p>
   * This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until
   * the whole body received. Don't use this if your request body is large - you could potentially run out of RAM.
   * @param bodyHandler This handler will be called after all the body has been received
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientResponse bodyHandler(Handler<io.vertx.rxjava.core.buffer.Buffer> bodyHandler) { 
    delegate.bodyHandler(new Handler<io.vertx.core.buffer.Buffer>() {
      public void handle(io.vertx.core.buffer.Buffer event) {
        bodyHandler.handle(io.vertx.rxjava.core.buffer.Buffer.newInstance(event));
      }
    });
    return this;
  }

  
Set an custom frame handler. The handler will get notified when the http stream receives an custom HTTP/2
frame. HTTP/2 permits extension of the protocol.
Params:
handler – 
Returns:
a reference to this, so the API can be used fluently/**
   * Set an custom frame handler. The handler will get notified when the http stream receives an custom HTTP/2
   * frame. HTTP/2 permits extension of the protocol.
   * @param handler 
   * @return a reference to this, so the API can be used fluently
   */
  public io.vertx.rxjava.core.http.HttpClientResponse customFrameHandler(Handler<io.vertx.rxjava.core.http.HttpFrame> handler) { 
    delegate.customFrameHandler(new Handler<io.vertx.core.http.HttpFrame>() {
      public void handle(io.vertx.core.http.HttpFrame event) {
        handler.handle(io.vertx.rxjava.core.http.HttpFrame.newInstance(event));
      }
    });
    return this;
  }

  
Get a net socket for the underlying connection of this request.

USE THIS WITH CAUTION! Writing to the socket directly if you don't know what you're doing can easily break the HTTP protocol.

HTTP/1.1 pipe-lined requests cannot support net socket upgrade.
 One valid use-case for calling this is to receive the NetSocket after a HTTP CONNECT was issued to the remote peer and it responded with a status code of 200. 
Returns:
the net socket/**
   * Get a net socket for the underlying connection of this request.
   * <p>
   * USE THIS WITH CAUTION! Writing to the socket directly if you don't know what you're doing can easily break the HTTP protocol.
   * <p>
   * HTTP/1.1 pipe-lined requests cannot support net socket upgrade.
   * <p>
   * One valid use-case for calling this is to receive the {@link io.vertx.rxjava.core.net.NetSocket} after a HTTP CONNECT was issued to the
   * remote peer and it responded with a status code of 200.
   * @return the net socket
   */
  public io.vertx.rxjava.core.net.NetSocket netSocket() { 
    if (cached_3 != null) {
      return cached_3;
    }
    io.vertx.rxjava.core.net.NetSocket ret = io.vertx.rxjava.core.net.NetSocket.newInstance(delegate.netSocket());
    cached_3 = ret;
    return ret;
  }

  
Returns:
the corresponding request/**
   * @return the corresponding request
   */
  public io.vertx.rxjava.core.http.HttpClientRequest request() { 
    if (cached_4 != null) {
      return cached_4;
    }
    io.vertx.rxjava.core.http.HttpClientRequest ret = io.vertx.rxjava.core.http.HttpClientRequest.newInstance(delegate.request());
    cached_4 = ret;
    return ret;
  }

  
Set an handler for stream priority changes.

This is not implemented for HTTP/1.x.
Params:
handler – the handler to be called when the stream priority changes
Returns:
/**
   * Set an handler for stream priority changes.
   * <p/>
   * This is not implemented for HTTP/1.x.
   * @param handler the handler to be called when the stream priority changes
   * @return 
   */
  public io.vertx.rxjava.core.http.HttpClientResponse streamPriorityHandler(Handler<StreamPriority> handler) { 
    delegate.streamPriorityHandler(handler);
    return this;
  }

  
Return the first header value with the specified name
Params:
headerName – the header name
Returns:
the header value/**
   * Return the first header value with the specified name
   * @param headerName the header name
   * @return the header value
   */
  public String getHeader(CharSequence headerName) { 
    String ret = delegate.getHeader(headerName);
    return ret;
  }

  private io.vertx.rxjava.core.MultiMap cached_0;
  private io.vertx.rxjava.core.MultiMap cached_1;
  private List<String> cached_2;
  private io.vertx.rxjava.core.net.NetSocket cached_3;
  private io.vertx.rxjava.core.http.HttpClientRequest cached_4;

  public static  HttpClientResponse newInstance(io.vertx.core.http.HttpClientResponse arg) {
    return arg != null ? new HttpClientResponse(arg) : null;
  }
}