/**
 * 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_LOGSERVICE_MOCK_CONTAINER_LOG_SLIDING_WINDOW_
#define OCEANBASE_UNITTEST_LOGSERVICE_MOCK_CONTAINER_LOG_SLIDING_WINDOW_

#define private public
#include "logservice/palf/log_sliding_window.h"
#include "share/scn.h"
#include "mock_log_state_mgr.h"
#undef private

namespace oceanbase
{
namespace palf
{
class PalfFSCbWrapper;

class MockLogSlidingWindow : public LogSlidingWindow
{
public:
  MockLogSlidingWindow()
    : pending_end_lsn_(0), mock_start_id_(1)
  {}
  virtual ~MockLogSlidingWindow() {}
public:
  void destroy() {}
  int init(const int64_t palf_id,
           const common::ObAddr &self,
           LogStateMgr *state_mgr,
           LogConfigMgr *mm,
           LogEngine *log_engine,
           palf::PalfFSCbWrapper *palf_fs_cb,
           common::ObILogAllocator *alloc_mgr,
           const PalfBaseInfo &palf_base_info,
           const bool is_normal_replica)
  {
    int ret = OB_SUCCESS;
    UNUSED(palf_id);
    UNUSED(self);
    UNUSED(state_mgr);
    UNUSED(mm);
    UNUSED(log_engine);
    UNUSED(palf_fs_cb);
    UNUSED(alloc_mgr);
    UNUSED(palf_base_info);
    UNUSED(is_normal_replica);
    return ret;
  }
  int sliding_cb(const int64_t sn, const FixedSlidingWindowSlot *data)
  {
    int ret = OB_SUCCESS;
    UNUSED(sn);
    UNUSED(data);
    return ret;
  }
  int64_t get_max_log_id() const
  {
    return 1;
  }
  int64_t get_max_log_ts() const
  {
    return 1;
  }
  LSN get_max_lsn() const
  {
    LSN lsn;
    lsn.val_ = 0;
    return lsn;
  }
  int64_t get_start_id() const
  {
    return mock_start_id_;
  }
  int get_committed_end_lsn(LSN &committed_end_lsn) const
  {
    int ret = OB_SUCCESS;
    UNUSED(committed_end_lsn);
    return ret;
  }
  int get_server_ack_info(const common::ObAddr &server, LsnTsInfo &lsn_ts_info)
  {
    UNUSEDx(server, lsn_ts_info);
    return OB_SUCCESS;
  }
  int try_fetch_log(const FetchTriggerType &fetch_log_type,
                    const LSN prev_lsn = LSN(),
                    const LSN fetch_start_lsn = LSN(),
                    const int64_t fetch_start_log_id = OB_INVALID_LOG_ID)
  {
    int ret = OB_SUCCESS;
    UNUSED(prev_lsn);
    UNUSED(fetch_start_lsn);
    UNUSED(fetch_start_log_id);
    return ret;
  }
  int try_fetch_log_for_reconfirm(const common::ObAddr &dest, const LSN &fetch_end_lsn, bool &is_fetched)
  {
    int ret = OB_SUCCESS;
    UNUSED(dest);
    UNUSED(fetch_end_lsn);
    is_fetched = true;
    return ret;
  }
  bool is_empty() const
  {
    return true;
  }
  bool check_all_log_has_flushed()
  {
    return true;
  }
  int get_majority_match_lsn(LSN &majority_match_lsn)
  {
    UNUSED(majority_match_lsn);
    return OB_SUCCESS;
  }
  // ================= log sync part begin
  int submit_log(const char *buf,
                 const int64_t buf_len,
                 const int64_t ref_ts_ns,
                 LSN &lsn,
                 int64_t &log_timestamp)
  {
    int ret = OB_SUCCESS;
    UNUSED(buf);
    UNUSED(buf_len);
    UNUSED(ref_ts_ns);
    UNUSED(lsn);
    UNUSED(log_timestamp);
    return ret;
  }
  int submit_group_log(const LSN &lsn,
                       const char *buf,
                       const int64_t buf_len)
  {
    int ret = OB_SUCCESS;
    UNUSED(lsn);
    UNUSED(buf);
    UNUSED(buf_len);
    return ret;
  }
  int receive_log(const common::ObAddr &src_server,
                  const PushLogType push_log_type,
                  const LSN &prev_lsn,
                  const int64_t &prev_log_pid,
                  const LSN &lsn,
                  const char *buf,
                  const int64_t buf_len,
                  const bool need_check_clean_log,
                  TruncateLogInfo &truncate_log_info) override
  {
    int ret = OB_SUCCESS;
    UNUSED(src_server);
    UNUSED(push_log_type);
    UNUSED(prev_lsn);
    UNUSED(prev_log_pid);
    UNUSED(lsn);
    UNUSED(buf);
    UNUSED(buf_len);
    UNUSED(need_check_clean_log);
    UNUSED(truncate_log_info);
    return ret;
  }
  int after_flush_log(const FlushLogCbCtx &flush_cb_ctx)
  {
    int ret = OB_SUCCESS;
    UNUSED(flush_cb_ctx);
    return ret;
  }
  int after_truncate(const TruncateLogCbCtx &truncate_cb_ctx)
  {
    int ret = OB_SUCCESS;
    UNUSED(truncate_cb_ctx);
    return ret;
  }
  int ack_log(const common::ObAddr &src_server, const LSN &end_lsn)
  {
    int ret = OB_SUCCESS;
    UNUSED(src_server);
    UNUSED(end_lsn);
    return ret;
  }
  int truncate(const TruncateLogInfo &truncate_log_info, const LSN &expected_prev_lsn, const int64_t expected_prev_log_pid) override
  {
    int ret = OB_SUCCESS;
    UNUSED(truncate_log_info);
    UNUSED(expected_prev_lsn);
    UNUSED(expected_prev_log_pid);
    return ret;
  }
  int truncate_for_rebuild(const PalfBaseInfo &palf_base_info)
  {
    int ret = OB_SUCCESS;
    UNUSED(palf_base_info);
    return ret;
  }
  bool pre_check_for_config_log(const int64_t &msg_proposal_id,
                                const LSN &lsn,
                                const int64_t &log_proposal_id,
                                TruncateLogInfo &truncate_log_info) override
  {
    UNUSED(msg_proposal_id);
    UNUSED(lsn);
    UNUSED(log_proposal_id);
    UNUSED(truncate_log_info);
    return true;
  }
  // ================= log sync part end
  int append_disk_log(const LSN &lsn, const LogGroupEntry &group_entry)
  {
    int ret = OB_SUCCESS;
    UNUSED(lsn);
    UNUSED(group_entry);
    return ret;
  }
  int report_log_task_trace(const int64_t log_id)
  {
    int ret = OB_SUCCESS;
    UNUSED(log_id);
    return ret;
  }
  void get_max_flushed_end_lsn(LSN &end_lsn) const
  {
    end_lsn = max_flushed_end_lsn_;
  }
  int get_max_flushed_log_info(LSN &lsn,
                               LSN &end_lsn,
                               int64_t &log_proposal_id) const
  {
    int ret = OB_SUCCESS;
    lsn = mock_max_flushed_lsn_;
    end_lsn = mock_max_flushed_end_lsn_;
    log_proposal_id = mock_max_flushed_log_pid_;
    return ret;
  }
  int clean_log(const bool need_clear_log_exist_flag)
  {
    int ret = OB_SUCCESS;
    UNUSED(need_clear_log_exist_flag);
    return ret;
  }
  int clean_cached_log(const int64_t begin_log_id,
                       const LSN &lsn,
                       const LSN &prev_lsn,
                       const int64_t prev_log_pid) override
  {
    int ret = OB_SUCCESS;
    UNUSED(begin_log_id);
    UNUSED(lsn);
    UNUSED(prev_lsn);
    UNUSED(prev_log_pid);
    return ret;
  }
  int to_follower_pending(LSN &last_lsn)
  {
    int ret = OB_SUCCESS;
    last_lsn = pending_end_lsn_;
    return ret;
  }
  int to_leader_reconfirm() override
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  int to_leader_active()
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  int try_advance_committed_end_lsn(const LSN &end_lsn)
  {
    int ret = OB_SUCCESS;
    UNUSED(end_lsn);
    return ret;
  }
  int64_t get_last_submit_log_id_() const
  {
    return 1;
  }
  int get_last_submit_log_info(LSN &last_submit_lsn, int64_t &log_id, int64_t &log_proposal_id) const
  {
    int ret = OB_SUCCESS;
    last_submit_lsn = mock_last_submit_lsn_;
    log_id = mock_last_submit_log_id_;
    log_proposal_id = mock_last_submit_pid_;
    return ret;
  }
  int get_last_submit_log_info(LSN &last_submit_lsn,
                               LSN &last_submit_end_lsn,
                               int64_t &log_id,
                               int64_t &log_proposal_id) const
  {
    int ret = OB_SUCCESS;
    last_submit_lsn = mock_last_submit_lsn_;
    last_submit_end_lsn = mock_last_submit_end_lsn_;
    log_id = mock_last_submit_log_id_;
    log_proposal_id = mock_last_submit_pid_;
    return ret;
  }
  int get_last_slide_end_lsn(LSN &out_end_lsn) const
  {
    int ret = OB_SUCCESS;
    out_end_lsn = last_slide_end_lsn_;
    return ret;
  }
  int64_t get_last_slide_log_ts() const
  {
    return 1;
  }
  int try_freeze_last_log()
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  int inc_update_scn_base(const share::SCN &scn)
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  // location cache will be removed TODO by yunlong
  int set_location_cache_cb(PalfLocationCacheCb *lc_cb)
  {
    int ret = OB_SUCCESS;
    UNUSED(lc_cb);
    return ret;
  }
  int reset_location_cache_cb()
  {
    int ret = OB_SUCCESS;
    return ret;
  }
  int config_change_update_match_lsn_map(const ObMemberList &added_memberlist,
      const ObMemberList &removed_memberlist,
      const ObMemberList &new_log_sync_memberlist,
      const int64_t new_replica_num)
  {
    UNUSED(added_memberlist);
    UNUSED(removed_memberlist);
    UNUSED(new_log_sync_memberlist);
    UNUSED(new_replica_num);
    return OB_SUCCESS;
  }
  int get_server_ack_info(const common::ObAddr &server, LsnTsInfo &ack_info) const
  {
    UNUSED(server);
    ack_info.last_ack_time_us_ = common::ObTimeUtility::current_time();
    ack_info.lsn_ = LSN(PALF_INITIAL_LSN_VAL);
    return OB_SUCCESS;
  }
  int get_leader_from_cache(common::ObAddr &leader) const
  {
    leader = state_mgr_->get_leader();
    return OB_SUCCESS;
  }
public:
  palf::MockLogStateMgr *state_mgr_;
  LSN pending_end_lsn_;
  int64_t mock_start_id_;
  int64_t mock_last_submit_log_id_;
  LSN mock_last_submit_lsn_;
  LSN mock_last_submit_end_lsn_;
  int64_t mock_last_submit_pid_;
  LSN mock_max_flushed_lsn_;
  LSN mock_max_flushed_end_lsn_;
  int64_t mock_max_flushed_log_pid_;
};

} // end of palf
} // end of oceanbase

#endif