// SPDX-FileCopyrightText: Copyright (C) 2021-2026 Software Radio Systems Limited

// SPDX-FileCopyrightText: Copyright (C) 2026 OCUDU contributors

// SPDX-License-Identifier: BSD-3-Clause-Open-MPI

// Portions of this file may implement 3GPP specifications, which may be subject to additional licensing requirements.

#pragma once

#include "ocudu/asn1/asn1_utils.h"

#include "ocudu/asn1/nrppa/nrppa_ies.h"

#include "ocudu/nrppa/nrppa_e_cid.h"

#include "ocudu/ocudulog/ocudulog.h"

#include "ocudu/ran/cyclic_prefix.h"

#include "ocudu/ran/nr_cell_identity.h"

#include "ocudu/ran/nr_cgi.h"

#include "ocudu/ran/positioning/common.h"

#include "ocudu/ran/positioning/measurement_information.h"

#include "ocudu/ran/positioning/positioning_information_exchange.h"

#include "ocudu/ran/positioning/trp_information_exchange.h"

#include "ocudu/ran/srs/srs_configuration.h"

#include "ocudu/support/enum_utils.h"

#include <variant>

namespace ocudu::ocucp {

// Helper to create PDU from NRPPA message

template <class T>

byte_buffer pack_into_pdu(const T& msg, const char* context_name = nullptr)

{

  context_name = context_name == nullptr ? __FUNCTION__ : context_name;

  byte_buffer   pdu{};

  asn1::bit_ref bref{pdu};

  if (msg.pack(bref) == asn1::OCUDUASN_ERROR_ENCODE_FAIL) {

    ocudulog::fetch_basic_logger("NRPPA").error("Failed to pack message in {} - discarding it", context_name);

    pdu.clear();

  }

  return pdu;

}

inline meas_periodicity_t asn1_to_meas_periodicity(asn1::nrppa::meas_periodicity_e asn1_meas_periodicity)

{

  if (asn1_meas_periodicity == asn1::nrppa::meas_periodicity_opts::nulltype) {

    report_fatal_error("Unsupported NRPPa meas periodicity. NRPPa meas periodicity={}",

                       fmt::underlying(asn1_meas_periodicity.value));

  }

  return static_cast<meas_periodicity_t>(asn1_meas_periodicity.to_number());

}

inline nrppa_meas_quantities_item

asn1_to_meas_quantities_item(const asn1::nrppa::meas_quantities_item_s& asn1_meas_quantities_item)

{

  nrppa_meas_quantities_item meas_quantities_item;

  switch (asn1_meas_quantities_item.meas_quantities_value) {

    case asn1::nrppa::meas_quantities_value_e::cell_id:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::cell_id;

      break;

    case asn1::nrppa::meas_quantities_value_e::angle_of_arrival:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::angle_of_arrival;

      break;

    case asn1::nrppa::meas_quantities_value_e::timing_advance_type1:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::timing_advance_type1;

      break;

    case asn1::nrppa::meas_quantities_value_e::timing_advance_type2:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::timing_advance_type2;

      break;

    case asn1::nrppa::meas_quantities_value_e::rsrp:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::rsrp;

      break;

    case asn1::nrppa::meas_quantities_value_e::rsrq:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::rsrq;

      break;

    case asn1::nrppa::meas_quantities_value_e::ss_rsrp:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::ss_rsrp;

      break;

    case asn1::nrppa::meas_quantities_value_e::ss_rsrq:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::ss_rsrq;

      break;

    case asn1::nrppa::meas_quantities_value_e::csi_rsrp:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::csi_rsrp;

      break;

    case asn1::nrppa::meas_quantities_value_e::csi_rsrq:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::csi_rsrq;

      break;

    case asn1::nrppa::meas_quantities_value_e::angle_of_arrival_nr:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::angle_of_arrival_nr;

      break;

    case asn1::nrppa::meas_quantities_value_e::timing_advance_nr:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::timing_advance_nr;

      break;

    case asn1::nrppa::meas_quantities_value_e::ue_rx_tx_time_diff:

      meas_quantities_item.meas_quantities_value = nrppa_meas_quantities_value::ue_rx_tx_time_diff;

      break;

    default:

      report_fatal_error("Unsupported NRPPa meas quantities value. NRPPa meas quantities value={}",

                         asn1_meas_quantities_item.meas_quantities_value.to_number());

  }

  return meas_quantities_item;

}

inline asn1::nrppa::meas_quantities_item_s

meas_quantities_item_to_asn1(const nrppa_meas_quantities_item& meas_quantities_item)

{

  asn1::nrppa::meas_quantities_item_s asn1_meas_quantities_item;

  switch (meas_quantities_item.meas_quantities_value) {

    case nrppa_meas_quantities_value::cell_id:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::cell_id;

      break;

    case nrppa_meas_quantities_value::angle_of_arrival:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::angle_of_arrival;

      break;

    case nrppa_meas_quantities_value::timing_advance_type1:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::timing_advance_type1;

      break;

    case nrppa_meas_quantities_value::timing_advance_type2:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::timing_advance_type2;

      break;

    case nrppa_meas_quantities_value::rsrp:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::rsrp;

      break;

    case nrppa_meas_quantities_value::rsrq:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::rsrq;

      break;

    case nrppa_meas_quantities_value::ss_rsrp:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::ss_rsrp;

      break;

    case nrppa_meas_quantities_value::ss_rsrq:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::ss_rsrq;

      break;

    case nrppa_meas_quantities_value::csi_rsrp:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::csi_rsrp;

      break;

    case nrppa_meas_quantities_value::csi_rsrq:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::csi_rsrq;

      break;

    case nrppa_meas_quantities_value::angle_of_arrival_nr:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::angle_of_arrival_nr;

      break;

    case nrppa_meas_quantities_value::timing_advance_nr:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::timing_advance_nr;

      break;

    case nrppa_meas_quantities_value::ue_rx_tx_time_diff:

      asn1_meas_quantities_item.meas_quantities_value = asn1::nrppa::meas_quantities_value_opts::ue_rx_tx_time_diff;

      break;

    default:

      report_fatal_error("Unsupported NRPPa meas quantities value");

  }

  return asn1_meas_quantities_item;

}

inline asn1::nrppa::ng_ran_access_point_position_s

ng_ran_access_point_position_to_asn1(const ng_ran_access_point_position_t& ng_ran_access_point_position)

{

  asn1::nrppa::ng_ran_access_point_position_s asn1_ng_ran_access_point_position;

  // Fill latitude sign.

  asn1_ng_ran_access_point_position.latitude_sign.value =

      static_cast<asn1::nrppa::ng_ran_access_point_position_s::latitude_sign_opts::options>(

          ng_ran_access_point_position.latitude_sign);

  // Fill latutide.

  asn1_ng_ran_access_point_position.latitude = ng_ran_access_point_position.latitude;

  // Fill longitude.

  asn1_ng_ran_access_point_position.longitude = ng_ran_access_point_position.longitude;

  // Direction of altitude.

  asn1_ng_ran_access_point_position.direction_of_altitude.value =

      static_cast<asn1::nrppa::ng_ran_access_point_position_s::direction_of_altitude_opts::options>(

          ng_ran_access_point_position.direction_of_altitude);

  // Fill altitude.

  asn1_ng_ran_access_point_position.altitude = ng_ran_access_point_position.altitude;

  // Fill uncertainty semi major.

  asn1_ng_ran_access_point_position.uncertainty_semi_major = ng_ran_access_point_position.uncertainty_semi_major;

  // Fill uncertainty semi minor.

  asn1_ng_ran_access_point_position.uncertainty_semi_minor = ng_ran_access_point_position.uncertainty_semi_minor;

  // Fill orientation of major axis.

  asn1_ng_ran_access_point_position.orientation_of_major_axis = ng_ran_access_point_position.orientation_of_major_axis;

  // Fill uncertainty altitude.

  asn1_ng_ran_access_point_position.uncertainty_altitude = ng_ran_access_point_position.uncertainty_altitude;

  // Fill confidence.

  asn1_ng_ran_access_point_position.confidence = ng_ran_access_point_position.confidence;

  return asn1_ng_ran_access_point_position;

}

inline asn1::nrppa::e_c_id_meas_result_s e_cid_meas_result_to_asn1(const nrppa_e_cid_meas_result& meas_result)

{

  asn1::nrppa::e_c_id_meas_result_s asn1_meas_result;

  // Serving cell id.

  asn1_meas_result.serving_cell_id.ng_ran_cell.set_nr_cell_id().from_number(meas_result.serving_cell_id.nci.value());

  asn1_meas_result.serving_cell_id.plmn_id = meas_result.serving_cell_id.plmn_id.to_bytes();

  // Serving cell tac.

  asn1_meas_result.serving_cell_tac.from_number(meas_result.serving_cell_tac);

  // NG-RAN access point position.

  if (meas_result.ng_ran_access_point_position.has_value()) {

    asn1_meas_result.ng_ran_access_point_position_present = true;

    asn1_meas_result.ng_ran_access_point_position =

        ng_ran_access_point_position_to_asn1(meas_result.ng_ran_access_point_position.value());

  }

  // Measured results.

  // Note that only NR results are supported.

  for (const auto& measured_results_value : meas_result.measured_results) {

    asn1::nrppa::measured_results_value_c asn1_measured_results_value;

    auto&                                 result_nr = asn1_measured_results_value.set_choice_ext();

    // SS RSRP.

    if (const auto* result = std::get_if<std::vector<nrppa_result_ss_rsrp_item>>(&measured_results_value)) {

      asn1::nrppa::result_ss_rsrp_l rsrp_list;

      for (const auto& result_item : *result) {

        asn1::nrppa::result_ss_rsrp_item_s rsrp_item;

        rsrp_item.nr_pci   = result_item.nr_pci;

        rsrp_item.nr_arfcn = result_item.nr_arfcn.value();

        if (result_item.cgi_nr.has_value()) {

          rsrp_item.cgi_nr_present = true;

          rsrp_item.cgi_nr.nr_cell_id.from_number(result_item.cgi_nr->nci.value());

          rsrp_item.cgi_nr.plmn_id = result_item.cgi_nr->plmn_id.to_bytes();

        }

        if (result_item.value_ss_rsrp_cell.has_value()) {

          rsrp_item.value_ss_rsrp_cell_present = true;

          rsrp_item.value_ss_rsrp_cell         = result_item.value_ss_rsrp_cell.value();

        }

        for (const auto& rsrp_per_ssb_item : result_item.ss_rsrp_per_ssb) {

          asn1::nrppa::result_ss_rsrp_per_ssb_item_s asn1_rsrp_per_ssb_item;

          asn1_rsrp_per_ssb_item.ssb_idx       = rsrp_per_ssb_item.ssb_idx;

          asn1_rsrp_per_ssb_item.value_ss_rsrp = rsrp_per_ssb_item.value_ss_rsrp;

          rsrp_item.ss_rsrp_per_ssb.push_back(asn1_rsrp_per_ssb_item);

        }

        rsrp_list.push_back(rsrp_item);

      }

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::result_ss_rsrp);

      result_nr->result_ss_rsrp() = rsrp_list;

    }

    // SS RSRQ.

    if (const auto* result = std::get_if<std::vector<nrppa_result_ss_rsrq_item>>(&measured_results_value)) {

      asn1::nrppa::result_ss_rsrq_l rsrq_list;

      for (const auto& result_item : *result) {

        asn1::nrppa::result_ss_rsrq_item_s rsrq_item;

        rsrq_item.nr_pci   = result_item.nr_pci;

        rsrq_item.nr_arfcn = result_item.nr_arfcn.value();

        if (result_item.cgi_nr.has_value()) {

          rsrq_item.cgi_nr_present = true;

          rsrq_item.cgi_nr.nr_cell_id.from_number(result_item.cgi_nr->nci.value());

          rsrq_item.cgi_nr.plmn_id = result_item.cgi_nr->plmn_id.to_bytes();

        }

        if (result_item.value_ss_rsrq_cell.has_value()) {

          rsrq_item.value_ss_rsrq_cell_present = true;

          rsrq_item.value_ss_rsrq_cell         = result_item.value_ss_rsrq_cell.value();

        }

        for (const auto& rsrq_per_ssb_item : result_item.ss_rsrq_per_ssb) {

          asn1::nrppa::result_ss_rsrq_per_ssb_item_s asn1_rsrq_per_ssb_item;

          asn1_rsrq_per_ssb_item.ssb_idx       = rsrq_per_ssb_item.ssb_idx;

          asn1_rsrq_per_ssb_item.value_ss_rsrq = rsrq_per_ssb_item.value_ss_rsrq;

          rsrq_item.ss_rsrq_per_ssb.push_back(asn1_rsrq_per_ssb_item);

        }

        rsrq_list.push_back(rsrq_item);

      }

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::result_ss_rsrq);

      result_nr->result_ss_rsrq() = rsrq_list;

    }

