// This file is under GNU General Public License 3.0

 // see LICENSE.txt

 #include "pEp_internal.h"

 #include <stdlib.h>

 #include <assert.h>

 #include <string.h>

 #include "stringpair.h"

 DYNAMIC_API stringpair_t * new_stringpair(const char *key, const char *value)

 {

     stringpair_t *pair = NULL;

     // key and value should not be NULL, that's bad style (while legal)

     assert(key);

     assert(value);

     pair = calloc(1, sizeof(stringpair_t));

     assert(pair);

     if (pair == NULL)

         goto enomem;

     pair->key = key ? strdup(key) : strdup("");

     assert(pair->key);

     if (pair->key == NULL)

         goto enomem;

     pair->value = value ? strdup(value) : strdup("");

     assert(pair->value);

     if (pair->value == NULL)

         goto enomem;

     return pair;

 enomem:

     free_stringpair(pair);

     return NULL;

 }

 DYNAMIC_API void free_stringpair(stringpair_t * pair)

 {

     if (pair) {

         free(pair->key);

         free(pair->value);

         free(pair);

     }

 }

 DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src)

 {

     assert(src);

     if (src == NULL)

         return NULL;

     return new_stringpair(src->key, src->value);

 }

 DYNAMIC_API stringpair_list_t *new_stringpair_list(stringpair_t *value)

 {

     stringpair_list_t *result = calloc(1, sizeof(stringpair_list_t));

     assert(result);

     if (result && value)

         result->value = value;

     return result;

 }

 DYNAMIC_API stringpair_list_t *stringpair_list_dup(

         const stringpair_list_t *src

     )

 {

     assert(src);

     if (src == NULL)

         return NULL;

     stringpair_t* copy_pair = stringpair_dup(src->value);

     stringpair_list_t *dst = new_stringpair_list(copy_pair);

     if (dst == NULL)

         return NULL;

     stringpair_list_t* src_curr = src->next;

     stringpair_list_t** dst_curr_ptr = &dst->next;

     while (src_curr) {

         copy_pair = stringpair_dup(src_curr->value);

         if (copy_pair == NULL) {

             free_stringpair_list(dst);

             return NULL;

         }

         *dst_curr_ptr = new_stringpair_list(copy_pair);

         if (*dst_curr_ptr == NULL) {

             free_stringpair(copy_pair);

             free_stringpair_list(dst);

             return NULL;

         }

         src_curr = src_curr->next;

         dst_curr_ptr = &((*dst_curr_ptr)->next);

     }

     return dst;

 }

 DYNAMIC_API stringpair_list_t *stringpair_list_add(

         stringpair_list_t *stringpair_list,

         stringpair_t *value

     )

 {

     assert(value);

     // empty list (no nodes)

     if (stringpair_list == NULL)

         return new_stringpair_list(value);

     // empty list (one node, no value)

     if (stringpair_list->value == NULL) {

         if (stringpair_list->next)

             return NULL; // invalid list

         stringpair_list->value = value;

         assert(stringpair_list->value);

         if (stringpair_list->value == NULL)

             return NULL;

         return stringpair_list;

     }

     stringpair_list_t* list_curr = stringpair_list;

     while (list_curr->next)

         list_curr = list_curr->next;

     list_curr->next = new_stringpair_list(value);

     assert(list_curr->next);

     if (list_curr->next == NULL)

         return NULL;

     return list_curr->next;

 }

 DYNAMIC_API stringpair_list_t *stringpair_list_append(

         stringpair_list_t *stringpair_list,

         stringpair_list_t *second

     )

 {

     assert(stringpair_list);

     if (stringpair_list == NULL)

         return NULL;

     // second list is empty

     if (second == NULL || second->value == NULL)

         return stringpair_list;

     stringpair_list_t *_s = stringpair_list;

     for (stringpair_list_t *_s2 = second; _s2 != NULL; _s2 = _s2->next) {

         stringpair_t *_sp = stringpair_dup(_s2->value);

         if (_sp == NULL)

             return NULL;

         _s = stringpair_list_add(_s, _sp);

         if (_s == NULL){

             free_stringpair(_sp);

             return NULL;

         }

     }

     return _s;

 }

 DYNAMIC_API int stringpair_list_length(

         const stringpair_list_t *stringpair_list

     )

 {

     int len = 0;

     for (const stringpair_list_t *_sl = stringpair_list; _sl && _sl->value; _sl = _sl->next)

         len++;

     return len;

 }

 DYNAMIC_API void free_stringpair_list(stringpair_list_t *stringpair_list)

 {

     if (stringpair_list) {

         free_stringpair_list(stringpair_list->next);

         free_stringpair(stringpair_list->value);

         free(stringpair_list);

     }

 }

 // ONLY DELETES ONE.

 DYNAMIC_API stringpair_list_t *stringpair_list_delete_by_key(

         stringpair_list_t *sp_list,

         const char *key

     )

 {

     assert(sp_list);

     assert(key);

     if (sp_list->value == NULL) {

         free_stringpair_list(sp_list);

         return NULL;

     }

     if (key == NULL)

         return sp_list;

     stringpair_list_t *_sl;

     stringpair_list_t *last = NULL;

     for (_sl = sp_list; _sl && _sl->value && _sl->value->key; _sl = _sl->next) {

         if (strcmp(_sl->value->key, key) == 0) {

             if (last == NULL)

                 sp_list = sp_list->next;

             else

                 last->next = _sl->next;

             _sl->next = NULL;

             free_stringpair_list(_sl);

             break;

         }

         last = _sl;

     }

     return sp_list;

 }

 DYNAMIC_API stringpair_list_t *stringpair_list_find(

         stringpair_list_t *stringpair_list,

         const char *key

     )

 {

     assert(key);

     for (stringpair_list_t *_l = stringpair_list; _l; _l = _l->next) {

         if (strcoll(key, _l->value->key) == 0)

             return _l;

     }

     return NULL;

 }