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

#include "components/update_client/net/url_request_post_interceptor.h"

#include <memory>

#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/sequenced_task_runner.h"
#include "base/strings/stringprintf.h"
#include "components/update_client/test_configurator.h"
#include "net/base/upload_bytes_element_reader.h"
#include "net/base/upload_data_stream.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_util.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_filter.h"
#include "net/url_request/url_request_interceptor.h"
#include "net/url_request/url_request_simple_job.h"
#include "net/url_request/url_request_test_util.h"

namespace update_client {

// Returns a canned response.
class URLRequestPostInterceptor::URLRequestMockJob
    : public net::URLRequestSimpleJob {
 public:
  URLRequestMockJob(scoped_refptr<URLRequestPostInterceptor> interceptor,
                    net::URLRequest* request,
                    net::NetworkDelegate* network_delegate,
                    int response_code,
                    const std::string& response_body)
      : net::URLRequestSimpleJob(request, network_delegate),
        interceptor_(interceptor),
        response_code_(response_code),
        response_body_(response_body) {}

  void Start() override {
    if (interceptor_->is_paused_)
      return;
    net::URLRequestSimpleJob::Start();
  }

 protected:
  void GetResponseInfo(net::HttpResponseInfo* info) override {
    const std::string headers =
        base::StringPrintf("HTTP/1.1 %i OK\r\n\r\n", response_code_);
    info->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
        net::HttpUtil::AssembleRawHeaders(headers.c_str(), headers.length()));
  }

  int GetData(std::string* mime_type,
              std::string* charset,
              std::string* data,
              const net::CompletionOnceCallback callback) const override {
    mime_type->assign("text/plain");
    charset->assign("US-ASCII");
    data->assign(response_body_);
    return net::OK;
  }

 private:
  ~URLRequestMockJob() override {}

  scoped_refptr<URLRequestPostInterceptor> interceptor_;

  int response_code_;
  std::string response_body_;
  DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
};

URLRequestPostInterceptor::URLRequestPostInterceptor(
    const GURL& url,
    scoped_refptr<base::SequencedTaskRunner> io_task_runner)
    : url_(url), io_task_runner_(io_task_runner), hit_count_(0) {}

URLRequestPostInterceptor::~URLRequestPostInterceptor() {
  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
}

GURL URLRequestPostInterceptor::GetUrl() const {
  return url_;
}

bool URLRequestPostInterceptor::ExpectRequest(
    std::unique_ptr<RequestMatcher> request_matcher) {
  return ExpectRequest(std::move(request_matcher), kResponseCode200);
}

bool URLRequestPostInterceptor::ExpectRequest(
    std::unique_ptr<RequestMatcher> request_matcher,
    int response_code) {
  expectations_.push(
      {std::move(request_matcher), ExpectationResponse(response_code, "")});
  return true;
}

bool URLRequestPostInterceptor::ExpectRequest(
    std::unique_ptr<RequestMatcher> request_matcher,
    const base::FilePath& filepath) {
  std::string response;
  if (filepath.empty() || !base::ReadFileToString(filepath, &response))
    return false;

  expectations_.push({std::move(request_matcher),
                      ExpectationResponse(kResponseCode200, response)});
  return true;
}

int URLRequestPostInterceptor::GetHitCount() const {
  base::AutoLock auto_lock(interceptor_lock_);
  return hit_count_;
}

int URLRequestPostInterceptor::GetCount() const {
  base::AutoLock auto_lock(interceptor_lock_);
  return static_cast<int>(requests_.size());
}

std::vector<URLRequestPostInterceptor::InterceptedRequest>
URLRequestPostInterceptor::GetRequests() const {
  base::AutoLock auto_lock(interceptor_lock_);
  return requests_;
}

std::string URLRequestPostInterceptor::GetRequestBody(size_t n) const {
  base::AutoLock auto_lock(interceptor_lock_);
  return requests_[n].first;
}

std::string URLRequestPostInterceptor::GetRequestsAsString() const {
  const std::vector<InterceptedRequest> requests = GetRequests();

  std::string s = "Requests are:";

  int i = 0;
  for (auto it = requests.cbegin(); it != requests.cend(); ++it)
    s.append(base::StringPrintf("\n  [%d]: %s", ++i, it->first.c_str()));

  return s;
}

void URLRequestPostInterceptor::Reset() {
  base::AutoLock auto_lock(interceptor_lock_);
  hit_count_ = 0;
  requests_.clear();
  base::queue<Expectation>().swap(expectations_);
}

void URLRequestPostInterceptor::Pause() {
  base::AutoLock auto_lock(interceptor_lock_);
  is_paused_ = true;
}

void URLRequestPostInterceptor::Resume() {
  base::AutoLock auto_lock(interceptor_lock_);
  is_paused_ = false;
  io_task_runner_->PostTask(FROM_HERE,
                            base::BindOnce(&URLRequestMockJob::Start,
                                           base::Unretained(request_job_)));
}

void URLRequestPostInterceptor::url_job_request_ready_callback(
    UrlJobRequestReadyCallback url_job_request_ready_callback) {
  base::AutoLock auto_lock(interceptor_lock_);
  url_job_request_ready_callback_ = std::move(url_job_request_ready_callback);
}

class URLRequestPostInterceptor::Delegate : public net::URLRequestInterceptor {
 public:
  Delegate(const std::string& scheme,
           const std::string& hostname,
           scoped_refptr<base::SequencedTaskRunner> io_task_runner)
      : scheme_(scheme), hostname_(hostname), io_task_runner_(io_task_runner) {}