    // CSI RSRP.

    if (const auto* result = std::get_if<std::vector<nrppa_result_csi_rsrp_item>>(&measured_results_value)) {

      asn1::nrppa::result_csi_rsrp_l rsrp_list;

      for (const auto& result_item : *result) {

        asn1::nrppa::result_csi_rsrp_item_s rsrp_item;

        rsrp_item.nr_pci   = result_item.nr_pci;

        rsrp_item.nr_arfcn = result_item.nr_arfcn.value();

        if (result_item.cgi_nr.has_value()) {

          rsrp_item.cgi_nr_present = true;

          rsrp_item.cgi_nr.nr_cell_id.from_number(result_item.cgi_nr->nci.value());

          rsrp_item.cgi_nr.plmn_id = result_item.cgi_nr->plmn_id.to_bytes();

        }

        if (result_item.value_csi_rsrp_cell.has_value()) {

          rsrp_item.value_csi_rsrp_cell_present = true;

          rsrp_item.value_csi_rsrp_cell         = result_item.value_csi_rsrp_cell.value();

        }

        for (const auto& csi_rsrp_per_csi_rs_item : result_item.csi_rsrp_per_csi_rs) {

          asn1::nrppa::result_csi_rsrp_per_csi_rs_item_s asn1_csi_rsrp_per_csi_rs_item;

          asn1_csi_rsrp_per_csi_rs_item.csi_rs_idx     = csi_rsrp_per_csi_rs_item.csi_rs_idx;

          asn1_csi_rsrp_per_csi_rs_item.value_csi_rsrp = csi_rsrp_per_csi_rs_item.value_csi_rsrp;

          rsrp_item.csi_rsrp_per_csi_rs.push_back(asn1_csi_rsrp_per_csi_rs_item);

        }

        rsrp_list.push_back(rsrp_item);

      }

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::result_csi_rsrp);

