/*
** Copyright 2017-present Open Networking Foundation
**
** Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
**
** 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.
*/

#include <stdio.h>
#include <bal_api.h>

#undef _SYS_QUEUE_H_

/* Includes related to proto buf */
#include "asfvolt16_driver.h"
#include "bal_tmqueue_hdlr.h"


/********************************************************************\
 * Function    : bal_tm_queue_cfg_set                           *
 * Description : Configures the tm queue for OLT device             *
 ********************************************************************/

uint32_t bal_tm_queue_cfg_set(BalTmQueueCfg *tm_queue_cfg)
{
    bcmos_errno err = BCM_ERR_OK;
    bcmbal_tm_queue_cfg tm_queue_obj;   /**< declare main API struct */
    bcmbal_tm_queue_key key = { };      /**< declare key */

    if((tm_queue_cfg->key->has_id) && (tm_queue_cfg->key->has_sched_id) && (tm_queue_cfg->key->has_sched_dir))
    {
       key.id = tm_queue_cfg->key->id;
       key.sched_id = tm_queue_cfg->key->sched_id;
       key.sched_dir = tm_queue_cfg->key->sched_dir;
    }
    else
    {
       ASFVOLT_LOG(ASFVOLT_ERROR, "Failed to configure the tm queue cfg(OLT): Missing Key values "
                                  "Received key values Id(%d), Sched-Dir(%d), Sched-Id(%d)",
                                   tm_queue_cfg->key->sched_id, tm_queue_cfg->key->sched_dir, tm_queue_cfg->key->id);
       return BAL_ERRNO__BAL_ERR_NOENT;
    }

    ASFVOLT_LOG(ASFVOLT_DEBUG, "Configuration of OLT(tm Queue) starts");

    /* init the API struct */
    BCMBAL_CFG_INIT(&tm_queue_obj, tm_queue, key);

    if (NULL != tm_queue_cfg->data)
    {
	    /* decode API parameters from GRPC */
	    ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, priority,
			    tm_queue_cfg->data->has_priority,
			    tm_queue_cfg->data->priority);
	    ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, weight,
			    tm_queue_cfg->data->has_weight,
			    tm_queue_cfg->data->weight);
	    ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, creation_mode,
			    tm_queue_cfg->data->has_creation_mode,
			    tm_queue_cfg->data->creation_mode);
	    ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, ref_count,
			    tm_queue_cfg->data->has_ref_count,
			    tm_queue_cfg->data->ref_count);
    }
    /* rating/shaping */
    BalTmShaping *balShaping = (BalTmShaping *)tm_queue_cfg->data->rate;
    bcmbal_tm_shaping val = {};
    if ((NULL != balShaping) && (balShaping->has_presence_mask))
    {
       val.presence_mask = balShaping->presence_mask;
       if (balShaping->has_cir)
       {
          val.cir = balShaping->cir;
       }
       if (balShaping->has_pir)
       {
          val.pir = balShaping->pir;
       }
       if (balShaping->has_burst)
       {
          val.burst = balShaping->burst;
       }
       ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, rate, BCMOS_TRUE, val);
    }

    /* bac - Buffer addmission Control */
    BalTmBac *balBac = (BalTmBac *)tm_queue_cfg->data->bac;
    bcmbal_tm_bac valBac = {};
    if((NULL != balBac) && (balBac->has_type))
    {
       valBac.type = balBac->type;
       switch(valBac.type)
       {
           case BAL_TM_BAC__U_TAILDROP:
             if(balBac->taildrop->has_max_size)
             {
                valBac.u.taildrop.max_size = balBac->taildrop->max_size;
             }
             break;
           case BAL_TM_BAC__U_RED:
             if(balBac->red->red->has_min_threshold)
             {
                 valBac.u.red.red.min_threshold = balBac->red->red->min_threshold;
             }
             if(balBac->red->red->has_max_threshold)
             {
                 valBac.u.red.red.max_threshold = balBac->red->red->max_threshold;
             }
             if(balBac->red->red->has_max_probability)
             {
                 valBac.u.red.red.max_probability = balBac->red->red->max_probability;
             }
             break;
           case BAL_TM_BAC__U_WRED:
             if(balBac->wred->red->has_min_threshold)
             {
                 valBac.u.wred.red.min_threshold = balBac->wred->red->min_threshold;
             }
             if(balBac->wred->red->has_max_threshold)
             {
                 valBac.u.wred.red.max_threshold = balBac->wred->red->max_threshold;
             }
             if(balBac->wred->red->has_max_probability)
             {
                 valBac.u.wred.red.max_probability= balBac->wred->red->max_probability;
             }
             if(balBac->wred->green->has_min_threshold)
             {
                 valBac.u.wred.green.min_threshold = balBac->wred->green->min_threshold;
             }
             if(balBac->wred->green->has_max_threshold)
             {
                 valBac.u.wred.green.max_threshold = balBac->wred->green->max_threshold;
             }
             if(balBac->wred->green->has_max_probability)
             {
                 valBac.u.wred.green.max_probability= balBac->wred->green->max_probability;
             }
             if(balBac->wred->yellow->has_min_threshold)
             {
                 valBac.u.wred.yellow.min_threshold = balBac->wred->yellow->min_threshold;
             }
             if(balBac->wred->yellow->has_max_threshold)
             {
                 valBac.u.wred.yellow.max_threshold = balBac->wred->yellow->max_threshold;
             }
             if(balBac->wred->yellow->has_max_probability)
             {
                 valBac.u.wred.yellow.max_probability= balBac->wred->yellow->max_probability;
             }
             break;
           default:
             break;
       }
       ASFVOLT_CFG_PROP_SET(tm_queue_obj, tm_queue, bac, BCMOS_TRUE, valBac);
    }

    err = bcmbal_cfg_set(DEFAULT_ATERM_ID, &(tm_queue_obj.hdr));

    if(BCM_ERR_OK != err)
    {
        ASFVOLT_LOG(ASFVOLT_ERROR, "Failed to configure the tm Queue Cfg(OLT)");
        return err;
    }

    ASFVOLT_LOG(ASFVOLT_INFO, "Set tm Queue configuration sent to OLT. "
                              "Queue ID(%d) Sched ID(%d) Sched Dir(%d)",
                               key.id, key.sched_id, key.sched_dir );
    return err;
}


