/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#ifndef OCEANBASE_UNITTEST_CLOG_MOCK_CONTAINER_MOCK_OB_LOG_ENGINE_H_
#define OOCEANBASE_UNITTEST_CLOG_MOCK_CONTAINER_MOCK_OB_LOG_ENGINE_H_
#include "clog/ob_i_disk_log_buffer.h"
#include "common/ob_member_list.h"
#include "lib/net/ob_addr.h"
#include "common/ob_partition_key.h"
#include "clog/ob_log_reader_interface.h"
#include "clog/ob_i_log_engine.h"

namespace oceanbase {
namespace clog {
class ObIDiskLogBuffer;
class ObINetLogBufferMgr;
class ObILogNetTask;
class ObConfirmedInfo;
class ObLogTask;
class MockObLogEngine : public ObILogEngine {
public:
  typedef ObDiskBufferTask FlushTask;

public:
  MockObLogEngine()
  {}
  ~MockObLogEngine()
  {}
  ObIRawLogIterator* alloc_raw_log_iterator(
      const file_id_t start_file_id, const file_id_t end_file_id, const offset_t offset, const int64_t timeout)
  {
    UNUSED(start_file_id);
    UNUSED(end_file_id);
    UNUSED(offset);
    UNUSED(timeout);
    return NULL;
  }
  void revert_raw_log_iterator(ObIRawLogIterator* iter)
  {
    UNUSED(iter);
  }
  ObIRawIndexIterator* alloc_raw_index_iterator(const file_id_t start_file_id, const file_id_t end_file_id,
      const offset_t offset, const int64_t timeout, const bool use_cache)
  {
    UNUSED(start_file_id);
    UNUSED(end_file_id);
    UNUSED(offset);
    UNUSED(timeout);
    UNUSED(use_cache);
    return NULL;
  }
  void revert_raw_index_iterator(ObIRawIndexIterator* iter)
  {
    UNUSED(iter);
  }
  int read_log_by_location(const ObReadParam& param, ObLogEntry& entry)
  {
    UNUSED(param);
    UNUSED(entry);
    return common::OB_SUCCESS;
  }
  int read_log_by_location(const ObReadParam& param, ObLogEntry& entry, ObReadCost& cost)
  {
    UNUSED(param);
    UNUSED(entry);
    UNUSED(cost);
    return common::OB_SUCCESS;
  }
  int read_log_by_location(const ObLogTask& log_task, ObLogEntry& entry)
  {
    UNUSED(log_task);
    UNUSED(entry);
    return common::OB_SUCCESS;
  }
  int read_data_with_ctx(ObReadCtx& ctx, file_id_t f, offset_t o, int64_t s, char* b, ObReadCost& cost)
  {
    UNUSED(ctx);
    UNUSED(f);
    UNUSED(o);
    UNUSED(s);
    UNUSED(b);
    UNUSED(cost);
    return common::OB_SUCCESS;
  }
  int read_data_from_hot_cache(
      const file_id_t want_file_id, const offset_t want_offset, const int64_t want_size, char* user_buf)
  {
    UNUSED(want_file_id);
    UNUSED(want_offset);
    UNUSED(want_size);
    UNUSED(user_buf);
    return common::OB_SUCCESS;
  }
  int read_data_direct(const ObReadParam& param, ObReadBuf& rbuf, ObReadRes& res, ObReadCost& cost)
  {
    UNUSED(param);
    UNUSED(rbuf);
    UNUSED(res);
    UNUSED(cost);
    return common::OB_SUCCESS;
  }
  int submit_flush_task(FlushTask* task)
  {
    UNUSED(task);
    return common::OB_SUCCESS;
  }
  int submit_fetch_log_resp(
      const common::ObAddr& server, const common::ObPartitionKey& key, const int64_t network_limit, ObILogNetTask* task)
  {
    UNUSED(server);
    UNUSED(key);
    UNUSED(network_limit);
    UNUSED(task);
    return common::OB_SUCCESS;
  }
  int submit_log_ack(const common::ObAddr& server, const common::ObPartitionKey& key, const uint64_t log_id,
      const common::ObProposalID proposal_id)
  {
    UNUSED(server);
    UNUSED(key);
    UNUSED(log_id);
    UNUSED(proposal_id);
    return common::OB_SUCCESS;
  }
  int fetch_log_from_all_follower(const common::ObMemberList& mem_list, const common::ObPartitionKey& key,
      const uint64_t start_id, const uint64_t end_id, const common::ObProposalID proposal_id)
  {
    UNUSED(mem_list);
    UNUSED(key);
    UNUSED(start_id);
    UNUSED(end_id);
    UNUSED(proposal_id);
    return common::OB_SUCCESS;
  }
  int fetch_log_from_leader(const common::ObAddr& server, const common::ObPartitionKey& key, const uint64_t start_id,
      const uint64_t end_id, const common::ObProposalID proposal_id, const common::ObReplicaType replica_type)
  {
    UNUSED(server);
    UNUSED(key);
    UNUSED(start_id);
    UNUSED(end_id);
    UNUSED(proposal_id);
    UNUSED(replica_type);
    return common::OB_SUCCESS;
  }
  int fetch_register_server(const common::ObAddr& server, const ObPartitionKey& key,
      const common::ObReplicaType replica_type, const bool is_request_leader, const bool is_need_force_register)
  {
    UNUSED(server);
    UNUSED(key);
    UNUSED(replica_type);
    UNUSED(is_request_leader);
    UNUSED(is_need_force_register);
    return common::OB_SUCCESS;
  }
  int request_replace_sick_child(
      const common::ObAddr& server, const common::ObPartitionKey& key, const common::ObAddr& sick_child)
  {
    int ret = OB_SUCCESS;
    UNUSED(server);
    UNUSED(key);
    UNUSED(sick_child);
    return ret;
  }
  int reject_server(const common::ObAddr& server, const common::ObPartitionKey& key, const int32_t msg_type)
  {
    UNUSED(server);
    UNUSED(key);
    UNUSED(msg_type);
    return common::OB_SUCCESS;
  }
  bool is_in_black_list(const common::ObAddr& server) const
  {
    UNUSED(server);
    return true;
  }
  int submit_prepare_rqst(
      const common::ObMemberList& mem_list, const common::ObPartitionKey& key, const common::ObProposalID proposal_id)
  {
    UNUSED(mem_list);
    UNUSED(key);
    UNUSED(proposal_id);
    return common::OB_SUCCESS;
  }
  int prepare_response(const common::ObAddr& server, const common::ObPartitionKey& partition_key,
      const common::ObProposalID proposal_id, const uint64_t max_log_id, const int64_t max_log_ts)
  {
    UNUSED(server);
    UNUSED(partition_key);
    UNUSED(proposal_id);
    UNUSED(max_log_id);
    UNUSED(max_log_ts);
    return common::OB_SUCCESS;
  }
  int send_keepalive_msg(const common::ObAddr& server, const common::ObPartitionKey& partition_key,
      const uint64_t next_log_id, const int64_t next_log_ts_lb, const uint64_t deliver_cnt)
  {
    UNUSED(server);
    UNUSED(partition_key);
    UNUSED(next_log_id);
    UNUSED(next_log_ts_lb);
    UNUSED(deliver_cnt);
    return common::OB_SUCCESS;
  }