      result_nr->result_csi_rsrp() = rsrp_list;

    }

    // CSI RSRQ.

    if (const auto* result = std::get_if<std::vector<nrppa_result_csi_rsrq_item>>(&measured_results_value)) {

      asn1::nrppa::result_csi_rsrq_l rsrq_list;

      for (const auto& result_item : *result) {

        asn1::nrppa::result_csi_rsrq_item_s rsrq_item;

        rsrq_item.nr_pci   = result_item.nr_pci;

        rsrq_item.nr_arfcn = result_item.nr_arfcn.value();

        if (result_item.cgi_nr.has_value()) {

          rsrq_item.cgi_nr_present = true;

          rsrq_item.cgi_nr.nr_cell_id.from_number(result_item.cgi_nr->nci.value());

          rsrq_item.cgi_nr.plmn_id = result_item.cgi_nr->plmn_id.to_bytes();

        }

        if (result_item.value_csi_rsrq_cell.has_value()) {

          rsrq_item.value_csi_rsrq_cell_present = true;

          rsrq_item.value_csi_rsrq_cell         = result_item.value_csi_rsrq_cell.value();

        }

        for (const auto& csi_rsrq_per_csi_rs_item : result_item.csi_rsrq_per_csi_rs) {

          asn1::nrppa::result_csi_rsrq_per_csi_rs_item_s asn1_csi_rsrq_per_csi_rs_item;

          asn1_csi_rsrq_per_csi_rs_item.csi_rs_idx     = csi_rsrq_per_csi_rs_item.csi_rs_idx;

          asn1_csi_rsrq_per_csi_rs_item.value_csi_rsrq = csi_rsrq_per_csi_rs_item.value_csi_rsrq;

          rsrq_item.csi_rsrq_per_csi_rs.push_back(asn1_csi_rsrq_per_csi_rs_item);

        }

        rsrq_list.push_back(rsrq_item);

      }

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::result_csi_rsrq);

      result_nr->result_csi_rsrq() = rsrq_list;

    }

    // Angle of arrival.

    if (const auto* result = std::get_if<nrppa_ul_aoa>(&measured_results_value)) {

      asn1::nrppa::ul_ao_a_s asn1_aoa;

      asn1_aoa.azimuth_ao_a = result->azimuth_aoa;

      if (result->zenith_aoa.has_value()) {

        asn1_aoa.zenith_ao_a_present = true;

        asn1_aoa.zenith_ao_a         = result->zenith_aoa.value();

      }

      if (result->lcs_to_gcs_translation.has_value()) {

        asn1_aoa.lcs_to_gcs_translation_present = true;

        asn1_aoa.lcs_to_gcs_translation.alpha   = result->lcs_to_gcs_translation->alpha;

        asn1_aoa.lcs_to_gcs_translation.beta    = result->lcs_to_gcs_translation->beta;

        asn1_aoa.lcs_to_gcs_translation.gamma   = result->lcs_to_gcs_translation->gamma;

      }

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::angle_of_arrival_nr);

      result_nr->angle_of_arrival_nr() = asn1_aoa;

    }

    // NR Timing advance.

    if (const auto* result = std::get_if<nrppa_nr_tadv>(&measured_results_value)) {

      result_nr->set(asn1::nrppa::measured_results_value_ext_ie_o::value_c::types_opts::nr_tadv);

      result_nr->nr_tadv() = static_cast<uint16_t>(*result);

    }

    asn1_meas_result.measured_results.push_back(asn1_measured_results_value);

  }

  return asn1_meas_result;

}

