#include "nbrpc_call.h"

extern char* alloc_new_str(char *);
extern char *alloc_new_str_s(char *, size_t);


rpc_call_request*  rpc_call_req_new(char *method, char *params, int id)
{
  rpc_call_request *ret = NULL;

  if (!method)
  {
    return NULL;
  }

  if (!params)
  {
    return NULL;
  }

  ret = malloc(sizeof(rpc_call_request));
  if (!ret)
  {
    return NULL;
  }
  ret->id = id;
  ret->method = alloc_new_str(method);
  ret->params = alloc_new_str(params);
  ret->user = NULL;
  ret->mask = NULL;
  ret->server == NULL;
  return ret;
}


rpc_call_response* rpc_call_resp_new(char *result, char *error, int id)
{
  rpc_call_response *ret = NULL;

  ret = malloc(sizeof(rpc_call_response));
  if (!ret)
  {
    return NULL;
  }

  PRINT("resp->id %d\n", id);
  ret->id = id;
  ret->result = alloc_new_str(result);
  ret->error  = alloc_new_str(error);
  ret->user = NULL;
  ret->mask = NULL;
  ret->server = NULL;
  return ret;
}


int rpc_call_req_free(rpc_call_request   *req)
{
  if (req)
  {
    FREE(req->user);
    FREE(req->mask);
    FREE(req->server);
    FREE(req->method);
    FREE(req->params);
    FREE(req);
  }
}


int rpc_call_resp_free(rpc_call_response *resp)
{
  if (resp)
  {
    FREE(resp->result);
    FREE(resp->error);
    FREE(resp->user);
    FREE(resp->mask);
    FREE(resp->server);
    FREE(resp);
  }
}


int rpc_call_req_marsh(   rpc_call_request   *req,     netbyte_store **nb_req)
{
  netbyte_store *nb = NULL;
  nb_u32   nb_id;
  nb_u8arr nb_method, nb_params, nb_user, nb_mask, nb_server;

  nb = calloc(1,sizeof(netbyte_store));
  nb_init(nb);

  nb_u8arr_create(&nb_method, strlen(req->method), req->method);
  nb_add_u8arr(nb, &nb_method);

  nb_u8arr_create(&nb_params, strlen(req->params), req->params);
  nb_add_u8arr(nb, &nb_params);

  nb_u32_create(&nb_id, req->id);
  //PRINT("%d\n", req->id);
  //PRINT("%d\n", nb_id.val);
  nb_add_u32(nb, &nb_id);

  nb_u8arr_create(&nb_user, strlen(req->user), req->user);
  nb_add_u8arr(nb, &nb_user);

  nb_u8arr_create(&nb_mask, strlen(req->mask), req->mask);
  nb_add_u8arr(nb, &nb_params);

  nb_u8arr_create(&nb_server, strlen(req->server), req->server);
  nb_add_u8arr(nb, &nb_server);

  //nb_print(nb);
  //nb_print(nb);

  *nb_req = nb;
  return 0;
}


int rpc_call_resp_marsh(  rpc_call_response  *resp,    netbyte_store **nb_resp)
{
  int eret;
  netbyte_store *nb = NULL;
  nb_u32 nb_id;
  nb_u8arr nb_result, nb_error, nb_user, nb_mask, nb_server;

  nb = calloc(1,sizeof(netbyte_store));
  nb_init(nb);

  eret = nb_u8arr_create(&nb_result, strlen(resp->result), resp->result);
  eret |= nb_add_u8arr(nb, &nb_result);

  eret = nb_u8arr_create(&nb_error, strlen(resp->error), resp->error);
  eret |= nb_add_u8arr(nb, &nb_error);

  eret = nb_u32_create(&nb_id, resp->id);
  //PRINT("%d\n", resp->id);
  //PRINT("%d\n", nb_id.val);
  eret |= nb_add_u32(nb, &nb_id);

  eret = nb_u8arr_create(&nb_user, strlen(resp->user), resp->user);
  eret |= nb_add_u8arr(nb, &nb_user);

  eret = nb_u8arr_create(&nb_mask, strlen(resp->mask), resp->mask);
  eret |= nb_add_u8arr(nb, &nb_mask);

  eret = nb_u8arr_create(&nb_server, strlen(resp->server), resp->server);
  eret |= nb_add_u8arr(nb, &nb_server);

  if (!eret)
  {
    ENL();
  }

  //nb_print(nb);

  *nb_resp = nb;
  return 0;
}


int rpc_call_req_unmarsh( netbyte_store *nb_req,  rpc_call_request   **req)
{
  __nb_type *type=NULL;
  rpc_call_request *__req=NULL;

  if (!nb_req)
  {
    return -1;
  }

  if (!req)
  {
    return -1;
  }

  __req = calloc(1,sizeof(rpc_call_request));

  //method
  if (0 == nb_val(nb_req, 0, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __req->method = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //params
  if (0 == nb_val(nb_req, 1, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __req->params = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //id
  if (0 == nb_val(nb_req, 2, &type))
  if (type->type == NBT_U32)
  {
    //PNL();
    nb_u32 *u32 = (nb_u32 *)type->nb_val;
    __req->id = u32->val;
  } else
  {
    ENL();
  }

  //user
  if (0 == nb_val(nb_req, 3, &type))
  if (type->type == NBT_U8ARRAY)
  {
    //PNL();
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __req->user = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //mask
  if (0 == nb_val(nb_req, 4, &type))
  if (type->type == NBT_U8ARRAY)
  {
    //PNL();
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __req->mask = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //server
  if (0 == nb_val(nb_req, 5, &type))
  if (type->type == NBT_U8ARRAY)
  {
    //PNL();
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __req->server = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  *req = __req;

  return 0;
}


int rpc_call_resp_unmarsh(netbyte_store *nb_resp, rpc_call_response  **resp)
{
  __nb_type *type=NULL;
  rpc_call_response *__resp=NULL;

  if (!nb_resp)
  {
    return -1;
  }

  if (!resp)
  {
    return -1;
  }

  __resp = calloc(1,sizeof(rpc_call_response));

  //result
  if (0 == nb_val(nb_resp, 0, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __resp->result = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //error
  if (0 == nb_val(nb_resp, 1, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __resp->error = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //id
  if (0 == nb_val(nb_resp, 2, &type))
  if (type->type == NBT_U32)
  {
    PNL();
    nb_u32 *u32 = (nb_u32 *)type->nb_val;
    __resp->id = u32->val;
    //PRINT("%d\n",u32->val)
  } else
  {
    ENL();
  }

  //user
  if (0 == nb_val(nb_resp, 3, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __resp->user = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //mask
  if (0 == nb_val(nb_resp, 1, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __resp->mask = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  //server
  if (0 == nb_val(nb_resp, 1, &type))
  if (type->type == NBT_U8ARRAY)
  {
    nb_u8arr *u8arr = (nb_u8arr *)type->nb_val;
    __resp->server = alloc_new_str_s(u8arr->val, u8arr->len);
  } else
  {
    ENL();
  }

  *resp = __resp;

  return 0;
}