  void Register() {
    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
    net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
        scheme_, hostname_, std::unique_ptr<net::URLRequestInterceptor>(this));
  }

  void Unregister() {
    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
    interceptors_.clear();
    net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(scheme_,
                                                                hostname_);
  }

  void OnCreateInterceptor(
      scoped_refptr<URLRequestPostInterceptor> interceptor) {
    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
    DCHECK_EQ(0u, interceptors_.count(interceptor->GetUrl()));

    interceptors_.insert(std::make_pair(interceptor->GetUrl(), interceptor));
  }

 private:
  ~Delegate() override {}

  net::URLRequestJob* MaybeInterceptRequest(
      net::URLRequest* request,
      net::NetworkDelegate* network_delegate) const override {
    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());

    // Only intercepts POST.
    if (!request->has_upload())
      return nullptr;

    GURL url = request->url();
    if (url.has_query()) {
      GURL::Replacements replacements;
      replacements.ClearQuery();
      url = url.ReplaceComponents(replacements);
    }

    const auto it = interceptors_.find(url);
    if (it == interceptors_.end())
      return nullptr;

    // There is an interceptor hooked up for this url. Read the request body,
    // check the existing expectations, and handle the matching case by
    // popping the expectation off the queue, counting the match, and
    // returning a mock object to serve the canned response.
    auto interceptor = it->second;

    const net::UploadDataStream* stream = request->get_upload();
    const net::UploadBytesElementReader* reader =
        (*stream->GetElementReaders())[0]->AsBytesReader();
    const int size = reader->length();
    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(size));
    const std::string request_body(reader->bytes());

    {
      base::AutoLock auto_lock(interceptor->interceptor_lock_);
      interceptor->requests_.push_back(
          {request_body, request->extra_request_headers()});
      if (interceptor->expectations_.empty())
        return nullptr;
      const auto& expectation = interceptor->expectations_.front();
      if (expectation.first->Match(request_body)) {
        const int response_code(expectation.second.response_code);
        const std::string response_body(expectation.second.response_body);
        interceptor->expectations_.pop();
        ++interceptor->hit_count_;
        interceptor->request_job_ =
            new URLRequestMockJob(interceptor, request, network_delegate,
                                  response_code, response_body);
        if (interceptor->url_job_request_ready_callback_) {
          io_task_runner_->PostTask(
              FROM_HERE,
              std::move(interceptor->url_job_request_ready_callback_));
        }
        return interceptor->request_job_;
      }
    }

    return nullptr;
  }

  using InterceptorMap =
      std::map<GURL, scoped_refptr<URLRequestPostInterceptor>>;
  InterceptorMap interceptors_;

  const std::string scheme_;
  const std::string hostname_;
  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;

  DISALLOW_COPY_AND_ASSIGN(Delegate);
};

URLRequestPostInterceptorFactory::URLRequestPostInterceptorFactory(
    const std::string& scheme,
    const std::string& hostname,
    scoped_refptr<base::SequencedTaskRunner> io_task_runner)
    : scheme_(scheme),
      hostname_(hostname),
      io_task_runner_(io_task_runner),
      delegate_(new URLRequestPostInterceptor::Delegate(scheme,
                                                        hostname,
                                                        io_task_runner)) {
  io_task_runner_->PostTask(
      FROM_HERE, base::BindOnce(&URLRequestPostInterceptor::Delegate::Register,
                                base::Unretained(delegate_)));
}

URLRequestPostInterceptorFactory::~URLRequestPostInterceptorFactory() {
  io_task_runner_->PostTask(
      FROM_HERE,
      base::BindOnce(&URLRequestPostInterceptor::Delegate::Unregister,
                     base::Unretained(delegate_)));
}

scoped_refptr<URLRequestPostInterceptor>
URLRequestPostInterceptorFactory::CreateInterceptor(
    const base::FilePath& filepath) {
  const GURL base_url(
      base::StringPrintf("%s://%s", scheme_.c_str(), hostname_.c_str()));
  GURL absolute_url(base_url.Resolve(filepath.MaybeAsASCII()));
  auto interceptor = scoped_refptr<URLRequestPostInterceptor>(
      new URLRequestPostInterceptor(absolute_url, io_task_runner_));
  bool res = io_task_runner_->PostTask(
      FROM_HERE,
      base::BindOnce(&URLRequestPostInterceptor::Delegate::OnCreateInterceptor,
                     base::Unretained(delegate_), interceptor));
  return res ? interceptor : nullptr;
}

bool PartialMatch::Match(const std::string& actual) const {
  return actual.find(expected_) != std::string::npos;
}

bool AnyMatch::Match(const std::string&) const {
  return true;
}

InterceptorFactory::InterceptorFactory(
    scoped_refptr<base::SequencedTaskRunner> io_task_runner)
    : URLRequestPostInterceptorFactory(POST_INTERCEPT_SCHEME,
                                       POST_INTERCEPT_HOSTNAME,
                                       io_task_runner) {}

InterceptorFactory::~InterceptorFactory() {}

scoped_refptr<URLRequestPostInterceptor>
InterceptorFactory::CreateInterceptor() {
  return CreateInterceptorForPath(POST_INTERCEPT_PATH);
}

scoped_refptr<URLRequestPostInterceptor>
InterceptorFactory::CreateInterceptorForPath(const char* url_path) {
  return URLRequestPostInterceptorFactory::CreateInterceptor(
      base::FilePath::FromUTF8Unsafe(url_path));
}

}  // namespace update_client