/// \brief Convert \c nrppa_cause_t type to NRPPA ASN.1 cause.

/// \param cause The nrppa_cause_t type.

/// \return The NRPPA ASN.1 cause.

inline asn1::nrppa::cause_c cause_to_asn1(nrppa_cause_t cause)

{

  asn1::nrppa::cause_c asn1_cause;

  if (const auto* result = std::get_if<nrppa_cause_radio_network_t>(&cause)) {

    asn1_cause.set_radio_network() = static_cast<asn1::nrppa::cause_radio_network_opts::options>(*result);

    return asn1_cause;

  }

  if (const auto* result = std::get_if<nrppa_cause_protocol_t>(&cause)) {

    asn1_cause.set_protocol() = static_cast<asn1::nrppa::cause_protocol_opts::options>(*result);

    return asn1_cause;

  }

  if (const auto* result = std::get_if<nrppa_cause_misc_t>(&cause)) {

    asn1_cause.set_misc() = static_cast<asn1::nrppa::cause_misc_opts::options>(*result);

    return asn1_cause;

  }

  report_fatal_error("Cannot convert cause to NRPPA type");

  return asn1_cause;

}

inline std::optional<trp_information_type_item_t>

asn1_to_trp_info_type_item(const asn1::nrppa::trp_info_type_item_e& asn1_trp_info_type_item)

{

  trp_information_type_item_t trp_info_type_item;

  switch (asn1_trp_info_type_item) {

    case asn1::nrppa::trp_info_type_item_opts::options::nr_pci:

      trp_info_type_item = trp_information_type_item_t::nr_pci;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::ng_ran_cgi:

      trp_info_type_item = trp_information_type_item_t::ng_ran_cgi;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::arfcn:

      trp_info_type_item = trp_information_type_item_t::arfcn;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::prs_cfg:

      trp_info_type_item = trp_information_type_item_t::prs_cfg;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::ssb_info:

      trp_info_type_item = trp_information_type_item_t::ssb_info;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::sfn_init_time:

      trp_info_type_item = trp_information_type_item_t::sfn_init_time;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::spatial_direct_info:

      trp_info_type_item = trp_information_type_item_t::spatial_direct_info;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::geo_coord:

      trp_info_type_item = trp_information_type_item_t::geo_coord;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::trp_type:

      trp_info_type_item = trp_information_type_item_t::trp_type;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::ondemand_pr_si_nfo:

      trp_info_type_item = trp_information_type_item_t::ondemand_prs_info;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::trp_tx_teg:

      trp_info_type_item = trp_information_type_item_t::trp_tx_teg;

      break;

    case asn1::nrppa::trp_info_type_item_opts::options::beam_ant_info:

      trp_info_type_item = trp_information_type_item_t::beam_ant_info;

      break;

    default:

      ocudulog::fetch_basic_logger("NRPPA").info("Unsupported NRPPa TRP info type item ({}). Ignoring it",

                                                 asn1_trp_info_type_item.to_string());

      return std::nullopt;

  }

  return trp_info_type_item;

}

inline asn1::nrppa::dl_prs_muting_pattern_c

dl_prs_muting_pattern_to_asn1(const dl_prs_muting_pattern_t& dl_prs_muting_pattern)

{

  asn1::nrppa::dl_prs_muting_pattern_c asn1_dl_prs_muting_pattern;

  if (dl_prs_muting_pattern.length == 2) {

    asn1_dl_prs_muting_pattern.set_two().from_number(dl_prs_muting_pattern.value);

  }

  if (dl_prs_muting_pattern.length == 4) {

    asn1_dl_prs_muting_pattern.set_four().from_number(dl_prs_muting_pattern.value);

  }

  if (dl_prs_muting_pattern.length == 6) {

    asn1_dl_prs_muting_pattern.set_six().from_number(dl_prs_muting_pattern.value);

  }

  if (dl_prs_muting_pattern.length == 8) {

    asn1_dl_prs_muting_pattern.set_eight().from_number(dl_prs_muting_pattern.value);

  }

  if (dl_prs_muting_pattern.length == 16) {

    asn1_dl_prs_muting_pattern.set_sixteen().from_number(dl_prs_muting_pattern.value);

  }

  if (dl_prs_muting_pattern.length == 32) {

    asn1_dl_prs_muting_pattern.set_thirty_two().from_number(dl_prs_muting_pattern.value);

  }

  return asn1_dl_prs_muting_pattern;

}

inline asn1::nrppa::prs_muting_s prs_muting_to_asn1(const prs_muting_t& prs_muting)

{

  asn1::nrppa::prs_muting_s asn1_prs_muting;

  if (prs_muting.prs_muting_option1.has_value()) {

    asn1_prs_muting.prs_muting_option1_present = true;

    asn1_prs_muting.prs_muting_option1.muting_pattern =

        dl_prs_muting_pattern_to_asn1(prs_muting.prs_muting_option1->muting_pattern);

    asn1::number_to_enum(asn1_prs_muting.prs_muting_option1.muting_bit_repeat_factor,

                         prs_muting.prs_muting_option1->muting_bit_repeat_factor);

  }

  if (prs_muting.prs_muting_option2.has_value()) {

    asn1_prs_muting.prs_muting_option2_present = true;

    asn1_prs_muting.prs_muting_option2.muting_pattern =

        dl_prs_muting_pattern_to_asn1(prs_muting.prs_muting_option2->muting_pattern);

  }

  return asn1_prs_muting;

}

