#ifndef CSLIST_H_INCLUDED
#define CSLIST_H_INCLUDED

#include <stdbool.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>

typedef
enum {
    LIST_CMP_EQUAL          = 0x0,
    LIST_CMP_LESS_THAT      = 1,
    LIST_CMP_GREATER_THAT   = -1
} list_cmp_t;

typedef enum {
    LIST_SORT_ASC,      /* Indica que se copiaran los elemento antes del elemento indicado. No usar en conjunto de LIST_COPY_RIGHT. */
    LIST_SORT_DESC      /* Indica que se copiaran los elementos despues del elementos indicado. No usar en conjunto de LIST_COPY_LEFT. */
} list_sort_t;

typedef void*               list_t;
typedef list_t*             list_ptr_t;
#define LIST_NULL           NULL

typedef intptr_t            list_value_t;
typedef list_value_t*       list_value_ptr_t;
#define LIST_VALUE_NULL     NULL

typedef list_value_ptr_t    list_item_t;
typedef list_item_t*        list_item_ptr_t;
#define LIST_ITEM_NULL      NULL

typedef size_t              list_size_t;
typedef list_size_t*        list_size_ptr_t;

/** Definición de callback que se encarga de crear un duplicado del list_value_t indicado en el parámetro value.
 * @param value: list_value_t que se duplicara.
 * @return Retorna el elemento list_value_t duplicado del parámetro value.
 */
typedef
list_value_t(*list_callback_clone_item)
(const list_value_t value);

/** Definición de callback que se encarga de destruir la memoria asignada al list_value_t.
 * @param value: list_value_t que se liberara.
 */
typedef
void(*list_callback_release_item)
(const list_value_t value);

/** Definición de callback que se encarga comparar dos list_value_t.
 * @param value1: list_value_t que se comparara con value2.
 * @param value2: list_value_t que se comparara con value1.
 * @return Retorna el resultado de la comparación.
 *    LIST_CMP_LESS_THAT: Si value1 < value2.
 *    LIST_CMP_EQUAL: Si value1 == value2.
 *    LIST_CMP_GREATER_THAT: Si value1 > value2.
 */
typedef
list_cmp_t(*list_callback_compare_item)
(const list_value_t value1,
const list_value_t value2);

/** Crea una nueva lista de elementos list_value_t.
 * @param clone_item: Apuntador a la función callback que retornara la copia del valor a asignar.
 * @param release_item: Apuntador a la función callback que liberara la copia del valor duplicado en el list_callback_clone_item.
 * @param clone_item: Apuntador a un proceso callback que se encarga de comparar los list_item_t.
 * @return Retorna la nueva cola de datos queue_t que debera ser destruida con list_release().
 */
list_t
list_allocator(list_callback_clone_item clone_item,
               list_callback_release_item release_item,
               list_callback_compare_item compare_item);

/** Función que destruye una lista.
 */
void
list_release(list_t list);

/** Función que remueve TODOS los elementos de la lista.
 * @return Retorna la cantidad de elementos removidos de la lista.
 */
list_size_t
list_clear(list_t list);

/** Función que agrega n cantidad de elementos repetidos (value) a la lista, reemplazando los existentes.
 * @param list: Lista en la que se agregara value n veces.
 * @param n: Cantidad de valores a agregar a la lista.
 * @param value: Valor a agregar n veces a la lista.
 * @return Retorna el primer elemento agregado; NULL si no se a agregado ningun elemento.
 */
list_item_t
list_assign(list_t list,
            list_size_t n,
            list_value_t value);

/** Función que agrega un elemento al final de la lista.
 * @param list: lista a la cual se le agregara un elemento nuevo.
 * @param value: Valor a agregar a la lista.
 * @return Retorna el item en la lista.
 */
list_item_t
list_pushback(list_t list,
              list_value_t value);

/** Función que agrega un elemento al inicio de la lista.
 * @param list: Lista a la cual se le agregara un elemento nuevo.
 * @param value: Valor a agregar a la lista.
 * @return Retorna el item en la lista.
 */
list_item_t
list_pushfront(list_t list,
               list_value_t value);

/** Función que agrega un elemento en la lista antes de un elemento indicado.
 * @param item: Elemento pivote que esta dentro de una lista.
 * @param value: Valor a agregar a la lista antes del pivote.
 * @return Retorna el item en la lista.
 */
list_item_t
list_pushprev(list_item_t item,
              list_value_t value);

/** Función que agrega un elemento aen la lista despues de un elemento indicado como pivote.
 * @param item: Elemento pivote que esta dentro de una lista.
 * @param value: Valor a agregar a la lista despues del pivote.
 * @return Retorna el item en la lista.
 */