  int send_sync_log_archive_progress_msg(const common::ObAddr& server, const int64_t cluster_id,
      const common::ObPartitionKey& partition_key, const int64_t log_archive_round, const uint64_t last_archived_log_id,
      const int64_t last_archived_log_ts)
  {
    UNUSED(server);
    UNUSED(cluster_id);
    UNUSED(partition_key);
    UNUSED(log_archive_round);
    UNUSED(last_archived_log_id);
    UNUSED(last_archived_log_ts);
    return common::OB_SUCCESS;
  }
  int submit_index_flush_task(FlushTask* task)
  {
    UNUSED(task);
    return common::OB_SUCCESS;
  }
  void update_clog_info(const int64_t submit_timestamp)
  {
    UNUSED(submit_timestamp);
  }
  void update_clog_info(
      const common::ObPartitionKey& partition_key, const uint64_t log_id, const int64_t submit_timestamp)
  {
    UNUSED(partition_key);
    UNUSED(log_id);
    UNUSED(submit_timestamp);
  }
  void update_ilog_info(
      const common::ObPartitionKey& partition_key, const uint64_t log_id, const int64_t submit_timestamp)
  {
    UNUSED(partition_key);
    UNUSED(log_id);
    UNUSED(submit_timestamp);
  }
  void update_ilog_info(const int64_t submit_timestamp)
  {
    UNUSED(submit_timestamp);
  }
  ObILogInfoBlockReader* get_info_block_reader(const InfoBlockReaderType type)
  {
    UNUSED(type);
    return NULL;
  }
  void revert_info_block_reader(ObILogInfoBlockReader* reader)
  {
    UNUSED(reader);
  }