inline asn1::nrppa::prs_res_set_item_s prs_resource_set_item_to_asn1(const prs_resource_set_item_t& prs_res_set_item)

{

  asn1::nrppa::prs_res_set_item_s asn1_prs_res_set_item;

  asn1_prs_res_set_item.prs_res_set_id = prs_res_set_item.prs_res_set_id;

  asn1::number_to_enum(asn1_prs_res_set_item.subcarrier_spacing, scs_to_khz(prs_res_set_item.scs));

  asn1_prs_res_set_item.pr_sbw    = prs_res_set_item.prs_bw;

  asn1_prs_res_set_item.start_prb = prs_res_set_item.start_prb;

  asn1_prs_res_set_item.point_a   = prs_res_set_item.point_a;

  asn1::number_to_enum(asn1_prs_res_set_item.comb_size, prs_res_set_item.comb_size);

  if (prs_res_set_item.cp_type == cyclic_prefix::options::NORMAL) {

    asn1_prs_res_set_item.cp_type = asn1::nrppa::prs_res_set_item_s::cp_type_opts::options::normal;

  } else {

    asn1_prs_res_set_item.cp_type = asn1::nrppa::prs_res_set_item_s::cp_type_opts::options::extended;

  }

  asn1::number_to_enum(asn1_prs_res_set_item.res_set_periodicity, prs_res_set_item.res_set_periodicity);

  asn1_prs_res_set_item.res_set_slot_offset = prs_res_set_item.res_set_slot_offset;

  asn1::number_to_enum(asn1_prs_res_set_item.res_repeat_factor, prs_res_set_item.res_repeat_factor);

  asn1::number_to_enum(asn1_prs_res_set_item.res_time_gap, prs_res_set_item.res_time_gap);

  asn1::number_to_enum(asn1_prs_res_set_item.res_numof_symbols, prs_res_set_item.res_numof_symbols);

  if (prs_res_set_item.prs_muting.has_value()) {

    asn1_prs_res_set_item.prs_muting_present = true;

    asn1_prs_res_set_item.prs_muting         = prs_muting_to_asn1(prs_res_set_item.prs_muting.value());

  }

  asn1_prs_res_set_item.prs_res_tx_pwr = prs_res_set_item.prs_res_tx_pwr;

  for (const auto& prs_res_item : prs_res_set_item.prs_res_list) {

    asn1::nrppa::prs_res_item_s asn1_prs_res_item;

    asn1_prs_res_item.prs_res_id        = prs_res_item.prs_res_id;

    asn1_prs_res_item.seq_id            = prs_res_item.seq_id;

    asn1_prs_res_item.re_offset         = prs_res_item.re_offset;

    asn1_prs_res_item.res_slot_offset   = prs_res_item.res_slot_offset;

    asn1_prs_res_item.res_symbol_offset = prs_res_item.res_symbol_offset;

    if (prs_res_item.qcl_info.has_value()) {

      asn1_prs_res_item.qcl_info_present = true;

      if (std::holds_alternative<ssb_t>(prs_res_item.qcl_info.value())) {

        asn1::nrppa::prs_res_qcl_source_ssb_s& asn1_pres_res_qcl_source_ssb =

            asn1_prs_res_item.qcl_info.set_qcl_source_ssb();

        const ssb_t& prs_res_qcl_source_ssb = std::get<ssb_t>(prs_res_item.qcl_info.value());

        asn1_pres_res_qcl_source_ssb.pci_nr = prs_res_qcl_source_ssb.pci_nr;

        if (prs_res_qcl_source_ssb.ssb_idx.has_value()) {

          asn1_pres_res_qcl_source_ssb.ssb_idx_present = true;

          asn1_pres_res_qcl_source_ssb.ssb_idx         = prs_res_qcl_source_ssb.ssb_idx.value();

        }

      } else {

        asn1::nrppa::prs_res_qcl_source_prs_s& asn1_prs_res_qcl_source_prs =

            asn1_prs_res_item.qcl_info.set_qcl_source_prs();

        const prs_resource_qcl_source_prs_t& prs_res_qcl_source_prs =

            std::get<prs_resource_qcl_source_prs_t>(prs_res_item.qcl_info.value());

        asn1_prs_res_qcl_source_prs.qcl_source_prs_res_set_id = prs_res_qcl_source_prs.qcl_source_prs_res_set_id;

        if (prs_res_qcl_source_prs.qcl_source_prs_res_id.has_value()) {

          asn1_prs_res_qcl_source_prs.qcl_source_prs_res_id_present = true;

          asn1_prs_res_qcl_source_prs.qcl_source_prs_res_id = prs_res_qcl_source_prs.qcl_source_prs_res_id.value();

        }

      }

    }

    asn1_prs_res_set_item.prs_res_list.push_back(asn1_prs_res_item);

  }

  return asn1_prs_res_set_item;

}

inline asn1::nrppa::ssb_info_item_s ssb_info_item_to_asn1(const ssb_info_item_t& ssb_info_item)

