/simpletypesystem/trunk

/*
Copyright (c) 2013-2014 Gustav Hartvigsson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

#include "Error.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include "utils.h"
#include "LinkedList.h"
#include "DynamicArray.h"


/* **************************************************************************
 *********************** INTERNALS ******************************************
 **************************************************************************** */

typedef
struct SErrorItem {
  schar * message;
  SErrorDomain error_domain;
  sint error_type;
} SErrorItem;

struct SError {
  SLinkedList * error_list; /* SLinkedList<SErrorItem *> */
};


typedef
struct SErrorDomainItem {
  SErrorDomain domain;
  SErrorDomainToString to_string_func;
  schar * domain_name;
} SErrorDomainItem;

static
SDynamicArray *
_internal_s_error_domain_list = NULL; /* <SErrorDomainItem *> */

void
_internal_s_error_domain_item_free (SErrorDomainItem * self);

void
_internal_s_error_item_free (SErrorItem * self);

void
_internal_s_error_list_for_each_item (SDynamicArray * in_array,
                                        SErrorItem * item,
                                        SDynamicArray * out_array);

schar *
s_default_error_domain_to_string (sint error_id, schar * msg) {
  schar * ret_val = s_string_new_fmt ("Error %d (%s): %s",
                                      error_id,
                                      s_default_error_get_name (error_id),
                                      msg);
  return ret_val;
}

schar *
s_default_error_get_name (SDefaultErrorType k) {
  return SDefaultErrorTypeName[k];
}

/* **************************************************************************
 ************************** SError ******************************************
 **************************************************************************** */

SError *
s_error_new (void) {
  SError * self = s_malloc (sizeof (SError));
  self->error_list = s_linked_list_new (FREEFUNC (_internal_s_error_item_free));
  return self;
}

void
s_error_append (SError * self ,
                sint error, const char * message,
                SErrorDomain error_domain) {
  assert (self != NULL);
  if (error_domain < 0) {
    s_err_print ("Invalid ErrorDomain");

    print_backtrace ();

    return;
  }

  SErrorItem * item = s_malloc (sizeof (SErrorItem));

  item->message = s_string_new (message);
  item->error_type = error;
  item->error_domain = error_domain;

  s_linked_list_append (self->error_list, item);
}

sboolean
s_error_has_error (SError * self) {
  if (self != NULL) {
    if (s_linked_list_get_current (self->error_list)) {
      return TRUE;
    }
  }
  return FALSE;
}

SDynamicArray *
s_error_to_string_array (SError * self) {
  assert (self != NULL);

  size_t out_arr_len = s_linked_list_len (self->error_list);

  SDynamicArray * ret_val = s_dynamic_array_new (out_arr_len, NULL);

  s_linked_list_for_each (self->error_list,
                          FOREACHFUNC(_internal_s_error_list_for_each_item),
                          ret_val);

  return ret_val;
}

void
s_error_free (SError * self) {
  s_linked_list_free (self->error_list, TRUE);
  s_free (self);
}

void
s_error_teardown () {
  s_dbg_print ("Taring down error system....");
  if (_internal_s_error_domain_list) {
    s_dynamic_array_free (_internal_s_error_domain_list, TRUE);
  }
  s_dbg_print ("Done tearing down error system.");
}



/* **************************************************************************
 *********************** SErrorDomain ***************************************
 **************************************************************************** */