  // new functions
  ObILogInfoBlockReader* get_clog_info_block_reader()
  {
    return NULL;
  }
  void revert_clog_info_block_reader(ObILogInfoBlockReader* reader)
  {
    UNUSED(reader);
  }
  ObILogInfoBlockReader* get_ilog_info_block_reader()
  {
    return NULL;
  }
  void revert_ilog_info_block_reader(ObILogInfoBlockReader* reader)
  {
    UNUSED(reader);
  }
  virtual ObCommitLogEnv* get_clog_env(const bool is_sys)
  {
    UNUSED(is_sys);
    return NULL;
  }
  virtual ObIndexLogEnv* get_ilog_env(const bool is_sys)
  {
    UNUSED(is_sys);
    return NULL;
  }
  virtual void revert_clog_env(ObCommitLogEnv* log_env)
  {
    UNUSED(log_env);
  }
  virtual void revert_ilog_env(ObIndexLogEnv* log_env)
  {
    UNUSED(log_env);
  }

  int reset_clog_info_block()
  {
    return common::OB_SUCCESS;
  }
  int reset_ilog_info_block()
  {
    return common::OB_SUCCESS;
  }
  int switch_ilog_file()
  {
    return common::OB_SUCCESS;
  }

  virtual int notify_follower_log_missing(
      const common::ObAddr& a, const common::ObPartitionKey& b, uint64_t c, const bool d)
  {
    UNUSED(a);
    UNUSED(b);
    UNUSED(c);
    UNUSED(d);
    return common::OB_SUCCESS;
  }
  virtual file_id_t get_flying_ilog_file_id()
  {
    return common::OB_INVALID_FILE_ID;
  }
  virtual file_id_t get_flying_clog_file_id()
  {
    return common::OB_INVALID_FILE_ID;
  }
  virtual ObIndexInfoBlockHandler& get_flying_ilog_info_handler()
  {
    return fake_handler_;
  }
  void revert_flying_ilog_info_handler(ObIndexInfoBlockHandler* handler)
  {
    UNUSED(handler);
  }
  virtual int get_clog_info_handler(clog::file_id_t a, clog::ObCommitInfoBlockHandler& b)
  {
    UNUSED(a);
    UNUSED(b);
    return common::OB_SUCCESS;
  }
  virtual int get_ilog_info_handler(clog::file_id_t a, clog::ObIndexInfoBlockHandler& b, ObReadCost& cost)
  {
    UNUSED(a);
    UNUSED(b);
    UNUSED(cost);
    return common::OB_SUCCESS;
  }
  virtual int get_remote_membership_status(const common::ObAddr& server, const common::ObPartitionKey& partition_key,
      int64_t& timestamp, uint64_t& max_confirmed_log_id, bool& is_in_sync)
  {
    UNUSED(server);
    UNUSED(partition_key);
    UNUSED(timestamp);
    UNUSED(max_confirmed_log_id);
    UNUSED(is_in_sync);
    return common::OB_SUCCESS;
  }
  virtual int get_follower_sync_info(const common::ObAddr& a, const common::ObPartitionKey& b, uint64_t& c, int64_t& d)
  {
    UNUSED(a);
    UNUSED(b);
    UNUSED(c);
    UNUSED(d);
    return common::OB_SUCCESS;
  }
  virtual int add_to_black_list(const common::ObAddr& server)
  {
    UNUSED(server);
    return common::OB_SUCCESS;
  }
  virtual int remove_from_black_list(const common::ObAddr& server, bool& is_exec_remove)
  {
    UNUSED(server);
    UNUSED(is_exec_remove);
    return common::OB_SUCCESS;
  }
  virtual void try_limit_network(const ObLogEntry& log_entry)
  {
    UNUSED(log_entry);
  }
  virtual int64_t get_free_quota() const
  {
    return 0;
  };
  virtual bool is_using_new_log_env() const
  {
    return true;
  }
  ObILogDir* get_sys_ilog_dir()
  {
    return &si_dir_;
  }
  ObILogDir* get_user_ilog_dir()
  {
    return &ui_dir_;
  }
  ObILogDir* get_sys_clog_dir()
  {
    return &sc_dir_;
  }
  ObILogDir* get_user_clog_dir()
  {
    return &uc_dir_;
  }
  ObILogDir* get_clog_dir()
  {
    return NULL;
  }
  ObILogDir* get_ilog_dir()
  {
    return NULL;
  }
  int switch_clog_file()
  {
    return common::OB_SUCCESS;
  }
  bool is_disk_space_enough() const
  {
    return true;
  }
  /*
  virtual int set_new_env_min_using_file_id(const bool is_sys,
                                            const file_id_t ilog_file_id,
                                            const file_id_t clog_file_id)
                                            */
  int get_corresponding_clog_file_id(const file_id_t ilog_file_id, file_id_t& clog_file_id)
  {
    UNUSED(ilog_file_id);
    UNUSED(clog_file_id);
    return common::OB_SUCCESS;
  }
  virtual int broadcast_info(const common::ObMemberList& mem_list, const common::ObPartitionKey& key,
      const common::ObReplicaType& replica_type, const uint64_t max_confirmed_log_id)
  {
    UNUSED(mem_list);
    UNUSED(key);
    UNUSED(replica_type);
    UNUSED(max_confirmed_log_id);
    return 0;
  }
  void set_all_scan_finish()
  {}
  virtual int set_env_min_using_file_id(const file_id_t ilog_file_id, const file_id_t clog_file_id)
  {
    UNUSED(ilog_file_id);
    UNUSED(clog_file_id);
    return common::OB_SUCCESS;
  }
  virtual int set_new_env_min_using_file_id(const file_id_t ilog_file_id, const file_id_t clog_file_id)
  {
    UNUSED(ilog_file_id);
    UNUSED(clog_file_id);
    return common::OB_SUCCESS;
  }
  virtual int submit_batch_log(const common::ObMemberList& member_list, const transaction::ObTransID& trans_id,
      const common::ObPartitionArray& partition_array, const ObLogInfoArray& log_info_array)
  {
    UNUSED(member_list);
    UNUSED(trans_id);
    UNUSED(partition_array);
    UNUSED(log_info_array);
    return common::OB_SUCCESS;
  }
  virtual int submit_batch_ack(
      const common::ObAddr& leader, const transaction::ObTransID& trans_id, const ObBatchAckArray& batch_ack_array)
  {
    UNUSED(leader);
    UNUSED(trans_id);
    UNUSED(batch_ack_array);
    return common::OB_SUCCESS;
  }
  virtual int query_remote_log(const common::ObAddr& server, const common::ObPartitionKey& partition_key,
      const uint64_t log_id, transaction::ObTransID& trans_id, int64_t& submit_timestamp)
  {
    UNUSED(server);
    UNUSED(partition_key);
    UNUSED(log_id);
    UNUSED(trans_id);
    UNUSED(submit_timestamp);
    return common::OB_SUCCESS;
  }
  virtual void record_flush_cb_histogram(const int64_t cost_ts)
  {
    UNUSED(cost_ts);
  }
  virtual void record_batch_flush_cb_histogram(const int64_t cost_ts)
  {
    UNUSED(cost_ts);
  }
  virtual int get_cursor_batch(const common::ObPartitionKey& pkey, const uint64_t query_log_id,
      ObGetCursorResult& result, ObIlogStorageQueryCost& csr_cost, const uint64_t retry_limit,
      const unsigned sleep_time_on_retry_us)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(query_log_id);
    UNUSED(result);
    UNUSED(csr_cost);
    UNUSED(retry_limit);
    UNUSED(sleep_time_on_retry_us);
    return ret;
  }
  virtual int get_cursor_batch(const common::ObPartitionKey& pkey, const uint64_t query_log_id,
      ObLogCursorExt& log_cursor, ObGetCursorResult& result, uint64_t& cursor_start_log_id)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(query_log_id);
    UNUSED(log_cursor);
    UNUSED(result);
    UNUSED(cursor_start_log_id);
    return ret;
  }
  virtual int get_cursor(const common::ObPartitionKey& pkey, const uint64_t query_log_id, ObLogCursorExt& log_cursor)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(query_log_id);
    UNUSED(log_cursor);
    return ret;
  }
  virtual int query_max_ilog_id(const common::ObPartitionKey& pkey, uint64_t& ret_max_ilog_id)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(ret_max_ilog_id);
    return ret;
  }
  virtual int query_ilog_file_id(
      const common::ObPartitionKey& pkey, const uint64_t query_log_id, file_id_t& ilog_file_id)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(query_log_id);
    UNUSED(ilog_file_id);
    return ret;
  }
  virtual int guarantee_extend_min()
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  virtual int locate_by_timestamp(const common::ObPartitionKey& pkey, const int64_t start_ts, uint64_t& target_log_id,
      int64_t& target_log_timestamp)
  {
    int ret = OB_SUCCESS;
    UNUSED(pkey);
    UNUSED(start_ts);
    UNUSED(target_log_id);
    UNUSED(target_log_timestamp);
    return ret;
  }

private:
  ObIndexInfoBlockHandler fake_handler_;
  ObLogDir si_dir_;
  ObLogDir ui_dir_;
  ObLogDir sc_dir_;
  ObLogDir uc_dir_;
};
/*
class ObILogNetTask
{
public:
  ~ObILogNetTask() {}
  char *get_data_buffer() const{return NULL;}
  common::ObProposalID get_proposal_id() const{
    return 0;}
  int64_t get_data_len() const{return 0;}
};

class ObLogNetTask : public ObILogNetTask
{
public:
  ObLogNetTask(common::ObProposalID proposal_id, char *buff,
               int64_t data_len) : proposal_id_(proposal_id),
                                   buff_(buff), data_len_(data_len) {};
  char *get_data_buffer() const {return buff_;}
  common::ObProposalID get_proposal_id() const {return proposal_id_;}
  int64_t get_data_len() const {return data_len_;}
private:
  common::ObProposalID proposal_id_;
  char *buff_;
  int64_t data_len_;
};
*/
}  // end namespace clog
}  // end namespace oceanbase

#endif  // OCEANBASE_UNITTEST_CLOG_MOCK_CONTAINER_MOCK_OB_LOG_ENGINE_H_