// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/cronet/android/cronet_url_request_adapter.h"

#include <limits>
#include <utility>
#include <vector>

#include "base/functional/bind.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "components/cronet/android/cronet_context_adapter.h"
#include "components/cronet/android/io_buffer_with_byte_buffer.h"
#include "components/cronet/android/shared_dictionary_with_byte_buffer.h"
#include "components/cronet/android/url_request_close_source.h"
#include "components/cronet/android/url_request_error.h"
#include "components/cronet/metrics_util.h"
#include "net/base/idempotency.h"
#include "net/base/load_flags.h"
#include "net/base/load_states.h"
#include "net/base/net_errors.h"
#include "net/base/proxy_server.h"
#include "net/base/request_priority.h"
#include "net/base/upload_data_stream.h"
#include "net/cert/cert_status_flags.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/http/http_util.h"
#include "net/ssl/ssl_info.h"
#include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
#include "net/url_request/redirect_info.h"
#include "net/url_request/url_request_context.h"

// Must come after all headers that specialize FromJniType() / ToJniType().
#include "components/cronet/android/cronet_jni_headers/CronetUrlRequest_jni.h"

using base::android::ConvertUTF8ToJavaString;
using base::android::JavaRef;

namespace cronet {
namespace {

base::android::ScopedJavaLocalRef<jobjectArray> ConvertResponseHeadersToJava(
    JNIEnv* env,
    const net::HttpResponseHeaders* headers) {
  std::vector<std::string> response_headers;
  // Returns an empty array if |headers| is nullptr.
  if (headers != nullptr) {
    size_t iter = 0;
    std::string header_name;
    std::string header_value;
    while (headers->EnumerateHeaderLines(&iter, &header_name, &header_value)) {
      response_headers.push_back(header_name);
      response_headers.push_back(header_value);
    }
  }
  return base::android::ToJavaArrayOfStrings(env, response_headers);
}

}  // namespace

static jlong JNI_CronetUrlRequest_CreateRequestAdapter(
    JNIEnv* env,
    const JavaRef<jobject>& jurl_request,
    jlong jurl_request_context_adapter,
    const JavaRef<jstring>& jurl_string,
    jint jpriority,
    jboolean jdisable_cache,
    jboolean jdisable_connection_migration,
    jboolean jtraffic_stats_tag_set,
    jint jtraffic_stats_tag,
    jboolean jtraffic_stats_uid_set,
    jint jtraffic_stats_uid,
    jint jidempotency,
    const base::android::JavaRef<jbyteArray>& jdictionary_sha256_hash,
    const base::android::JavaRef<jobject>& jdictionary_byte_buffer,
    jint jdictionary_position,
    jint jdictionary_limit,
    const base::android::JavaRef<jstring>& jdictionary_id,
    jlong jnetwork_handle) {
  CHECK(jdictionary_id);
  CronetContextAdapter* context_adapter =
      reinterpret_cast<CronetContextAdapter*>(jurl_request_context_adapter);
  DCHECK(context_adapter);

  GURL url(base::android::ConvertJavaStringToUTF8(env, jurl_string));

  VLOG(1) << "New chromium network request_adapter: "
          << url.possibly_invalid_spec();

  CronetURLRequestAdapter* adapter = new CronetURLRequestAdapter(
      context_adapter, env, jurl_request, url,
      static_cast<net::RequestPriority>(jpriority), jdisable_cache,
      jdisable_connection_migration, jtraffic_stats_tag_set, jtraffic_stats_tag,
      jtraffic_stats_uid_set, jtraffic_stats_uid,
      static_cast<net::Idempotency>(jidempotency),
      SharedDictionaryWithByteBuffer::MaybeCreate(
          env,
          /*dictionary_sha256_hash=*/jdictionary_sha256_hash,
          /*dictionary_content_byte_buffer=*/jdictionary_byte_buffer,
          /*dictionary_content_position=*/jdictionary_position,
          /*dictionary_content_limit=*/jdictionary_limit,
          /*dictionary_id=*/jdictionary_id),
      jnetwork_handle);

  return reinterpret_cast<jlong>(adapter);
}

CronetURLRequestAdapter::CronetURLRequestAdapter(
    CronetContextAdapter* context,
    JNIEnv* env,
    const base::android::JavaRef<jobject>& jurl_request,
    const GURL& url,
    net::RequestPriority priority,
    jboolean jdisable_cache,
    jboolean jdisable_connection_migration,
    jboolean jtraffic_stats_tag_set,
    jint jtraffic_stats_tag,
    jboolean jtraffic_stats_uid_set,
    jint jtraffic_stats_uid,
    net::Idempotency idempotency,
    scoped_refptr<net::SharedDictionary> shared_dictionary,
    jlong network)
    : request_(new CronetURLRequest(context->cronet_url_request_context(),
                                    base::WrapUnique<>(this),
                                    url,
                                    priority,
                                    jdisable_cache == JNI_TRUE,
                                    jdisable_connection_migration == JNI_TRUE,
                                    jtraffic_stats_tag_set == JNI_TRUE,
                                    jtraffic_stats_tag,
                                    jtraffic_stats_uid_set == JNI_TRUE,
                                    jtraffic_stats_uid,
                                    idempotency,
                                    shared_dictionary,
                                    network)) {
  owner_.Reset(env, jurl_request);
}

CronetURLRequestAdapter::~CronetURLRequestAdapter() {
}

jboolean CronetURLRequestAdapter::SetHttpMethod(
    JNIEnv* env,
    const JavaRef<jstring>& jmethod) {
  std::string method(base::android::ConvertJavaStringToUTF8(env, jmethod));
  return request_->SetHttpMethod(method) ? JNI_TRUE : JNI_FALSE;
}

jboolean CronetURLRequestAdapter::AddRequestHeader(
    JNIEnv* env,
    const JavaRef<jstring>& jname,
    const JavaRef<jstring>& jvalue) {
  std::string name(base::android::ConvertJavaStringToUTF8(env, jname));
  std::string value(base::android::ConvertJavaStringToUTF8(env, jvalue));
  return request_->AddRequestHeader(name, value) ? JNI_TRUE : JNI_FALSE;
}

void CronetURLRequestAdapter::SetUpload(
    std::unique_ptr<net::UploadDataStream> upload) {
  request_->SetUpload(std::move(upload));
}

void CronetURLRequestAdapter::Start(JNIEnv* env) {
  request_->Start();
}

void CronetURLRequestAdapter::GetStatus(
    JNIEnv* env,
    const JavaRef<jobject>& jstatus_listener) {
  base::android::ScopedJavaGlobalRef<jobject> status_listener_ref;
  status_listener_ref.Reset(env, jstatus_listener);
  request_->GetStatus(base::BindOnce(&CronetURLRequestAdapter::OnStatus,
                                     base::Unretained(this),
                                     status_listener_ref));
}

void CronetURLRequestAdapter::FollowDeferredRedirect(JNIEnv* env) {
  request_->FollowDeferredRedirect();
}

jboolean CronetURLRequestAdapter::ReadData(JNIEnv* env,
                                           const JavaRef<jobject>& jbyte_buffer,
                                           jint jposition,
                                           jint jlimit) {
  DCHECK_LT(jposition, jlimit);

  IOBufferWithByteBuffer* read_buffer =
      new IOBufferWithByteBuffer(env, jbyte_buffer, jposition, jlimit);

  int remaining_capacity = jlimit - jposition;
  request_->ReadData(read_buffer, remaining_capacity);
  return JNI_TRUE;
}

void CronetURLRequestAdapter::Destroy(JNIEnv* env,
                                      jboolean jsend_on_canceled) {
  // Destroy could be called from any thread, including network thread (if
  // posting task to executor throws an exception), but is posted, so |this|
  // is valid until calling task is complete. Destroy() is always called from
  // within a synchronized java block that guarantees no future posts to the
  // network thread with the adapter pointer.
  request_->Destroy(jsend_on_canceled == JNI_TRUE);
}

void CronetURLRequestAdapter::OnReceivedRedirect(
    const std::string& new_location,
    int http_status_code,
    const std::string& http_status_text,
    const net::HttpResponseHeaders* headers,
    bool was_cached,
    const std::string& negotiated_protocol,
    const std::string& proxy_server,
    int64_t received_byte_count) {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onRedirectReceived(
      env, owner_, ConvertUTF8ToJavaString(env, new_location), http_status_code,
      ConvertUTF8ToJavaString(env, http_status_text),
      ConvertResponseHeadersToJava(env, headers),
      was_cached ? JNI_TRUE : JNI_FALSE,
      ConvertUTF8ToJavaString(env, negotiated_protocol),
      ConvertUTF8ToJavaString(env, proxy_server), received_byte_count);
}

void CronetURLRequestAdapter::OnResponseStarted(
    int http_status_code,
    const std::string& http_status_text,
    const net::HttpResponseHeaders* headers,
    bool was_cached,
    const std::string& negotiated_protocol,
    const std::string& proxy_server,
    int64_t received_byte_count) {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onResponseStarted(
      env, owner_, http_status_code,
      ConvertUTF8ToJavaString(env, http_status_text),
      ConvertResponseHeadersToJava(env, headers),
      was_cached ? JNI_TRUE : JNI_FALSE,
      ConvertUTF8ToJavaString(env, negotiated_protocol),
      ConvertUTF8ToJavaString(env, proxy_server), received_byte_count);
}

void CronetURLRequestAdapter::OnReadCompleted(
    scoped_refptr<net::IOBuffer> buffer,
    int bytes_read,
    int64_t received_byte_count) {
  IOBufferWithByteBuffer* read_buffer =
      reinterpret_cast<IOBufferWithByteBuffer*>(buffer.get());
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onReadCompleted(
      env, owner_, read_buffer->byte_buffer(), bytes_read,
      read_buffer->initial_position(), read_buffer->initial_limit(),
      received_byte_count);
}

void CronetURLRequestAdapter::OnSucceeded(int64_t received_byte_count) {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onSucceeded(env, owner_, received_byte_count);
}

void CronetURLRequestAdapter::OnError(int net_error,
                                      int quic_error,
                                      quic::ConnectionCloseSource source,
                                      const std::string& error_string,
                                      int64_t received_byte_count) {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onError(
      env, owner_, NetErrorToUrlRequestError(net_error), net_error, quic_error,
      (int)NetSourceToJavaSource(source),
      ConvertUTF8ToJavaString(env, error_string), received_byte_count);
}

void CronetURLRequestAdapter::OnCanceled() {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onCanceled(env, owner_);
}

void CronetURLRequestAdapter::OnDestroyed() {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onNativeAdapterDestroyed(env, owner_);
  // |this| adapter will be destroyed by the owner after return from this call.
}

void CronetURLRequestAdapter::OnStatus(
    const base::android::ScopedJavaGlobalRef<jobject>& status_listener_ref,
    net::LoadState load_status) {
  JNIEnv* env = base::android::AttachCurrentThread();
  cronet::Java_CronetUrlRequest_onStatus(env, owner_, status_listener_ref,
                                         load_status);
}

void CronetURLRequestAdapter::OnMetricsCollected(
    const base::Time& start_time,
    const base::TimeTicks& start_ticks,
    const base::TimeTicks& dns_start,
    const base::TimeTicks& dns_end,
    const base::TimeTicks& connect_start,
    const base::TimeTicks& connect_end,
    const base::TimeTicks& ssl_start,
    const base::TimeTicks& ssl_end,
    const base::TimeTicks& send_start,
    const base::TimeTicks& send_end,
    const base::TimeTicks& push_start,
    const base::TimeTicks& push_end,
    const base::TimeTicks& receive_headers_end,
    const base::TimeTicks& request_end,
    bool socket_reused,
    int64_t sent_bytes_count,
    int64_t received_bytes_count,
    bool quic_connection_migration_attempted,
    bool quic_connection_migration_successful) {
  JNIEnv* env = base::android::AttachCurrentThread();
  Java_CronetUrlRequest_onMetricsCollected(
      env, owner_,
      metrics_util::ConvertTime(start_ticks, start_ticks, start_time),
      metrics_util::ConvertTime(dns_start, start_ticks, start_time),
      metrics_util::ConvertTime(dns_end, start_ticks, start_time),
      metrics_util::ConvertTime(connect_start, start_ticks, start_time),
      metrics_util::ConvertTime(connect_end, start_ticks, start_time),
      metrics_util::ConvertTime(ssl_start, start_ticks, start_time),
      metrics_util::ConvertTime(ssl_end, start_ticks, start_time),
      metrics_util::ConvertTime(send_start, start_ticks, start_time),
      metrics_util::ConvertTime(send_end, start_ticks, start_time),
      metrics_util::ConvertTime(push_start, start_ticks, start_time),
      metrics_util::ConvertTime(push_end, start_ticks, start_time),
      metrics_util::ConvertTime(receive_headers_end, start_ticks, start_time),
      metrics_util::ConvertTime(request_end, start_ticks, start_time),
      socket_reused ? JNI_TRUE : JNI_FALSE, sent_bytes_count,
      received_bytes_count,
      quic_connection_migration_attempted ? JNI_TRUE : JNI_FALSE,
      quic_connection_migration_successful ? JNI_TRUE : JNI_FALSE);
}

}  // namespace cronet

DEFINE_JNI(CronetUrlRequest)