/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.1  (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.openairinterface.org/?page_id=698
 *
 * 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.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

/*! \file rrc_UE_ral.c
 * \brief rrc procedures for handling RAL messages
 * \author Lionel GAUTHIER
 * \date 2013
 * \version 1.0
 * \company Eurecom
 * \email: lionel.gauthier@eurecom.fr
 */
#define RRC_UE
#define RRC_UE_RAL_C
//-----------------------------------------------------------------------------
#include "rrc_UE_ral.h"
#include "assertions.h"
#include "collection/hashtable/obj_hashtable.h"
#include "RRC/LTE/defs.h"
#include "RRC/LTE/extern.h"


//-----------------------------------------------------------------------------
int rrc_ue_ral_delete_all_thresholds_type(unsigned int mod_idP, ral_link_param_type_t *param_type_pP)
//-----------------------------------------------------------------------------
{
  hashtable_rc_t           rc;
  rrc_ral_threshold_key_t *key;
  rrc_ral_threshold_key_t *keys = NULL;
  unsigned int             num_keys = 0;
  int                      return_code = 0;

  rc =  obj_hashtable_get_keys(UE_rrc_inst[mod_idP].ral_meas_thresholds, (void*)&keys, &num_keys);

  if (rc == HASH_TABLE_OK) {
    key = keys;

    while (num_keys > 0) {
      if (memcmp(&key->link_param_type, param_type_pP, sizeof(ral_link_param_type_t)) == 0) {
        rc = obj_hashtable_remove (UE_rrc_inst[mod_idP].ral_meas_thresholds, key, sizeof(rrc_ral_threshold_key_t));

        if (rc != HASH_TABLE_OK) {
          return_code = -1;
        }
      }

      key = &key[1];
      num_keys--;
    }
  } else {
    return_code = -1;
  }

  if (keys != NULL) {
    free(keys);
  }

  return return_code;
}


//-----------------------------------------------------------------------------
int rrc_ue_ral_delete_threshold(unsigned int mod_idP, ral_link_param_type_t *param_type_pP, ral_threshold_t *threshold_pP)
//-----------------------------------------------------------------------------
{
  hashtable_rc_t           rc;
  rrc_ral_threshold_key_t  ref_key;

  memcpy(&ref_key.link_param_type, param_type_pP, sizeof(ral_link_param_type_t));
  memcpy(&ref_key.threshold,       threshold_pP,  sizeof(ral_threshold_t));
  rc = obj_hashtable_remove (UE_rrc_inst[mod_idP].ral_meas_thresholds, (void*)&ref_key, sizeof(rrc_ral_threshold_key_t));

  if (rc == HASH_TABLE_OK) {
    return 0;
  } else {
    return -1;
  }
}


//-----------------------------------------------------------------------------
int rrc_ue_ral_handle_configure_threshold_request(unsigned int mod_idP, MessageDef *msg_pP)
//-----------------------------------------------------------------------------
{
  ral_transaction_id_t               transaction_id            = 0;
  rrc_ral_configure_threshold_req_t *configure_threshold_req_p = NULL;
  ral_link_cfg_param_t              *link_cfg_param_p          = NULL;
  ral_threshold_t                   *threshold_p               = NULL;
  MessageDef                        *message_p                 = NULL;
  unsigned int                       ix_param                  = 0;
  unsigned int                       ix_thresholds             = 0;

  DevAssert(msg_pP != NULL);

  LOG_I(RRC, "[UE %d] Received %s\n", mod_idP, ITTI_MSG_NAME (msg_pP));
  configure_threshold_req_p = &RRC_RAL_CONFIGURE_THRESHOLD_REQ(msg_pP);

  transaction_id = configure_threshold_req_p->transaction_id;

  for (ix_param = 0; ix_param < configure_threshold_req_p->num_link_cfg_params; ix_param++) {
    link_cfg_param_p = &configure_threshold_req_p->link_cfg_params[ix_param];

    switch (link_cfg_param_p->th_action) {
    case RAL_TH_ACTION_SET_NORMAL_THRESHOLD:
    case RAL_TH_ACTION_SET_ONE_SHOT_THRESHOLD:
      switch (link_cfg_param_p->link_param_type.choice) {

      case RAL_LINK_PARAM_TYPE_CHOICE_GEN:
        switch (link_cfg_param_p->link_param_type._union.link_param_gen) {
        case RAL_LINK_PARAM_GEN_DATA_RATE:
        case RAL_LINK_PARAM_GEN_SIGNAL_STRENGTH:
        case RAL_LINK_PARAM_GEN_SINR:
        case RAL_LINK_PARAM_GEN_THROUGHPUT:
        case RAL_LINK_PARAM_GEN_PACKET_ERROR_RATE:
          message_p = itti_alloc_new_message (TASK_RRC_UE, PHY_MEAS_THRESHOLD_REQ);
          PHY_MEAS_THRESHOLD_REQ(message_p).transaction_id  = transaction_id;
          memcpy (&PHY_MEAS_THRESHOLD_REQ(message_p).cfg_param, (void *) link_cfg_param_p, sizeof(ral_link_cfg_param_t));
          itti_send_msg_to_task (TASK_PHY_UE, ITTI_MSG_INSTANCE(msg_pP), message_p);
          break;

        default:
          LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ malformed, unknown link_param_gen %d\n", link_cfg_param_p->link_param_type._union.link_param_gen);
          return -1;
        }

        break;

      case RAL_LINK_PARAM_TYPE_CHOICE_QOS:
        switch (link_cfg_param_p->link_param_type._union.link_param_qos) {
        case RAL_LINK_PARAM_QOS_MAX_NUM_DIF_COS_SUPPORTED:
        case RAL_LINK_PARAM_QOS_MIN_PACKET_TRANSFER_DELAY_ALL_COS:
        case RAL_LINK_PARAM_QOS_AVG_PACKET_TRANSFER_DELAY_ALL_COS:
        case RAL_LINK_PARAM_QOS_MAX_PACKET_TRANSFER_DELAY_ALL_COS:
        case RAL_LINK_PARAM_QOS_STD_DEVIATION_PACKET_TRANSFER_DELAY:
        case RAL_LINK_PARAM_QOS_PACKET_LOSS_RATE_ALL_COS_FRAME_RATIO:
          message_p = itti_alloc_new_message (TASK_RRC_UE, PHY_MEAS_THRESHOLD_REQ);
          PHY_MEAS_THRESHOLD_REQ(message_p).transaction_id  = transaction_id;
          memcpy (&PHY_MEAS_THRESHOLD_REQ(message_p).cfg_param, (void *) link_cfg_param_p, sizeof(ral_link_cfg_param_t));
          itti_send_msg_to_task (TASK_MAC_UE, ITTI_MSG_INSTANCE(msg_pP), message_p);
          break;

        default:
          LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ malformed, unknown link_param_qos %d\n", link_cfg_param_p->link_param_type._union.link_param_qos);
          return -1;
        }

        break;

      case RAL_LINK_PARAM_TYPE_CHOICE_LTE:
        switch (link_cfg_param_p->link_param_type._union.link_param_lte) {
          // group by dest task id
        case RAL_LINK_PARAM_LTE_UE_RSRP:
        case RAL_LINK_PARAM_LTE_UE_RSRQ:
        case RAL_LINK_PARAM_LTE_UE_CQI:
          message_p = itti_alloc_new_message (TASK_RRC_UE, PHY_MEAS_THRESHOLD_REQ);
          PHY_MEAS_THRESHOLD_REQ(message_p).transaction_id  = transaction_id;
          memcpy (&PHY_MEAS_THRESHOLD_REQ(message_p).cfg_param, (void *) link_cfg_param_p, sizeof(ral_link_cfg_param_t));
          itti_send_msg_to_task (TASK_PHY_UE, ITTI_MSG_INSTANCE(msg_pP), message_p);
          break;

        case RAL_LINK_PARAM_LTE_AVAILABLE_BW:
        case RAL_LINK_PARAM_LTE_PACKET_LOSS_RATE:
        case RAL_LINK_PARAM_LTE_L2_BUFFER_STATUS:
        case RAL_LINK_PARAM_LTE_PACKET_DELAY:
          message_p = itti_alloc_new_message (TASK_RRC_UE, PHY_MEAS_THRESHOLD_REQ);
          PHY_MEAS_THRESHOLD_REQ(message_p).transaction_id  = transaction_id;
          memcpy (&PHY_MEAS_THRESHOLD_REQ(message_p).cfg_param, (void *) link_cfg_param_p, sizeof(ral_link_cfg_param_t));
          itti_send_msg_to_task (TASK_MAC_UE, ITTI_MSG_INSTANCE(msg_pP), message_p);
          break;

        case RAL_LINK_PARAM_LTE_MOBILE_NODE_CAPABILITIES:
        case RAL_LINK_PARAM_LTE_EMBMS_CAPABILITY:
        case RAL_LINK_PARAM_LTE_JUMBO_FEASIBILITY:
        case RAL_LINK_PARAM_LTE_JUMBO_SETUP_STATUS:
        case RAL_LINK_PARAM_LTE_NUM_ACTIVE_EMBMS_RECEIVERS_PER_FLOW:
#warning "TO DO MIH LTE LINK PARAMS IN RRC UE"
          break;

        default:
          LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ malformed, unknown link_param_lte %d\n", link_cfg_param_p->link_param_type._union.link_param_lte);
          return -1;
        }

        break;

      default:
        LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ malformed, unknown link_param_type choice %d\n", link_cfg_param_p->link_param_type.choice);
        return -1;
      }

      for (ix_thresholds=0; ix_thresholds < link_cfg_param_p->num_thresholds; ix_thresholds++) {
        threshold_p = &link_cfg_param_p->thresholds[ix_thresholds];
      }

      break;

    case RAL_TH_ACTION_CANCEL_THRESHOLD:

      // IEEE Std 802.21-2008, Table F4, Data type name=LINK_CFG_PARAM (page 228):
      // When “Cancel threshold” is selected and no thresholds are specified, then all
      // currently configured thresholds for the given LINK_PARAM_TYPE are cancelled.
      if (link_cfg_param_p->num_thresholds == 0) {
        rrc_ue_ral_delete_all_thresholds_type(mod_idP, &link_cfg_param_p->link_param_type);
      } else {
        //
        // When “Cancel threshold” is selected and thresholds are specified only those
        // configured thresholds for the given LINK_PARAM_TYPE and whose threshold value match what was
        // specified are cancelled.
        for (ix_thresholds=0; ix_thresholds < link_cfg_param_p->num_thresholds; ix_thresholds++) {
          threshold_p = &link_cfg_param_p->thresholds[ix_thresholds];
          rrc_ue_ral_delete_threshold(mod_idP, &link_cfg_param_p->link_param_type, threshold_p);
        }
      }

      LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ with RAL_TH_ACTION_CANCEL_THRESHOLD\n");
      break;

    default:
      LOG_E(RRC, "Message RRC_RAL_CONFIGURE_THRESHOLD_REQ malformed, unknown th_action %d\n", link_cfg_param_p->th_action);
      return -1;
    }
  }

  return 0;
}