/********************************************************************\
 * Function    : bal_tm_queue_cfg_clear                         *
 * Description : clear the OLT device tm queue configuration        *
 ********************************************************************/

uint32_t bal_tm_queue_cfg_clear(BalTmQueueKey *tm_queue_key)
{
    bcmos_errno err = BCM_ERR_OK;
    bcmbal_tm_queue_cfg tm_queue_obj;   /**< declare main API struct */
    bcmbal_tm_queue_key key = { };      /**< declare key */

    if((tm_queue_key->has_id) && (tm_queue_key->has_sched_id) && (tm_queue_key->has_sched_dir))
    {
       key.id = tm_queue_key->id;
       key.sched_id = tm_queue_key->sched_id;
       key.sched_dir = tm_queue_key->sched_dir;
    }
    else
    {
       ASFVOLT_LOG(ASFVOLT_ERROR, "Failed to clear the tm queue cfg(OLT): Missing Key values "
                                  "Received key values Id(%d), Sched-Dir(%d), Sched-Id(%d) ",
                                   tm_queue_key->sched_id, tm_queue_key->sched_dir, tm_queue_key->id);
       return BAL_ERRNO__BAL_ERR_NOENT;
    }

    ASFVOLT_LOG(ASFVOLT_DEBUG, "Clearing of OLT(tm Queue) starts");

    /* init the API struct */
    BCMBAL_CFG_INIT(&tm_queue_obj, tm_queue, key);

    err = bcmbal_cfg_clear(DEFAULT_ATERM_ID, &tm_queue_obj.hdr);

    if(BCM_ERR_OK != err)
    {
        ASFVOLT_LOG(ASFVOLT_ERROR, "Failed to clear the tm Queue Cfg(OLT)");
        return err;
    }

    ASFVOLT_LOG(ASFVOLT_INFO, "Clear tm Queue sent to OLT. "
                              "Queue ID(%d) Sched ID(%d) Sched Dir(%d)",
                               key.id, key.sched_id, key.sched_dir );
    return err;
}


/********************************************************************\
 * Function    : bal_tm_queue_cfg_get                               *
 * Description : Get the OLT device tm queue configuration          *
 ********************************************************************/

uint32_t bal_tm_queue_cfg_get(BalTmQueueCfg *tm_queue_cfg)
{
    bcmos_errno err = BCM_ERR_OK;
    bcmbal_tm_queue_cfg tm_queue_obj;   /**< declare main API struct */
    bcmbal_tm_queue_key key = { };      /**< declare key */

    key.id = tm_queue_cfg->key->id;
    key.sched_id = tm_queue_cfg->key->sched_id;
    key.sched_dir = tm_queue_cfg->key->sched_dir;

    ASFVOLT_LOG(ASFVOLT_DEBUG, "Get tm queue cfg(for OLT) starts");

    /* init the API struct */
    BCMBAL_CFG_INIT(&tm_queue_obj, tm_queue, key);

    /* request all properties, include everything */
    BCMBAL_CFG_PROP_GET(&tm_queue_obj, tm_queue, all_properties);

    err = bcmbal_cfg_get(DEFAULT_ATERM_ID, &tm_queue_obj.hdr);

    if(BCM_ERR_OK != err)
    {
        ASFVOLT_LOG(ASFVOLT_ERROR, "Failed to get the tm Queue Cfg(OLT)");
        return err;
    }

    ASFVOLT_LOG(ASFVOLT_INFO, "Get tm Queue sent to OLT. "
                              "Queue ID(%d) Sched ID(%d) Sched Dir(%d)",
                               key.id, key.sched_id, key.sched_dir );

    memcpy(tm_queue_cfg->key, &key, sizeof(BalTmQueueKey));
    memcpy(tm_queue_cfg->data, &tm_queue_obj, sizeof(BalTmQueueCfgData));

    return err;
}


/********************************************************************\
 * Function    : bal_tm_queue_indication_cb                         *
 * Description : Call back function registered with BAL to handle   *
 *               event related to access terminal                   *
 ********************************************************************/
bcmos_errno bal_tm_queue_cfg_indication_cb(bcmbal_obj *obj)
{
    bcmos_errno result = BCM_ERR_OK;
    ASFVOLT_LOG(ASFVOLT_INFO, "Processing API \'%s\' IND callback (status is %s)",
		    bcmbal_objtype_str(obj->obj_type),
		    bcmos_strerror(obj->status));

    return result;
}