SErrorDomain
s_error_get_domain (const schar * name, SErrorDomainToString to_string_func) {
  SErrorDomainItem * item = NULL;

  if (strlen (name) == 0 || to_string_func == NULL) {
    s_err_print ("Domain name or to_string_func not set.\n");
    return -2;
  }

  if (!(_internal_s_error_domain_list)) {
    s_dbg_print ("Array does not exist, lets create it!");
    _internal_s_error_domain_list =
          s_dynamic_array_new (S_ERROR_DOMAIN_RANGE_MAX,
          FREEFUNC (_internal_s_error_domain_item_free));
    // The default key is always 0
    item = s_malloc (sizeof (SErrorDomainItem));
    item->domain = 0;
    item->to_string_func = s_default_error_domain_to_string;
    item->domain_name = s_string_new ("default");
    s_dynamic_array_set (_internal_s_error_domain_list, 0, item);
  }

  if (s_string_is_equal (name, "default")) {
    if (to_string_func != s_default_error_domain_to_string) {
      s_err_print ("Trying to override the default error domain to string "
                   "callback.\n"
                   "This is not allowed! \n");
      return -1;
    }
    return 0;
  }

  /* We hash the domain name and see it the domain exists. */
  SErrorDomain domain = s_hash (name) % S_ERROR_DOMAIN_RANGE_MAX;

  SErrorDomainItem * item_2 = (SErrorDomainItem *) s_dynamic_array_get
                              (_internal_s_error_domain_list, domain);
  if ((item_2) == NULL) {
    /*
     * The item dose not exist in the array, lets just add it.
     */
    item = s_malloc (sizeof (SErrorDomainItem));
    item->domain = domain;
    item->to_string_func = to_string_func;
    item->domain_name = s_string_new (name);

    s_dynamic_array_set (_internal_s_error_domain_list ,domain, item);

    return domain;
  } else {
    /* We got something. See it it is correct */
    if (s_string_is_equal(item_2->domain_name, name)) {
      if (item_2->to_string_func != to_string_func) {
        s_err_print ("Trying to overwrite the to string handler"
                     "for error domain %s, this is not allowd.",
                     name);
        return -1;
      }
      return domain;
    }
    /*
     * We must now check each item untill we reach a NULL.
     */
    for (sint i = domain;
           i <= s_dynamic_array_size (_internal_s_error_domain_list);
             i++) {
      item_2 = (SErrorDomainItem *) s_dynamic_array_get (_internal_s_error_domain_list, i);
      if ((item_2) == NULL) {
        break; // This jumps out of the loop and to the for-loop below.
      } else {
        if (s_string_is_equal (item_2->domain_name, name)) {
          if (item_2->to_string_func != to_string_func) {
            s_err_print ("Trying to override to string function for error "
                         "domain %s.\nThis is not allowed!\n", name);
            return -1;
          } else {
            return i;
          }
        }
      }
    }
  }

  /*
   * The error domain does not exist.
   */
  for (/* domain */;
       domain <= s_dynamic_array_size (_internal_s_error_domain_list) + 1;
       domain++) {
    if (!(s_dynamic_array_get(_internal_s_error_domain_list ,domain))) {
      item = s_malloc (sizeof (SErrorDomainItem));
      item->domain = domain;
      item->domain_name = s_string_new (name);
      item->to_string_func = to_string_func;
      return domain;
    }
  }

  s_err_print ("Reaching a place where it should not reach. This is a sign "
               "that the devil has been messing with time and space.\n");
  print_backtrace ();

  return -666;
}



/* **************************************************************************
 *********************** INTERNALS ******************************************
 **************************************************************************** */

void
_internal_s_error_domain_item_free (SErrorDomainItem * self) {
  s_dbg_print ("(SErrorDomainItem) Freeing: %d, %s",
               self->domain,
               self->domain_name);
  s_free (self->domain_name);
  s_free (self);
}

void
_internal_s_error_list_for_each_item (SDynamicArray * in_array,
                                      SErrorItem * item,
                                      SDynamicArray * out_array) {
  SErrorDomainItem * domain_item = s_dynamic_array_get (
                                          _internal_s_error_domain_list,
                                          item->error_domain);

  SErrorDomainToString to_string_func = domain_item->to_string_func;
  s_dynamic_array_append (out_array, to_string_func (item->error_type,
                                                     item->message));
}

void
_internal_s_error_item_free (SErrorItem * self) {
  s_dbg_print ("Running free on errori item!");
  s_free (self->message);
  s_free (self);
}