{

  asn1::nrppa::ssb_info_item_s asn1_ssb_info_item;

  // Fill SSB config.

  asn1_ssb_info_item.ssb_cfg.ssb_freq = ssb_info_item.ssb_cfg.ssb_freq;

  asn1::number_to_enum(asn1_ssb_info_item.ssb_cfg.ssb_subcarrier_spacing,

                       scs_to_khz(ssb_info_item.ssb_cfg.ssb_subcarrier_spacing));

  asn1_ssb_info_item.ssb_cfg.ssb_tx_pwr = ssb_info_item.ssb_cfg.ssb_tx_pwr;

  asn1::number_to_enum(asn1_ssb_info_item.ssb_cfg.ssb_periodicity, to_underlying(ssb_info_item.ssb_cfg.ssb_period));

  asn1_ssb_info_item.ssb_cfg.ssb_half_frame_offset = ssb_info_item.ssb_cfg.ssb_half_frame_offset;

  asn1_ssb_info_item.ssb_cfg.ssb_sfn_offset        = ssb_info_item.ssb_cfg.ssb_sfn_offset;

  if (ssb_info_item.ssb_cfg.ssb_burst_position.has_value()) {

    asn1_ssb_info_item.ssb_cfg.ssb_burst_position_present = true;

    if (ssb_info_item.ssb_cfg.ssb_burst_position.value().type == ssb_burst_position_t::bitmap_type_t::short_bitmap) {

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.set_short_bitmap();

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.short_bitmap().from_number(

          static_cast<uint8_t>(ssb_info_item.ssb_cfg.ssb_burst_position.value().bitmap));

    }

    if (ssb_info_item.ssb_cfg.ssb_burst_position.value().type == ssb_burst_position_t::bitmap_type_t::medium_bitmap) {

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.set_medium_bitmap();

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.medium_bitmap().from_number(

          static_cast<uint8_t>(ssb_info_item.ssb_cfg.ssb_burst_position.value().bitmap));

    }

    if (ssb_info_item.ssb_cfg.ssb_burst_position.value().type == ssb_burst_position_t::bitmap_type_t::long_bitmap) {

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.set_long_bitmap();

      asn1_ssb_info_item.ssb_cfg.ssb_burst_position.long_bitmap().from_number(

          ssb_info_item.ssb_cfg.ssb_burst_position.value().bitmap);

    }

  }

  if (ssb_info_item.ssb_cfg.sfn_initialization_time.has_value()) {

    asn1_ssb_info_item.ssb_cfg.sfn_initisation_time_present = true;

    asn1_ssb_info_item.ssb_cfg.sfn_initisation_time.from_number(ssb_info_item.ssb_cfg.sfn_initialization_time.value());

  }

  // Fill PCI NR.

  asn1_ssb_info_item.pci_nr = ssb_info_item.pci_nr;

  return asn1_ssb_info_item;

}

inline asn1::nrppa::spatial_direction_info_s

spatial_direction_info_to_asn1(const spatial_direction_info_t& spatial_direction_info)

{

  asn1::nrppa::spatial_direction_info_s asn1_spatial_direction_info;

  // Fill NR PRS beam info list.

  for (const auto& nr_prs_beam_info_item : spatial_direction_info.nr_prs_beam_info.nr_prs_beam_info_list) {

    asn1::nrppa::nr_prs_beam_info_item_s asn1_nr_prs_beam_info_item;

    // Fill PR SRES set ID.

    asn1_nr_prs_beam_info_item.pr_sres_set_id = nr_prs_beam_info_item.pr_sres_set_id;

    // Fill PRS angle.

    for (const auto& prs_angle : nr_prs_beam_info_item.prs_angle) {

      asn1::nrppa::prs_angle_item_s asn1_prs_angle_item;

      asn1_prs_angle_item.nr_prs_azimuth = prs_angle.nr_prs_azimuth;

      if (prs_angle.nr_prs_azimuth_fine.has_value()) {

        asn1_prs_angle_item.nr_prs_azimuth_fine_present = true;

        asn1_prs_angle_item.nr_prs_azimuth_fine         = prs_angle.nr_prs_azimuth_fine.value();

      }

      if (prs_angle.nr_prs_elevation.has_value()) {

        asn1_prs_angle_item.nr_prs_elevation_present = true;

        asn1_prs_angle_item.nr_prs_elevation         = prs_angle.nr_prs_elevation.value();

      }

      if (prs_angle.nr_prs_elevation_fine.has_value()) {

        asn1_prs_angle_item.nr_prs_elevation_fine_present = true;

        asn1_prs_angle_item.nr_prs_elevation_fine         = prs_angle.nr_prs_elevation_fine.value();

      }

      asn1::protocol_ext_field_s<asn1::nrppa::prs_angle_item_ext_ies_o> asn1_ie_exts_item;

      asn1_ie_exts_item.value().prs_res_id() = prs_angle.prs_res_id;

      asn1_prs_angle_item.ie_exts.push_back(asn1_ie_exts_item);

      asn1_nr_prs_beam_info_item.prs_angle.push_back(asn1_prs_angle_item);

    }

    asn1_spatial_direction_info.nr_prs_beam_info.nr_prs_beam_info_list.push_back(asn1_nr_prs_beam_info_item);

  }

  // Fill LCS to GCS translation list.

  for (const auto& lcs_to_gcs_translation_item : spatial_direction_info.nr_prs_beam_info.lcs_to_gcs_translation_list) {

    asn1::nrppa::lcs_to_gcs_translation_item_s asn1_lcs_to_gcs_translation_item;

    asn1_lcs_to_gcs_translation_item.alpha = lcs_to_gcs_translation_item.alpha;

    if (lcs_to_gcs_translation_item.alpha_fine.has_value()) {

      asn1_lcs_to_gcs_translation_item.alpha_fine_present = true;

      asn1_lcs_to_gcs_translation_item.alpha_fine         = lcs_to_gcs_translation_item.alpha_fine.value();

    }

    asn1_lcs_to_gcs_translation_item.beta = lcs_to_gcs_translation_item.beta;

    if (lcs_to_gcs_translation_item.beta_fine.has_value()) {

      asn1_lcs_to_gcs_translation_item.beta_fine_present = true;

      asn1_lcs_to_gcs_translation_item.beta_fine         = lcs_to_gcs_translation_item.beta_fine.value();

    }

    asn1_lcs_to_gcs_translation_item.gamma = lcs_to_gcs_translation_item.gamma;

    if (lcs_to_gcs_translation_item.gamma_fine.has_value()) {

      asn1_lcs_to_gcs_translation_item.gamma_fine_present = true;

      asn1_lcs_to_gcs_translation_item.gamma_fine         = lcs_to_gcs_translation_item.gamma_fine.value();

    }

    asn1_spatial_direction_info.nr_prs_beam_info.lcs_to_gcs_translation_list.push_back(

        asn1_lcs_to_gcs_translation_item);

  }

  return asn1_spatial_direction_info;

}