list_item_t
list_pushnext(list_item_t item,
              list_value_t value);


/** Función que obtiene la lista a la cual pertenece un item.
 * @param list: Lista de la cual se obtendra su primer elemento list_item_t.
 * @return Devuelve la lista list_t a la cual pertenece dicho item; NULL si no pertenece a ninguna lista.
 */
list_t
list_getlist(list_item_t item);

/** Función que obtiene el primer elemento de una lista.
 * @param list: Lista de la cual se obtendra su primer elemento list_item_t.
 * @return Devuelve el primer list_item_t de la lista.
 */
list_item_t
list_begin(list_t list);

/** Función que obtiene el ultimo elemento de una lista.
 * @param list: Lista de la cual se obtendra el ultimo elemento list_item_t.
 * @return Devuelve el ultimo list_item_t de la lista.
 */
list_item_t
list_back(list_t list);

/** Función que verifica si una lista esta vacia.
 * @param list: Lista que se verificara.
 * @return Retorna:
 *  True: si la lista esta vacia.
 *  False: Si contiene por lo menos un elemento.
 */
bool
list_empty(list_t list);

/** Función que retorna el item anterior al inicado.
 * @param item: Item pivote en la lista.
 * @return Retorna el list_item_t anterior al indicado; NULL si no hay ningun item.
 */
list_item_t
list_before(list_item_t item);

/** Función que retorna el item siguiente al inicado.
 * @param item: Item pivote en la lista.
 * @return Retorna el list_item_t siguiente al indicado; NULL si no hay ningun item.
 */
list_item_t
list_after(list_item_t item);

/** Función que busca un valor a partir de un pivote indicado dentro de una lista.
 * @param item: Elemento pivote desde el cual se empresara a buscar el valor indicado en value.
 * @param value: Valor a buscar en la lista apartir de el pivote indicado.
 * @return Retorna NULL si no se a encontrado dentro de la lista en caso
 * contrario retorna el elemento .
*/
list_item_t
list_findnext(list_item_t item,
              list_value_t value);

/** Función que busca un valor a partir de un pivote indicado dentro de una lista.
 * @param item: Elemento pivote desde el cual se empresara a buscar el valor indicado en value.
 * @param value: Valor a buscar en la lista antes de el pivote indicado.
 * @return Retorna NULL si no se a encontrado dentro de la lista en caso
 * contrario retorna el elemento .
*/
list_item_t
list_findprev(list_item_t item,
              list_value_t value);

/** Función que intercambia los valores entre dos elementos cuales quiera, inclusive entre listas.
 * @param item1: Elemento involucrado en el intercambio.
 * @param item2: Elemento involucrado en el intercambio.
 * @return Retorna TRUE si no hubo errores y FALSE si no se puedo intercambiar los dos elementos.
 */
bool
list_swap(list_item_t item1,
          list_item_t item2);

/** Función que elimina un list_item_t de su lista.
 * @param item: Elemento que se extraera de su lista.
 */
void
list_erase(list_item_t item);

/** Función que mezcla dos listas generando una nueva lista que debera ser liberada con list_release().
 * @param list1: Los elementos de esta lista se agregaran al inicio.
 * @param list2: Los elementos de esta lista se agregaran al seguidos de los de list1.
 * @return Retorna una nueva lista que contendran las copias de las dos listas espesificadas.
 */
list_t
list_join(list_t list1,
          list_t list2);

/** Función que retorna la cantidad de elementos en la lista.
 * @param list: Lista de la cual se retornaran la cantidad de elementos almacenados en ella.
 *
 * @return Retorna la cantidad de elementos en la lista.
 */
list_size_t
list_size(list_t list);

/** Función que copia los elementos de una lista a otra.
 * @param dst: Elemento pivote en donde se se hubicaran los elementos a copiar desde src.
 * @param src: Elemento pivote de una lista que se le clonaran sus elementos para agregarlos en la lista destino dst.
 * @param n: Cantidad máxima de elementos que copiaran.
 *
 * @return Retorna la cantidad de elementos agregados en la listda dst.
 */
list_size_t
list_copy(list_item_t dst,
          list_item_t src,
          list_size_t n);

/** Función que clona por completo una lista.
 * @param list: Lista que será clonada.
 *
 * @return Retorna una nueva lista que debera ser liberada con list_release().
 */
list_t
list_clone(list_t list);

/** Función que ordena los elementos de una lista.
 * @param list: lista que se ordenara.
 * @param sort: Indica el modo en el que serán ordenados los elementos
 * LIST_SORT_ASC/LIST_SORT_DESC:
 */
void
list_sort(list_t list,
          list_sort_t sort);

#endif // CSLIST_H_INCLUDED