#pragma once

#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>


#include "defs.h"
#include "DynamicArray.h"

/**
 * @file
 * @defgroup SMatrix SMatrix
 * @addtogroup SMatrix
 * @{
 * A SMatrix is a 2d, rectangular array.
 */

S_BEGIN_DECLS

/**
 * An SMatrix is an opaque data structure representing a simple rectangular
 * matrix.
 *
 * An SMatrix Stores pointers to data, and not the data itself.
 * So when using functions like s_matrix_realloc, it only copies the pointers
 * over from the old SMatrix to the new.
 */
typedef struct SMatrix SMatrix;

#define S_MATRIX(k) ((SMatrix *) (k))

/**
 * convenience structure to store type into and name of a tuple.
 * Example:
 @code{.c}
typedef enum {
  MY_TUPLE_ENUM_NAME,
  MY_TUPLE_ENUM_AGE,
  MY_TUPLE_ENUM_HEIGHT,
  MY_TUPLE_ENUM_END_OF_TUPLE
} MyRowInfoEnum;

const SMatrixRowInformation my_row_info[] = {
  {"Name", S_TYPE_STRING, NULL, NULL, NULL},
  {"Age", S_TYPE_UINT, NULL, NULL, NULL},
  {"Height", S_TYPE_UINT, NULL, NULL, NULL}
  {NULL, NULL, NULL, NULL, NULL}
};
 @endcode
 * The information can then be used like this:
 @code{.c}
for (int i = 0, i <= s_matrix_get_last_tuple_n (my_matrix), i++) {
  spointer tmp_tuple = s_matrix_get_tuple (my_matrix, i);
  for (int j = 0, j <= MY_TUPLE_ENUM_END_OF_TUPLE, j++) {
    s_print ("%s: %s", my_row_info[j], tmp_tuple[j]);
  }
  s_print ("\n");
  free (tmp_tuple);
}
 @endcode
 *
 */
typedef struct SMatrixRowInformation {
  schar *       name; /**< Name of the row. */
  FreeFunc      free_func; /**< Free function to be used with complex objects.*/
  FuncPointer   to_json; /**< Used to get some sort of JSON information out of
                              a complex object. (Can be NULL). */
  FuncPointer   from_json; /**< When constructing an object of this type from
                            * some JSON representation of the complex object.
                            * This functons should be used. (Can be NULL)*/
  SType         type; /**< Type of the row. */
} SMatrixRowInformation;

/**
 * Create a new SMatrix.
 *
 * @param width The width of the matrix. This can be seen as the number of
 *              columns each tuple has.
 * @param height The initial height of the matrix. The initial number of rows
 *               the matrix has.
 */
S_EXPORTED
SMatrix *
s_matrix_new (size_t width,
              size_t height,
              SMatrixRowInformation * row_information);

/**
 * Free a SMatrix.
 *
 * @param self The SMatrix to free.
 * @param free_data Should the data also be freed with the data structure?
 */
S_EXPORTED
void
s_matrix_free (SMatrix * self, sboolean free_data);

/**
 * Reallocate a SMatrix from one tuple width to an other.
 *
 * @warning The new tuple size must be larger then the last, or it will be
 * turnicated, but not freed.
 *
 * @note You need to free the old SMatrix yourself
 * <em>(but not the data stored)</em>, this is to avoid memory leaks.
 */
S_EXPORTED
SMatrix *
s_matrix_realloc (SMatrix * self,
                  size_t width,
                  SMatrixRowInformation * new_row_information);

/**
 * Get element y in tuple x.
 *
 * Equivalent to matrix[x][y] would be in static 2d arrays.
 */
S_EXPORTED
spointer
s_matrix_get (SMatrix * self,
              size_t x,
              size_t y);

/**
 * Returns the number representing the last tuple.
 * IE: it the last tuple has the x position of 10, this will return 10.
 *
 * @param self The SMatrix to get the x coordinate of the last tuple.
 *
 * @return The x coordinate of the last tuple.
 *
 * @note The value way be wrong.
 */
S_EXPORTED
size_t
s_matrix_get_last_tuple_n (SMatrix self);

/**
 * @brief Set data at a point [x,y] in the array.
 *
 * @param self The SMatrix to operate on.
 * @param x The x coordinates of where to put the data.
 *          (What tuple to put it in).
 * @param y The y coordinates to put the data in.
 *          (What position in the tuple to put it in).
 * @param data The data to be placed in the SMatrix.
 */
S_EXPORTED
void
s_matrix_set (SMatrix * self,
              size_t x,
              size_t y,
              spointer data);

/**
 * Gets tuple x in SMatrix self.
 * 
 * @param self the matrix to perform the operation on.
 * @param x the tuple to get.
 *
 * @return a pointer to an array congaing painters to the data in the tuple.
 *
 * @see s_matrix_get_tuple_as_dynamic_array()
 */
S_EXPORTED
spointer *
s_matrix_get_tuple (SMatrix * self,
                    size_t x);

/**
 * Append a tuple to a SMatrix.
 *
 * @param self The SMatrix to perform the operation on.
 * @param tuple The <em>allocated</em> data tuple to be copied into the SMatrix.
 *
 * @note This function will consume (free) allocated data for the tuple.
 *
 * @note The function assumes that the tuple has the same width as specified
 *       during construction or reallocation. Any dangling pointers will
 *       <em>not</em> be freed.
 */
S_EXPORTED
void
s_matrix_append (SMatrix * self,
                 spointer * tuple);

/**
 * Get tuple x as a SDynamicArray.
 *
 * @param self the SMatrix to perform the operation on.
 * @param x the tuple to get.
 *
 * @return An SDynamicArray containing pointers to the data in the tuple.
 *
 * @see s_matrix_get_tuple
 */
S_EXPORTED
SDynamicArray *
s_matrix_get_tuple_as_dynamic_array (SMatrix * self,
                                     size_t x);

/**
 * This iterates over each tuple. giving the tuple as the item in the
 * callback function.
 */
S_EXPORTED
void
s_matrix_for_each (SMatrix * self,
                  ForEachFunc callback,
                  spointer data);


/**
 * @TODO
 * @warning NOT IMPLIED
 *
 * Get the matrix as JSON.
 * @param self The SMatrix to get the JSON from.
 *
 * @return a null-terminated JSON string representing the matrix.
 *
 * @note This only works on primative types. complex types (IE: structs and
 * such) can not be gotten any information from.
 *
 *The outputted JSON will have the format:
 @code{.js}
{
  { // Tuple
    { // Item
      name: "Name"
      type: "STRING",
      data: "John Smith"
    },
    { // Item
      name: "Age",
      type: "UINT",
      data: 32,
    },
    { // Item
      name: "Height",
      type: "UINT",
      data: 189
    }
  },
  { //tuple
    // ...
  }
}
 @endcode
 */
S_EXPORTED
char *
s_matrix_serialize_json (SMatrix * self);

/**
 * @TODO
 * @warning NOT IMPLIED
 *
 * Deselialize JSON into an SMatrix.
 *
 * @param self The SMatrix to write to.
 * @param data the JSON data to be deselialised.
 *
 * @note The SMatrix must be empty, but initialised.
 *
 * @note As with s_matrix_serialize_json(), only primative types work. Complex
 * types will not work.
 */
S_EXPORTED
void
s_matrix_deserialize_json (SMatrix * self,
                           const schar * data);

/** @} */

S_END_DECLS