inline asn1::nrppa::ngran_high_accuracy_access_point_position_s ng_ran_high_accuracy_access_point_position_to_asn1(

    const ng_ran_high_accuracy_access_point_position_t& access_point_position)

{

  asn1::nrppa::ngran_high_accuracy_access_point_position_s asn1_access_point_position;

  asn1_access_point_position.latitude                  = access_point_position.latitude;

  asn1_access_point_position.longitude                 = access_point_position.longitude;

  asn1_access_point_position.altitude                  = access_point_position.altitude;

  asn1_access_point_position.uncertainty_semi_major    = access_point_position.uncertainty_semi_major;

  asn1_access_point_position.uncertainty_semi_minor    = access_point_position.uncertainty_semi_minor;

  asn1_access_point_position.orientation_of_major_axis = access_point_position.orientation_of_major_axis;

  asn1_access_point_position.horizontal_confidence     = access_point_position.horizontal_confidence;

  asn1_access_point_position.uncertainty_altitude      = access_point_position.uncertainty_altitude;

  asn1_access_point_position.vertical_confidence       = access_point_position.vertical_confidence;

  return asn1_access_point_position;

}

inline asn1::nrppa::relative_geodetic_location_s

relative_geodetic_location_to_asn1(const relative_geodetic_location_t& location)

{

  asn1::nrppa::relative_geodetic_location_s asn1_location;

  if (location.milli_arc_second_units == milli_arc_second_units_t::zerodot03) {

    asn1_location.milli_arc_second_units =

        asn1::nrppa::relative_geodetic_location_s::milli_arc_second_units_opts::zerodot03;

  } else if (location.milli_arc_second_units == milli_arc_second_units_t::zerodot3) {

    asn1_location.milli_arc_second_units =

        asn1::nrppa::relative_geodetic_location_s::milli_arc_second_units_opts::zerodot3;

  } else {

    asn1_location.milli_arc_second_units =

        asn1::nrppa::relative_geodetic_location_s::milli_arc_second_units_opts::three;

  }

  if (location.height_units == height_units_t::mm) {

    asn1_location.height_units = asn1::nrppa::relative_geodetic_location_s::height_units_opts::mm;

  } else if (location.height_units == height_units_t::cm) {

    asn1_location.height_units = asn1::nrppa::relative_geodetic_location_s::height_units_opts::cm;

  } else {

    asn1_location.height_units = asn1::nrppa::relative_geodetic_location_s::height_units_opts::m;

  }

  asn1_location.delta_latitude  = location.delta_latitude;

  asn1_location.delta_longitude = location.delta_longitude;

  asn1_location.delta_height    = location.delta_height;

  asn1_location.location_uncertainty.horizontal_uncertainty = location.location_uncertainty.horizontal_uncertainty;

  asn1_location.location_uncertainty.horizontal_confidence  = location.location_uncertainty.horizontal_confidence;

  asn1_location.location_uncertainty.vertical_uncertainty   = location.location_uncertainty.vertical_uncertainty;

  asn1_location.location_uncertainty.vertical_confidence    = location.location_uncertainty.vertical_confidence;

  return asn1_location;

}

inline asn1::nrppa::relative_cartesian_location_s

relative_cartesian_location_to_asn1(const relative_cartesian_location_t& location)

{

  asn1::nrppa::relative_cartesian_location_s asn1_location;

  if (location.xyz_unit == xyz_unit_t::mm) {

    asn1_location.xy_zunit = asn1::nrppa::relative_cartesian_location_s::xy_zunit_opts::options::mm;

  } else if (location.xyz_unit == xyz_unit_t::cm) {

    asn1_location.xy_zunit = asn1::nrppa::relative_cartesian_location_s::xy_zunit_opts::cm;

  } else {

    asn1_location.xy_zunit = asn1::nrppa::relative_cartesian_location_s::xy_zunit_opts::dm;

  }

  asn1_location.xvalue = location.xvalue;

  asn1_location.yvalue = location.yvalue;

  asn1_location.zvalue = location.zvalue;

  asn1_location.location_uncertainty.horizontal_uncertainty = location.location_uncertainty.horizontal_uncertainty;

  asn1_location.location_uncertainty.horizontal_confidence  = location.location_uncertainty.horizontal_confidence;

  asn1_location.location_uncertainty.vertical_uncertainty   = location.location_uncertainty.vertical_uncertainty;

  asn1_location.location_uncertainty.vertical_confidence    = location.location_uncertainty.vertical_confidence;

  return asn1_location;

}

inline asn1::nrppa::geographical_coordinates_s

geographical_coordinates_to_asn1(const geographical_coordinates_t& geographical_coordinates)

