/**
 *
 * \section COPYRIGHT
 *
 * Copyright 2013-2021 Software Radio Systems Limited
 *
 * By using this file, you agree to the terms and conditions set
 * forth in the LICENSE file which can be found at the top level of
 * the distribution.
 *
 */

#include "dummy_gnb_stack.h"
#include "dummy_ue_stack.h"
#include "srsran/common/phy_cfg_nr_default.h"
#include "srsran/common/test_common.h"
#include "test_bench.h"
#include <boost/program_options.hpp>
#include <iostream>

// shorten boost program options namespace
namespace bpo = boost::program_options;

static double assert_sr_detection_min    = 1.000;
static double assert_cqi_detection_min   = 1.000;
static double assert_pusch_bler_max      = 0.000;
static double assert_pdsch_bler_max      = 0.000;
static double assert_prach_detection_min = 1.000;
static double assert_prach_ta_min        = 0.000;
static double assert_prach_ta_max        = 0.000;
static double assert_pucch_snr_min       = 0.000;

test_bench::args_t::args_t(int argc, char** argv)
{
  std::string              config_file;
  std::string              reference_cfg_str;
  bpo::options_description options;
  bpo::options_description options_tb("Test bench options");
  bpo::options_description options_gnb_stack("gNb stack and scheduling related options");
  bpo::options_description options_gnb_phy("gNb PHY related options");
  bpo::options_description options_ue_stack("UE stack options");
  bpo::options_description options_ue_phy("UE stack options");
  bpo::options_description options_assertion("Test assertions");
  bpo::options_description options_conf_file("Configuration file");

  uint16_t rnti = 17921;

  gnb_stack.pdsch.slots = "0,1,2,3,4,5";
  gnb_stack.pusch.slots = "6,7,8,9";

  // clang-format off
  options_tb.add_options()
        ("rnti",                         bpo::value<uint16_t>(&rnti)->default_value(rnti),                                                        "UE RNTI")
        ("duration",                     bpo::value<uint64_t>(&durations_slots)->default_value(durations_slots),                                  "Test duration in slots")
        ("lib.log.level",                bpo::value<std::string>(&phy_lib_log_level)->default_value(phy_lib_log_level),                           "PHY library log level")
        ("reference",                    bpo::value<std::string>(&reference_cfg_str)->default_value(reference_cfg_str),                           "Reference PHY configuration arguments")
        ("dl_channel.awgn_enable",       bpo::value<bool>(&dl_channel.awgn_enable)->default_value(dl_channel.awgn_enable),                        "DL Channel AWGN enable / disable")
        ("dl_channel.awgn_snr",          bpo::value<float>(&dl_channel.awgn_snr_dB)->default_value(dl_channel.awgn_snr_dB),                       "DL Channel AWGN SNR in dB")
        ("ul_channel.awgn_enable",       bpo::value<bool>(&ul_channel.awgn_enable)->default_value(ul_channel.awgn_enable),                        "UL Channel AWGN enable / disable")
        ("ul_channel.awgn_snr",          bpo::value<float>(&ul_channel.awgn_snr_dB)->default_value(ul_channel.awgn_snr_dB),                       "UL Channel AWGN SNR in dB")
        ("ul_channel.signal_power_dBfs", bpo::value<float>(&ul_channel.awgn_signal_power_dBfs)->default_value(ul_channel.awgn_signal_power_dBfs), "UL Channel expected signal power")
        ("channel.cfo",                  bpo::value<float>(&ul_channel.hst_fd_hz)->default_value(0),                                              "Channel HST Doppler frequency")
;

  options_gnb_stack.add_options()
        ("gnb.stack.pdcch.aggregation_level", bpo::value<uint32_t>(&gnb_stack.pdcch_aggregation_level)->default_value(gnb_stack.pdcch_aggregation_level), "PDCCH aggregation level")
        ("gnb.stack.pdsch.candidate",         bpo::value<uint32_t>(&gnb_stack.pdcch_dl_candidate)->default_value(gnb_stack.pdcch_dl_candidate),           "PDCCH candidate index for PDSCH")
        ("gnb.stack.pdsch.start",             bpo::value<uint32_t>(&gnb_stack.pdsch.rb_start)->default_value(0),                                          "PDSCH scheduling frequency allocation start")
        ("gnb.stack.pdsch.length",            bpo::value<uint32_t>(&gnb_stack.pdsch.rb_length)->default_value(gnb_stack.pdsch.rb_length),                 "PDSCH scheduling frequency allocation length")
        ("gnb.stack.pdsch.slots",             bpo::value<std::string>(&gnb_stack.pdsch.slots)->default_value(gnb_stack.pdsch.slots),                      "Slots enabled for PDSCH")
        ("gnb.stack.pdsch.mcs",               bpo::value<uint32_t>(&gnb_stack.pdsch.mcs)->default_value(gnb_stack.pdsch.mcs),                             "PDSCH scheduling modulation code scheme")
        ("gnb.stack.pusch.candidate",         bpo::value<uint32_t>(&gnb_stack.pdcch_ul_candidate)->default_value(gnb_stack.pdcch_ul_candidate),           "PDCCH candidate index for PUSCH")
        ("gnb.stack.pusch.start",             bpo::value<uint32_t>(&gnb_stack.pusch.rb_start)->default_value(0),                                          "PUSCH scheduling frequency allocation start")
        ("gnb.stack.pusch.length",            bpo::value<uint32_t>(&gnb_stack.pusch.rb_length)->default_value(gnb_stack.pusch.rb_length),                 "PUSCH scheduling frequency allocation length")
        ("gnb.stack.pusch.slots",             bpo::value<std::string>(&gnb_stack.pusch.slots)->default_value(gnb_stack.pusch.slots),                      "Slots enabled for PUSCH")
        ("gnb.stack.pusch.mcs",               bpo::value<uint32_t>(&gnb_stack.pusch.mcs)->default_value(gnb_stack.pusch.mcs),                             "PUSCH scheduling modulation code scheme")
        ("gnb.stack.log.level",               bpo::value<std::string>(&gnb_stack.log_level)->default_value(gnb_stack.log_level),                          "Stack log level")
        ("gnb.stack.use_dummy_mac",         bpo::value<std::string>(&gnb_stack.use_dummy_mac)->default_value("dummymac"),                                          "Use dummy or real NR scheduler (dummymac or realmac)")
        ;

  options_gnb_phy.add_options()
        ("gnb.phy.nof_threads",     bpo::value<uint32_t>(&gnb_phy.nof_phy_threads)->default_value(1),          "Number of threads")
        ("gnb.phy.log.level",       bpo::value<std::string>(&gnb_phy.log.phy_level)->default_value("warning"), "gNb PHY log level")
        ("gnb.phy.log.hex_limit",   bpo::value<int>(&gnb_phy.log.phy_hex_limit)->default_value(0),             "gNb PHY log hex limit")
        ("gnb.phy.log.id_preamble", bpo::value<std::string>(&gnb_phy.log.id_preamble)->default_value("GNB/"),  "gNb PHY log ID preamble")
        ("gnb.phy.pusch.max_iter",  bpo::value<uint32_t>(&gnb_phy.pusch_max_its)->default_value(10),      "PUSCH LDPC max number of iterations")
        ;

  options_ue_phy.add_options()
        ("ue.phy.fix_wideband_cqi", bpo::value<uint32_t>(&ue_phy.fix_wideband_cqi)->default_value(15),        "Fix wideband CQI value, set to 0 or greater than 15 to disable")
        ("ue.phy.nof_threads",      bpo::value<uint32_t>(&ue_phy.nof_phy_threads)->default_value(1),          "Number of threads")
        ("ue.phy.log.level",        bpo::value<std::string>(&ue_phy.log.phy_level)->default_value("warning"), "UE PHY log level")
        ("ue.phy.log.hex_limit",    bpo::value<int>(&ue_phy.log.phy_hex_limit)->default_value(0),             "UE PHY log hex limit")
        ("ue.phy.log.id_preamble",  bpo::value<std::string>(&ue_phy.log.id_preamble)->default_value(" UE/"),  "UE PHY log ID preamble")
        ;

  options_ue_stack.add_options()
        ("ue.stack.sr.period",      bpo::value<uint32_t>(&ue_stack.sr_period)->default_value(ue_stack.sr_period),           "SR period in number of opportunities. Set 0 to disable and 1 for all.")
        ("ue.stack.prach.period",   bpo::value<uint32_t>(&ue_stack.prach_period)->default_value(ue_stack.prach_period),     "PRACH period in SFN. Set 0 to disable and 1 for all.")
        ;

  options_assertion.add_options()
      ("assert.sr.detection.min",  bpo::value<double>(&assert_sr_detection_min)->default_value(assert_sr_detection_min),   "Scheduling request minimum detection threshold")
      ("assert.cqi.detection.min", bpo::value<double>(&assert_cqi_detection_min)->default_value(assert_cqi_detection_min), "CQI report minimum detection threshold")
      ("assert.pusch.bler.max",    bpo::value<double>(&assert_pusch_bler_max)->default_value(assert_pusch_bler_max),       "PUSCH maximum BLER threshold")
      ("assert.pdsch.bler.max",    bpo::value<double>(&assert_pdsch_bler_max)->default_value(assert_pdsch_bler_max),       "PDSCH maximum BLER threshold")
      ("assert.prach.ta.min",      bpo::value<double>(&assert_prach_ta_min)->default_value(assert_prach_ta_min),           "PRACH estimated TA minimum value threshold")
      ("assert.prach.ta.max",      bpo::value<double>(&assert_prach_ta_max)->default_value(assert_prach_ta_max),           "PRACH estimated TA maximum value threshold")
      ("assert.pucch.snr.min",     bpo::value<double>(&assert_pucch_snr_min)->default_value(assert_pucch_snr_min),         "PUCCH DMRS minimum SNR allowed threshold")
      ;

  options_conf_file.add_options()
      ("config_file", bpo::value<std::string>(&config_file), "Configuration file")
      ;
  bpo::positional_options_description p;
  p.add("config_file", -1);

  options.add(options_tb).add(options_assertion).add(options_gnb_stack).add(options_gnb_phy).add(options_ue_stack).add(options_ue_phy).add(options_conf_file).add_options()
        ("help",                      "Show this message")
        ;
  // clang-format on

  bpo::variables_map vm;
  try {
    bpo::store(bpo::command_line_parser(argc, argv).options(options).positional(p).run(), vm);
    bpo::notify(vm);

    // Apply the High Speed Train args to the DL channel as well
    ul_channel.hst_enable = std::isnormal(ul_channel.hst_fd_hz);
    dl_channel.hst_enable = ul_channel.hst_enable;
    dl_channel.hst_fd_hz  = ul_channel.hst_fd_hz;
  } catch (bpo::error& e) {
    std::cerr << e.what() << std::endl;
    return;
  }

  // help option was given or error - print usage and exit
  if (vm.count("help")) {
    std::cout << "Usage: " << argv[0] << " [OPTIONS] config_file" << std::endl << std::endl;
    std::cout << options_tb << std::endl << options_assertion << std::endl;
    std::cout << options_gnb_phy << std::endl << options_gnb_stack << std::endl;
    std::cout << options_ue_phy << std::endl << options_ue_stack << std::endl;
    exit(0);
  }

  // if config file given
  if (vm.count("config_file") != 0U) {
    std::cout << "Reading configuration file " << config_file << "..." << std::endl;
    std::ifstream conf(config_file.c_str(), std::ios::in);
    if (conf.fail()) {
      std::cout << "Failed to read configuration file " << config_file << " - exiting" << std::endl;
      exit(1);
    }

    // parse config file and handle errors gracefully
    try {
      bpo::store(bpo::parse_config_file(conf, options), vm);
      bpo::notify(vm);
    } catch (const boost::program_options::error& e) {
      std::cerr << e.what() << std::endl;
      exit(1);
    }
  }

  // Load default reference configuration
  phy_cfg = srsran::phy_cfg_nr_default_t(srsran::phy_cfg_nr_default_t::reference_cfg_t(reference_cfg_str));

  // Calculate the DL signal power from the number of PRBs
  dl_channel.awgn_signal_power_dBfs = srsran_gnb_dl_get_maximum_signal_power_dBfs(phy_cfg.carrier.nof_prb);

  // Reverses the Doppler shift for the UL
  ul_channel.hst_init_time_s = 0.5 * dl_channel.hst_period_s;

  // Calculate sampling rate in Hz
  srate_hz = (double)(srsran_min_symbol_sz_rb(phy_cfg.carrier.nof_prb) * SRSRAN_SUBC_SPACING_NR(phy_cfg.carrier.scs));

  cell_list.resize(1);
  cell_list[0].carrier = phy_cfg.carrier;
  cell_list[0].rf_port = 0;
  cell_list[0].cell_id = 0;
  cell_list[0].pdcch   = phy_cfg.pdcch;

  ue_stack.rnti = rnti;

  gnb_stack.rnti          = rnti;
  gnb_stack.phy_cfg       = phy_cfg;
  gnb_stack.wait_preamble = ue_stack.prach_period > 0;

  if (gnb_stack.pdsch.rb_length == 0) {
    gnb_stack.pdsch.rb_length = phy_cfg.carrier.nof_prb;
    gnb_stack.pdsch.rb_start  = 0;
  }

  if (gnb_stack.pusch.rb_length == 0) {
    gnb_stack.pusch.rb_length = phy_cfg.carrier.nof_prb;
    gnb_stack.pdsch.rb_start  = 0;
  }

  // Flag configuration as valid
  valid = true;
}

