// Copyright 2015 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.

#ifndef COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_
#define COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_

#include <stddef.h>
#include <stdint.h>

#include <set>
#include <string>
#include <vector>

#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"

namespace net {

class URLRequestContext;

namespace ct {
struct SignedTreeHead;
}  // namespace ct

}  // namespace net

class GURL;

namespace certificate_transparency {

class LogResponseHandler;

// Fetches Signed Tree Heads (STHs) and consistency proofs from Certificate
// Transparency logs using the URLRequestContext provided during the instance
// construction.
// Must outlive the provided URLRequestContext.
class LogProofFetcher {
 public:
  // Buffer size for log replies - currently the reply to
  // get-consistency-proof is the biggest one this class handles. 1500 bytes
  // should be enough to accommodate 31 proof nodes + JSON overhead, supporting
  // trees with up to 100 million entries.
  static const size_t kMaxLogResponseSizeInBytes = 1500;

  // Callback for successful retrieval of Signed Tree Heads. Called
  // with the log_id of the log the STH belogs to (as supplied by the caller
  // to FetchSignedTreeHead) and the STH itself.
  using SignedTreeHeadFetchedCallback =
      base::Callback<void(const std::string& log_id,
                          const net::ct::SignedTreeHead& signed_tree_head)>;

  // Callback for failure of Signed Tree Head retrieval. Called with the log_id
  // that the log fetching was requested for and a net error code of the
  // failure.
  // |http_response_code| is meaningful only if |net_error| is net::OK.
  using FetchFailedCallback = base::Callback<
      void(const std::string& log_id, int net_error, int http_response_code)>;

  // Callback for successful retrieval of consistency proofs between two
  // STHs. Called with the log_id of the log the consistency belongs to (as
  // supplied by the caller to FetchConsistencyProof) and the vector of
  // proof nodes.
  using ConsistencyProofFetchedCallback =
      base::Callback<void(const std::string& log_id,
                          const std::vector<std::string>& consistency_proof)>;

  explicit LogProofFetcher(net::URLRequestContext* request_context);
  ~LogProofFetcher();

  // Fetch the latest Signed Tree Head from the log identified by |log_id|
  // from |base_log_url|. The |log_id| will be passed into the callbacks to
  // identify the log the retrieved Signed Tree Head belongs to.
  // The callbacks won't be invoked if the request is destroyed before
  // fetching is completed.
  // It is possible, but does not make a lot of sense, to have multiple
  // Signed Tree Head fetching requests going out to the same log, since
  // they are likely to return the same result.
  // TODO(eranm): Think further about whether multiple requests to the same
  // log imply cancellation of previous requests, should be coalesced or handled
  // independently.
  void FetchSignedTreeHead(
      const GURL& base_log_url,
      const std::string& log_id,
      const SignedTreeHeadFetchedCallback& fetched_callback,
      const FetchFailedCallback& failed_callback);

  // Fetch a consistency proof between the Merkle trees identified by
  // |old_tree_size| and |new_tree_size| of the log identified by |log_id|
  // from |base_log_url|.
  //
  // See the documentation of FetchSignedTreeHead regarding request destruction
  // and multiple requests to the same log.
  void FetchConsistencyProof(
      const GURL& base_log_url,
      const std::string& log_id,
      uint64_t old_tree_size,
      uint64_t new_tree_size,
      const ConsistencyProofFetchedCallback& fetched_callback,
      const FetchFailedCallback& failed_callback);

 private:
  // Starts the fetch (by delegating to the LogResponseHandler)
  // and stores the |log_handler| in |inflight_fetches_| for later
  // cleanup.
  void StartFetch(const GURL& request_url,
                  std::unique_ptr<LogResponseHandler> log_request);

  // Callback for when the fetch was done (successfully or not).
  // Deletes, and removes, the |log_handler| from the |inflight_fetches_|.
  // Additionally, invokes |caller_callback| which is typically
  // one of the callbacks provided to the Fetch... method, bound to
  // success/failure parameters.
  void OnFetchDone(LogResponseHandler* log_handler,
                   const base::Closure& caller_callback);

  net::URLRequestContext* const request_context_;

  std::set<std::unique_ptr<LogResponseHandler>> inflight_fetches_;

  base::WeakPtrFactory<LogProofFetcher> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(LogProofFetcher);
};

}  // namespace certificate_transparency

#endif  // COMPONENTS_CERTIFICATE_TRANSPARENCY_LOG_PROOF_FETCHER_H_