{

  asn1::nrppa::geographical_coordinates_s asn1_geographical_coordinates;

  // Fill TRP position definition type.

  if (std::holds_alternative<trp_position_direct_t>(geographical_coordinates.trp_position_definition_type)) {

    asn1::nrppa::trp_position_direct_s& asn1_trp_position_direct =

        asn1_geographical_coordinates.trp_position_definition_type.set_direct();

    const trp_position_direct_t& trp_position_direct =

        std::get<trp_position_direct_t>(geographical_coordinates.trp_position_definition_type);

    // Fill accuracy.

    if (std::holds_alternative<ng_ran_access_point_position_t>(trp_position_direct.accuracy)) {

      asn1_trp_position_direct.accuracy.set_trp_position() =

          ng_ran_access_point_position_to_asn1(std::get<ng_ran_access_point_position_t>(trp_position_direct.accuracy));

    } else {

      asn1_trp_position_direct.accuracy.set_trph_aposition() = ng_ran_high_accuracy_access_point_position_to_asn1(

          std::get<ng_ran_high_accuracy_access_point_position_t>(trp_position_direct.accuracy));

    }

  }

  if (std::holds_alternative<trp_position_refd_t>(geographical_coordinates.trp_position_definition_type)) {

    asn1::nrppa::trp_position_refd_s& asn1_trp_position_refd =

        asn1_geographical_coordinates.trp_position_definition_type.set_refd();

    const trp_position_refd_t& trp_position_refd =

        std::get<trp_position_refd_t>(geographical_coordinates.trp_position_definition_type);

    // Fill ref point.

    if (std::holds_alternative<uint16_t>(trp_position_refd.ref_point)) {

      asn1_trp_position_refd.ref_point.set_relative_coordinate_id() = std::get<uint16_t>(trp_position_refd.ref_point);

    } else if (std::holds_alternative<ng_ran_access_point_position_t>(trp_position_refd.ref_point)) {

      asn1_trp_position_refd.ref_point.set_ref_point_coordinate() =

          ng_ran_access_point_position_to_asn1(std::get<ng_ran_access_point_position_t>(trp_position_refd.ref_point));

    } else {

      asn1_trp_position_refd.ref_point.set_ref_point_coordinate_ha() =

          ng_ran_high_accuracy_access_point_position_to_asn1(

              std::get<ng_ran_high_accuracy_access_point_position_t>(trp_position_refd.ref_point));

    }

    // Fill ref point type.

    if (std::holds_alternative<relative_geodetic_location_t>(trp_position_refd.ref_point_type)) {

      asn1_trp_position_refd.ref_point_type.set_trp_position_relative_geodetic() =

          relative_geodetic_location_to_asn1(std::get<relative_geodetic_location_t>(trp_position_refd.ref_point_type));

    } else {

      asn1_trp_position_refd.ref_point_type.set_trp_position_relative_cartesian() = relative_cartesian_location_to_asn1(

          std::get<relative_cartesian_location_t>(trp_position_refd.ref_point_type));

    }

  }

  return asn1_geographical_coordinates;

}

inline asn1::nrppa::trp_type_e trp_type_to_asn1(const trp_type_t& trp_type)

{

  asn1::nrppa::trp_type_e asn1_trp_type;

  if (trp_type == trp_type_t::prs_only_tp) {

    asn1_trp_type = asn1::nrppa::trp_type_opts::prs_only_tp;

  } else if (trp_type == trp_type_t::srs_only_rp) {

    asn1_trp_type = asn1::nrppa::trp_type_opts::srs_only_rp;

  } else if (trp_type == trp_type_t::tp) {

    asn1_trp_type = asn1::nrppa::trp_type_opts::tp;

  } else if (trp_type == trp_type_t::rp) {

    asn1_trp_type = asn1::nrppa::trp_type_opts::rp;

  } else {

    asn1_trp_type = asn1::nrppa::trp_type_opts::trp;

  }

  return asn1_trp_type;

}

inline asn1::nrppa::on_demand_prs_info_s on_demand_prs_info_to_asn1(const on_demand_prs_info_t& on_demand_prs_info)

{

  asn1::nrppa::on_demand_prs_info_s asn1_on_demand_prs_info;

  asn1_on_demand_prs_info.on_demand_prs_request_allowed.from_number(on_demand_prs_info.on_demand_prs_request_allowed);

  if (on_demand_prs_info.allowed_res_set_periodicity_values.has_value()) {

    asn1_on_demand_prs_info.allowed_res_set_periodicity_values_present = true;

    asn1_on_demand_prs_info.allowed_res_set_periodicity_values.from_number(

        on_demand_prs_info.allowed_res_set_periodicity_values.value());

  }

  if (on_demand_prs_info.allowed_prs_bw_values.has_value()) {

    asn1_on_demand_prs_info.allowed_prs_bw_values_present = true;

    asn1_on_demand_prs_info.allowed_prs_bw_values.from_number(on_demand_prs_info.allowed_prs_bw_values.value());

  }

  if (on_demand_prs_info.allowed_res_repeat_factor_values.has_value()) {

    asn1_on_demand_prs_info.allowed_res_repeat_factor_values_present = true;

    asn1_on_demand_prs_info.allowed_res_repeat_factor_values.from_number(

        on_demand_prs_info.allowed_res_repeat_factor_values.value());

  }

  if (on_demand_prs_info.allowed_res_nof_symbols_values.has_value()) {

    asn1_on_demand_prs_info.allowed_res_nof_symbols_values_present = true;

    asn1_on_demand_prs_info.allowed_res_nof_symbols_values.from_number(

        on_demand_prs_info.allowed_res_nof_symbols_values.value());

  }

  if (on_demand_prs_info.allowed_comb_size_values.has_value()) {

    asn1_on_demand_prs_info.allowed_comb_size_values_present = true;

    asn1_on_demand_prs_info.allowed_comb_size_values.from_number(on_demand_prs_info.allowed_comb_size_values.value());

  }

  return asn1_on_demand_prs_info;

}

inline asn1::nrppa::trp_tx_teg_assoc_l trp_tx_teg_assoc_list_to_asn1(const std::vector<trpteg_item_t>& trp_tx_teg_assoc)

{

  asn1::nrppa::trp_tx_teg_assoc_l asn1_trp_tx_teg_assoc;

  for (const auto& trpteg_item : trp_tx_teg_assoc) {

    asn1::nrppa::trpteg_item_s asn1_trpteg_item;