/*

 * Copyright (C) 2014 OpenSIPS Solutions

 *

 * This file is part of opensips, a free SIP server.

 *

 * opensips is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version

 *

 * opensips is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 *

 * History:

 * --------

 *  2014-12-10 initial version (liviu)

 */

#include "str.h"

#include "mem/mem.h"

#include "context.h"

#include <string.h>

/* Pointer to the current processing context */

context_p current_processing_ctx = NULL;

unsigned int context_sizes[CONTEXT_COUNT];

unsigned int type_sizes[CONTEXT_COUNT][CONTEXT_COUNT_TYPE];

unsigned int type_offsets[CONTEXT_COUNT][CONTEXT_COUNT_TYPE];

/* vector of destroy functions */

static context_destroy_f *context_destroy_array[CONTEXT_COUNT];

static void register_context_destroy(context_destroy_f f,

    enum osips_context ctx, enum osips_context_val t)

{

  static int count = 0; /* contains all counters */

  context_destroy_f *tmp;

  int pos = 0;

  int i;

  /*

   * group all functions based on their types:

   * first the int functions, then the str and pointers the last

   */

  switch (t) {

  case CONTEXT_PTR_TYPE:

    pos += type_sizes[ctx][CONTEXT_PTR_TYPE];

  case CONTEXT_STR_TYPE:

    pos += type_sizes[ctx][CONTEXT_STR_TYPE];

  case CONTEXT_INT_TYPE:

    pos += type_sizes[ctx][CONTEXT_INT_TYPE];

    break;

  default:

    LM_ERR("should not get here with ctx %d\n", t);

    return;

  }

  /* TODO: check whether this should be in pkg or shm? */

  tmp = pkg_realloc(context_destroy_array[ctx], (count + 1) * sizeof(context_destroy_f));

  if (!tmp) {

    LM_ERR("cannot add any more destroy functions\n");

    return;

  }

  context_destroy_array[ctx] = tmp;

  /* move everything to the right to make room for pos */

  for (i = count; i > pos; i--)

    context_destroy_array[ctx][i] = context_destroy_array[ctx][i - 1];

  context_destroy_array[ctx][pos] = f;

  count++;

}

/* Note: @ctx will *not* be freed! */

void context_destroy(enum osips_context ctxtype, context_p ctx)

{

  int f = 0;

  int n;

  int i;

  str *s;

  void *p;

  /* int ctx */

  for (n = 0; n < type_sizes[ctxtype][CONTEXT_INT_TYPE]; n++, f++)

    if (context_destroy_array[ctxtype][f]) {

      i = context_get_int(ctxtype, ctx, n);

      if (i)/* XXX: should we call for 0 values? */

        context_destroy_array[ctxtype][f](&i);

    }

  /* str ctx */

  for (n = 0; n < type_sizes[ctxtype][CONTEXT_STR_TYPE]; n++, f++)

    if (context_destroy_array[ctxtype][f]) {

      s = context_get_str(ctxtype, ctx, n);

      if (s)/* XXX: how do we determine if s is empty? */

        context_destroy_array[ctxtype][f](s);

    }

  /* ptr ctx */

  for (n = 0; n < type_sizes[ctxtype][CONTEXT_PTR_TYPE]; n++, f++) {

    if (context_destroy_array[ctxtype][f]) {

      p = context_get_ptr(ctxtype, ctx, n);

      if (p)

        context_destroy_array[ctxtype][f](p);

    }

  }

}

context_p context_alloc(enum osips_context type)

{

  context_p ctx;

  ctx = pkg_malloc(context_size(type));

  if (!ctx) {

    LM_ERR("no more pkg mem\n");

    return NULL;

  }

  return ctx;

}

int ensure_global_context(void)

{

  if (current_processing_ctx)

    return 0;

  current_processing_ctx = context_alloc(CONTEXT_GLOBAL);

  if (!current_processing_ctx) {

    LM_ERR("oom\n");

    return -1;

  }

  memset(current_processing_ctx, 0, context_size(CONTEXT_GLOBAL));

  return 0;

}

#define CTX_STACK_SIZE  8

static context_p ctx_stack[CTX_STACK_SIZE];

static unsigned int ctx_stack_idx = 0;

int push_new_global_context(void)

{

  if (ctx_stack_idx==CTX_STACK_SIZE) {

    LM_ERR("too many stacked contexts (%d)\n",ctx_stack_idx);

    return 0;

  }

  ctx_stack[ctx_stack_idx++] = current_processing_ctx;

  current_processing_ctx = context_alloc(CONTEXT_GLOBAL);

  if (!current_processing_ctx) {

    LM_ERR("oom\n");

    current_processing_ctx = ctx_stack[--ctx_stack_idx];

    return 0;

  }

  memset(current_processing_ctx, 0, context_size(CONTEXT_GLOBAL));

  return 1;

}

int pop_pushed_global_context(void)

{

  if (ctx_stack_idx==0) {

    LM_ERR("nothing to pop form the stack\n");

    return -1;

  }

  context_destroy(CONTEXT_GLOBAL, current_processing_ctx);

  context_free(current_processing_ctx);

  current_processing_ctx = ctx_stack[--ctx_stack_idx];

  return 0;

}

void clear_global_context(void)

{

  if (current_processing_ctx) {

    context_destroy(CONTEXT_GLOBAL, current_processing_ctx);

    context_free(current_processing_ctx);

    current_processing_ctx = NULL;

  }

}

int context_register_int(enum osips_context type, context_destroy_f f)

{

  context_sizes[type] += sizeof(int);

  type_offsets[type][CONTEXT_STR_TYPE] += sizeof(int);

  type_offsets[type][CONTEXT_PTR_TYPE] += sizeof(int);

  register_context_destroy(f, type, CONTEXT_INT_TYPE);

  return type_sizes[type][CONTEXT_INT_TYPE]++;

}

int context_register_str(enum osips_context type, context_destroy_f f)

{

  context_sizes[type] += sizeof(str);

  type_offsets[type][CONTEXT_PTR_TYPE] += sizeof(str);

  register_context_destroy(f, type, CONTEXT_STR_TYPE);

  return type_sizes[type][CONTEXT_STR_TYPE]++;

}

int context_register_ptr(enum osips_context type, context_destroy_f f)

{

  context_sizes[type] += sizeof(void *);

  register_context_destroy(f, type, CONTEXT_PTR_TYPE);

  return type_sizes[type][CONTEXT_PTR_TYPE]++;

}