int main(int argc, char** argv)
{
  srslog::init();

  // Parse test bench arguments
  test_bench::args_t args(argc, argv);

  // Parse arguments
  TESTASSERT(args.valid);

  // Create test bench
  test_bench tb(args);

  // Assert bench is initialised correctly
  TESTASSERT(tb.is_initialised());

  // Run per TTI basis
  while (tb.run_tti()) {
    ; // Do nothing
  }

  // Stop test bench
  tb.stop();

  // Flush log
  srslog::flush();

  // Retrieve MAC metrics
  test_bench::metrics_t metrics = tb.get_metrics();

  // Print PRACH
  double   prach_detection = 0.0;
  double   prach_ta        = 0.0;
  uint32_t prach_tx_count  = 0;
  uint32_t prach_rx_count  = 0;
  if (metrics.ue_stack.prach.size() > 0) {
    srsran::console("PRACH:\n");
    srsran::console(
        "   +------------+------------+------------+------------+------------+------------+------------+\n");
    srsran::console("   | %10s | %10s | %10s | %10s | %10s | %10s | %10s |\n",
                    "Preamble",
                    "Transmit'd",
                    "Received",
                    "Detection",
                    "Avg TA",
                    "Min TA",
                    "Max TA");
    srsran::console(
        "   +------------+------------+------------+------------+------------+------------+------------+\n");

    for (const auto& p : metrics.ue_stack.prach) {
      // Ensure the detected count matches with transmission
      //      TESTASSERT(metrics.gnb_stack.prach.count(p.first));
      //      TESTASSERT(metrics.gnb_stack.prach[p.first].count == p.second.count);
      TESTASSERT(p.second.count != 0);
      prach_tx_count += p.second.count;

      gnb_dummy_stack::prach_metrics_t gnb_prach = {};
      if (metrics.gnb_stack.prach.count(p.first) > 0) {
        gnb_prach = metrics.gnb_stack.prach[p.first];
        prach_ta  = SRSRAN_VEC_SAFE_CMA(gnb_prach.avg_ta, prach_ta, prach_rx_count);
      } else {
        gnb_prach.avg_ta = NAN;
        gnb_prach.min_ta = NAN;
        gnb_prach.max_ta = NAN;
      }
      prach_rx_count += gnb_prach.count;

      double detection = (double)gnb_prach.count / (double)p.second.count;

      srsran::console("   | %10d | %10d | %10d | %10.3f | %10.1f | %10.1f | %10.1f |\n",
                      p.first,
                      p.second.count,
                      gnb_prach.count,
                      detection,
                      gnb_prach.avg_ta,
                      gnb_prach.min_ta,
                      gnb_prach.max_ta);
    }
    srsran::console(
        "   +------------+------------+------------+------------+------------+------------+------------+\n");
  }
  if (prach_tx_count > 0) {
    prach_detection = (double)prach_rx_count / (double)prach_tx_count;
  }

  // Print PUCCH
  if (metrics.gnb_stack.pucch.count > 0) {
    srsran::console("PUCCH DMRS Receiver metrics:\n");
    srsran::console("   +------------+------------+------------+------------+\n");
    srsran::console("   | %10s | %10s | %10s | %10s |\n", "Measure", "Average", "Min", "Max");
    srsran::console("   +------------+------------+------------+------------+\n");
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "EPRE (dB)",
                    metrics.gnb_stack.pucch.epre_db_avg,
                    metrics.gnb_stack.pucch.epre_db_min,
                    metrics.gnb_stack.pucch.epre_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "RSRP (dB)",
                    metrics.gnb_stack.pucch.rsrp_db_avg,
                    metrics.gnb_stack.pucch.rsrp_db_min,
                    metrics.gnb_stack.pucch.rsrp_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "SINR (dB)",
                    metrics.gnb_stack.pucch.snr_db_avg,
                    metrics.gnb_stack.pucch.snr_db_min,
                    metrics.gnb_stack.pucch.snr_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "TA (us)",
                    metrics.gnb_stack.pucch.ta_us_avg,
                    metrics.gnb_stack.pucch.ta_us_min,
                    metrics.gnb_stack.pucch.ta_us_max);
    srsran::console("   +------------+------------+------------+------------+\n");
  }

  // Print PDSCH metrics if scheduled
  double pdsch_bler = 0.0;
  if (metrics.gnb_stack.mac.tx_pkts > 0) {
    pdsch_bler = (double)metrics.gnb_stack.mac.tx_errors / (double)metrics.gnb_stack.mac.tx_pkts;

    float pdsch_shed_rate = 0.0f;
    pdsch_shed_rate       = (float)metrics.gnb_stack.mac.tx_brate / (float)metrics.gnb_stack.mac.tx_pkts / 1000.0f;

    srsran::console("PDSCH:\n");
    srsran::console("       Count: %d\n", metrics.gnb_stack.mac.tx_pkts);
    srsran::console("        BLER: %f\n", pdsch_bler);
    srsran::console("  Sched Rate: %f Mbps\n", pdsch_shed_rate);
    srsran::console("    Net Rate: %f Mbps\n", (1.0f - pdsch_bler) * pdsch_shed_rate);
    srsran::console("   Retx Rate: %f Mbps\n", pdsch_bler * pdsch_shed_rate);
    srsran::console("\n");
  }

  // Print PUSCH metrics if scheduled
  double pusch_bler = 0.0;
  if (metrics.gnb_stack.mac.rx_pkts > 0) {
    if (metrics.gnb_stack.mac.rx_pkts != 0) {
      pusch_bler = (double)metrics.gnb_stack.mac.rx_errors / (double)metrics.gnb_stack.mac.rx_pkts;
    }

    float pusch_shed_rate = 0.0f;
    if (metrics.gnb_stack.mac.rx_pkts != 0) {
      pusch_shed_rate = (float)metrics.gnb_stack.mac.rx_brate / (float)metrics.gnb_stack.mac.rx_pkts / 1000.0f;
    }

    srsran::console("PUSCH:\n");
    srsran::console("       Count: %d\n", metrics.gnb_stack.mac.rx_pkts);
    srsran::console("        BLER: %f\n", pusch_bler);
    srsran::console("  Sched Rate: %f Mbps\n", pusch_shed_rate);
    srsran::console("    Net Rate: %f Mbps\n", (1.0f - pusch_bler) * pusch_shed_rate);
    srsran::console("   Retx Rate: %f Mbps\n", pusch_bler * pusch_shed_rate);
    srsran::console("\n");
  }

  // Print PUSCH
  if (metrics.gnb_stack.pusch.count > 0) {
    srsran::console("PUSCH DMRS Receiver metrics:\n");
    srsran::console("   +------------+------------+------------+------------+\n");
    srsran::console("   | %10s | %10s | %10s | %10s |\n", "Measure", "Average", "Min", "Max");
    srsran::console("   +------------+------------+------------+------------+\n");
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "EPRE (dB)",
                    metrics.gnb_stack.pusch.epre_db_avg,
                    metrics.gnb_stack.pusch.epre_db_min,
                    metrics.gnb_stack.pusch.epre_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "RSRP (dB)",
                    metrics.gnb_stack.pusch.rsrp_db_avg,
                    metrics.gnb_stack.pusch.rsrp_db_min,
                    metrics.gnb_stack.pusch.rsrp_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "SINR (dB)",
                    metrics.gnb_stack.pusch.snr_db_avg,
                    metrics.gnb_stack.pusch.snr_db_min,
                    metrics.gnb_stack.pusch.snr_db_max);
    srsran::console("   | %10s | %+10.2f | %+10.2f | %+10.2f |\n",
                    "TA (us)",
                    metrics.gnb_stack.pusch.ta_us_avg,
                    metrics.gnb_stack.pusch.ta_us_min,
                    metrics.gnb_stack.pusch.ta_us_max);
    srsran::console("   +------------+------------+------------+------------+\n");
  }

  srsran::console("UCI stats:\n");
  srsran::console("   +------------+------------+------------+------------+------------+\n");
  srsran::console(
      "   | %10s | %10s | %10s | %10s | %10s |\n", "Field", "Transmit'd", "Received", "Detection", "Avg. Val.");
  srsran::console("   +------------+------------+------------+------------+------------+\n");

  // Print SR
  double sr_detection = 0.0;
  if (metrics.ue_stack.sr_count > 0) {
    sr_detection = (double)metrics.gnb_stack.sr_count / (double)metrics.ue_stack.sr_count;
    srsran::console("   | %10s | %10d | %10d | %10.5f | %10s |\n",
                    "SR",
                    metrics.ue_stack.sr_count,
                    metrics.gnb_stack.sr_count,
                    sr_detection,
                    "-");
  }

  // Print SR
  double cqi_detection = 0.0;
  if (metrics.gnb_stack.cqi_count > 0) {
    cqi_detection = (double)metrics.gnb_stack.cqi_valid_count / (double)metrics.gnb_stack.cqi_count;
    srsran::console("   | %10s | %10d | %10d | %10.5f | %10.5f |\n",
                    "CQI",
                    metrics.gnb_stack.cqi_count,
                    metrics.gnb_stack.cqi_valid_count,
                    cqi_detection,
                    metrics.gnb_stack.mac.dl_cqi);
  }
  srsran::console("   +------------+------------+------------+------------+------------+\n");

  // Assert metrics
  srsran_assert(metrics.gnb_stack.mac.tx_pkts == 0 or pdsch_bler <= assert_pdsch_bler_max,
                "PDSCH BLER (%f) exceeds the assertion maximum (%f)",
                pdsch_bler,
                assert_pusch_bler_max);
  srsran_assert(metrics.gnb_stack.mac.rx_pkts == 0 or pusch_bler <= assert_pusch_bler_max,
                "PUSCH BLER (%f) exceeds the assertion maximum (%f)",
                pusch_bler,
                assert_pusch_bler_max);
  srsran_assert(metrics.ue_stack.sr_count == 0 or sr_detection >= assert_sr_detection_min,
                "SR detection probability (%f) did not reach the assertion minimum (%f)",
                sr_detection,
                assert_sr_detection_min);
  srsran_assert(metrics.gnb_stack.cqi_count == 0 or cqi_detection >= assert_cqi_detection_min,
                "CQI report detection probability (%f) did not reach the assertion minimum (%f)",
                cqi_detection,
                assert_sr_detection_min);
  srsran_assert(prach_tx_count == 0 or prach_detection >= assert_prach_detection_min,
                "PRACH detection probability (%f) did not reach the assertion minimum (%f)",
                prach_detection,
                assert_prach_detection_min);
  srsran_assert(prach_tx_count == 0 or (prach_ta >= assert_prach_ta_min and prach_ta <= assert_prach_ta_max),
                "PRACH TA average measurement %f is higher than minimum (%d) or above maximum (%f)",
                prach_ta,
                assert_prach_ta_min,
                assert_prach_ta_max);
  srsran_assert(metrics.gnb_stack.pucch.count == 0 or (metrics.gnb_stack.pucch.snr_db_min >= assert_pucch_snr_min),
                "Minimum PUCCH DMRS SNR %f is below the minimum (%d)",
                metrics.gnb_stack.pucch.snr_db_min,
                assert_pucch_snr_min);

  // If reached here, the test is successful
  return SRSRAN_SUCCESS;
}