#include <vlib/vlib.h>
#include <vnet/vnet.h>
#include <vlibmemory/unix_shared_memory_queue.h>
#include <vlibapi/api.h>
#include <vat/vat.h>
#include <snat/snat.api.h>

/* define message IDs */
#include <snat/snat_msg_enum.h>

/* define message structures */
#define vl_typedefs
#include <snat/snat_all_api_h.h> 
#undef vl_typedefs

/* define generated endian-swappers */
#define vl_endianfun
#include <snat/snat_all_api_h.h> 
#undef vl_endianfun

#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)

#define REPLY_MSG_ID_BASE sm->msg_id_base
#include <vlibapi/api_helper_macros.h>

/* Get the API version number */
#define vl_api_version(n,v) static u32 api_version=(v);
#include <snat/snat_all_api_h.h>
#undef vl_api_version
vlib_main_t vlib_global_main;
vlib_main_t **vlib_mains;
#define API_NAME_LEN 256

#define M(T, mp)                                                \
do {                                                            \
    vtm->api_result_ready = 0;                                      \
    mp = vl_msg_api_alloc_as_if_client(sizeof(*mp));            \
    memset (mp, 0, sizeof (*mp));                               \
    mp->_vl_msg_id = ntohs (VL_API_##T+__plugin_msg_base);      \
    mp->client_index = vtm->my_client_index;                    \
} while(0);



/* S: send a message */
#define S(mp) (vl_msg_api_send_shmem (vam->vl_input_queue, (u8 *)&mp))

/* W: wait for results, with timeout */
#define W(ret)					\
do {                                            \
    f64 timeout = vat_time_now (vam) + 1.0;     \
    ret = -99;                                  \
                                                \
    while (vat_time_now (vam) < timeout) {      \
        if (vam->result_ready == 1) {           \
            ret = vam->retval;                  \
            break;                              \
        }                                       \
        vat_suspend (vam->vlib_main, 1e-5);     \
    }                                           \
} while(0);
struct snat_data {
	u16 base_msg_id;
};

struct snat_data snat_data;

typedef struct {
   vat_main_t *vat_main;
  /* vpe input queue */
  unix_shared_memory_queue_t *vl_input_queue;
    /* our client index */
  u32 my_client_index;
  /* Time is of the essence... */
  clib_time_t clib_time;
  u32 api_client_index;
  int api_connected;
  unix_shared_memory_queue_t *api_vl_input_queue;
  char api_connection_name[API_NAME_LEN]; 

  volatile int api_result_ready;
  volatile int api_result_msg_id;
  volatile int api_result_retval;
} snat_test_main_t;
snat_test_main_t snat_test_main;
#define foreach_standard_reply_retval_handler   \
_(snat_pwh_update_reply)                 \
_(snat_pwh_clean_reply)         \
_(snat_globle_config_reply)                \
_(want_snat_decrypt_event_reply)                       \
_(want_snat_timesync_event_reply)        

#define _(n)                                            \
    static void vl_api_##n##_t_handler                  \
    (vl_api_##n##_t * mp)                               \
    {                                                   \
        vat_main_t * vam = snat_test_main.vat_main;   \
        i32 retval = ntohl(mp->retval);                 \
        if (vam->async_mode) {                          \
            vam->async_errors += (retval < 0);          \
        } else {                                        \
            vam->retval = retval;                       \
            vam->result_ready = 1;                      \
        }                                               \
    }
foreach_standard_reply_retval_handler;
#undef _
#define foreach_snat_api_reply_msg                               \
	_(snat_PWH_UPDATE_REPLY, snat_pwh_update_reply)		\
	_(snat_PWH_CLEAN_REPLY, snat_pwh_clean_reply)       \
	_(snat_GLOBLE_CONFIG_REPLY, snat_globle_config_reply)   \
	_(WANT_snat_DECRYPT_EVENT_REPLY, want_snat_decrypt_event_reply)
#define foreach_snat_api_msg                                      \
	_(snat_PWH_UPDATE, snat_pwh_update)		\
	_(snat_PWH_CLEAN, snat_pwh_clean)       \
	_(snat_GLOBLE_CONFIG, snat_globle_config)   \
	_(WANT_snat_DECRYPT_EVENT, want_snat_decrypt_event)

int vpp_snat_init (void)
{
	u8 *plugin_name;
	u16 base_msg_id;
	fprintf(stderr, "%s: Starting\n", _func_);

	plugin_name = format(0, "snat_%08x%c", api_version, 0);
	base_msg_id = vl_client_get_first_plugin_msg_id((char *)plugin_name);
	if(base_msg_id == (u16)~0){
		vec_free(plugin_name);
		return -1;
	}
	snat_data.base_msg_id = base_msg_id;
	fprintf(stderr, "%s: Base massege_id is %d\n", _func_, base_msg_id);


#define _(N,n)                                                  \
    vl_msg_api_set_handlers(vmid_map_fn(VL_API_##N),     \
                           #n,                                  \
                           vl_api_##n##_t_handler,              \
                           vl_noop_handler,                     \
                           vl_api_##n##_t_endian,               \
                           vl_api_##n##_t_print,                \
                           sizeof(vl_api_##n##_t), 1); 
    foreach_snat_api_reply_msg;
#undef _
	return 0;
}

/*static void handle_snat_decrypt_event(vl_api_snat_decrypt_event_t *reply)
{
	vpe_api_main_t *vam = &vpe_api_main;
  	vnet_main_t *vnm = vam->vnet_main;
  	vlib_main_t *vm = vam->vlib_main;
  	vl_api_snat_decrypt_event_t *event;
  	vl_api_snat_decrypt_event_t *mp;
  	unix_shared_memory_queue_t *q;

  	
}
*/
/*int want_snat_decrypt_event_registeration()
{
	vl_api_want_snat_decrypt_event_t *mp;
	int ret;
	M(WANT_snat_DECRYPT_EVENT, mp);
	S(mp);
	W(ret);
	return ret;
}*/

static int vpp_connect_to_vlib(char *name, snat_test_main_t *vtm)
{
        api_main_t *am;
	
        if (vl_client_connect_to_vlib("/vpe-api",
                                      api_connection_name,
                                      API_RX_Q_SIZE) < 0) {
                svm_region_exit();
                return -1;
        }

        am = &api_main;
        vtm->api_vl_input_queue = am->shmem_hdr->vl_input_queue;
        vtm->api_client_index = am->my_client_index;
        vtm->api_connected = 1;

        return 0;
}

void
snat_pwh_upedate (snat_test_main_t *vtm, u32 serverip, u8 *username, u32 ulen, u8 *pwh)
{

  vl_api_snat_pwh_update_t *mp;
  int rv = 0;

  mp = vl_msg_api_alloc (sizeof (*mp));
  memset (mp, 0, sizeof (*mp));
  mp->_vl_msg_id = ntohs (VL_API_snat_PWH_UPDATE);
  mp->client_index = vtm->my_client_index;
  mp->context = 0xdeadbeef;
  mp->serverip = serverip;
  mp->ulen = ulen;
  memcpy(mp->username, username, ulen);
  memcpy(mp->pwh, pwh, sizeof(mp->pwh));
  vl_msg_api_send_shmem (vtm->vl_input_queue, (u8 *) & mp);
}
int main(int argc, char **argv)
{
	snat_test_main_t *vtm = &snat_test_main;
	vl_api_want_snat_decrypt_event_t *mp;
	vl_api_snat_decrypt_event_t *reply;

	vpp_snat_init ();
  	setup_signal_handlers ();

	if (vpp_connect_to_vlib ("snat_api_test", vtm) < 0)
    	{
     		 svm_region_exit ();
     		 fformat (stderr, "Couldn't connect to vlib, exiting...\n");
     		 exit (1);
   	 }
	M(WANT_snat_DECRYPT_EVENT, mp);
	S(mp);
	while (vtm->api_result_msg_id == VL_API_SNAT_DECRYPT_EVENT)
    	{
     		print("it is ok!!!!");
   	 }
	vl_client_disconnect_from_vlib();
}

