/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *   Copyright 2022-Present Couchbase, Inc.
 *
 *   Licensed 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.
 */

#pragma once

#include "core/pending_operation.hxx"
#include "packet.hxx"
#include "queue_callback.hxx"
#include "queue_request_connection_info.hxx"

#include <couchbase/retry_strategy.hxx>

#include <asio/steady_timer.hpp>

#include <atomic>
#include <memory>
#include <mutex>
#include <set>

namespace couchbase::core
{
class operation_map;
} // namespace couchbase::core

namespace couchbase::core::mcbp
{
class operation_queue;

class queue_request
  : public std::enable_shared_from_this<queue_request>
  , public packet
  , public retry_request
  , public pending_operation
{
public:
  queue_request(protocol::magic magic, protocol::client_opcode opcode, queue_callback&& callback);
  ~queue_request() override = default;

  [[nodiscard]] auto retry_attempts() const -> std::size_t override;
  [[nodiscard]] auto identifier() const -> std::string override;
  [[nodiscard]] auto idempotent() const -> bool override;
  [[nodiscard]] auto retry_reasons() const -> std::set<retry_reason> override;

  [[nodiscard]] auto retries() const -> std::pair<std::size_t, std::set<retry_reason>>;
  [[nodiscard]] auto connection_info() const -> queue_request_connection_info;

  void record_retry_attempt(retry_reason reason) override;
  [[nodiscard]] auto retry_strategy() const -> std::shared_ptr<retry_strategy>;

  [[nodiscard]] auto is_cancelled() const -> bool;
  void cancel() override;
  void cancel(std::error_code error);
  void try_callback(std::shared_ptr<queue_response> response, std::error_code error);
  auto internal_cancel() -> bool;

  void set_deadline(std::shared_ptr<asio::steady_timer> timer);
  void set_retry_backoff(std::shared_ptr<asio::steady_timer> timer);

  std::string collection_name_{};
  std::string scope_name_{};
  std::size_t replica_index_{ 0 };
  // This tracks when the request was dispatched so that we can properly prioritize older requests
  // to try and meet timeout requirements.
  std::chrono::steady_clock::time_point dispatched_time_{};
  bool persistent_{ false };

  // This stores a pointer to the operation_map that currently is holding this request.  This allows
  // us to remove it form that list whenever the request is cancelled
  std::atomic<operation_map*> waiting_in_{ nullptr };

  // This is used to determine what, if any, retry strategy to use when deciding whether to retry
  // the request and calculating any back-off time period.
  std::shared_ptr<couchbase::retry_strategy> retry_strategy_{};

private:
  // Static routing properties
  queue_callback callback_;

  // This stores a pointer to the server that currently own this request.  This allows us to remove
  // it from that list whenever the request is cancelled.
  std::atomic<operation_queue*> queued_with_{ nullptr };

  // This keeps track of whether the request has been 'completed' which is synonymous with the
  // callback having been invoked. This is an integer to allow us to atomically control it.
  std::atomic_bool is_completed_{ false };

  // This is used to lock access to the request when processing a timeout, a response or spans
  mutable std::mutex processing_mutex_{};

  // This stores the number of times that the item has been retried. It is used for various
  // non-linear retry algorithms.
  std::size_t retry_count_{ 0 };

  // This is the set of reasons why this request has been retried.
  std::set<retry_reason> retry_reasons_{};

  // This is used to lock access to the request when processing retry reasons or attempts.
  mutable std::mutex retry_mutex_{};

  queue_request_connection_info connection_info_{};
  mutable std::mutex connection_info_mutex_{};

  std::shared_ptr<asio::steady_timer> deadline_{};
  std::shared_ptr<asio::steady_timer> retry_backoff_{};

  friend operation_queue;
};
} // namespace couchbase::core::mcbp