#include <string.h>

#include "logger.h"
#include "method.h"


Method* createMethod()
{
    Method* entity = (Method * ) malloc(sizeof(Method));

    logMessage(DEBUG,"method allocation",integerToString((int)entity,10));

    //error
    if(!entity)
    {
        logMessage(SEVERE,"malloc failed","Erreur lors de la création de la méthode");
        //perror("Erreur lors de la création de la méthode");
        return NULL;
    }

    // initialize
    // - dummy id
    entity->_db_id = 0;
    // - no name
    memset(entity->_name,'\0',MAX_INPUT * sizeof(char));
    // - no resolve function
    entity->_method_function = NULL;

    // - default epsilon
    entity->_epsilon_in  = DEFAULT_EPSILON;
    entity->_epsilon_out = DEFAULT_EPSILON;
    // - default max iteration
    entity->_max_iteration = DEFAULT_MAX_ITERATION;

    // clear statistics value
    clearResult(entity);
    
    return entity;
}

Method* createMethodWithParameters(
    char*         methodName,
    unsigned long methodId,
    void       (* method_function)
                (
                    Problema*       pb,
                    Method*         method,
                    double          init_vector[],
                    void*           args[]
                )
)
{
    Method * m = createMethod();

    strcpy(m->_name,methodName);

    m->_db_id = methodId;

    m->_method_function = method_function;

    return m;
}

void destroyMethod(Method ** m)
{
    if( *m )
    {
        free(*m);

        memset((*m)->_name,'\0',MAX_INPUT * sizeof(char));
        *m = NULL;
    }
    else
    {
        logMessage(WARNING,"destroyMethod","Trying to free a NULL pointer");
    }
}

void clearResult(Method* m)
{
    // clear statistics value
    m->_last_result                = NULL;
    m->_last_result_function_value = 0;
    m->_last_absolute_error        = 0;
    m->_last_relative_error        = 0;
    m->_last_complexity            = 0;
}

/**
 * <quote>H-H-H-H-H-HAAAAASHMAP !</quote>
 *
 * TODO : Empêcher les mauvais accès
 *
 * @param m
 * @return
 */
void** formatResult(Method* m)
{
    // FIXME Problème multi-process ? multi-thread ?
    static void** result = NULL;

/*
    {
        {(void * )"last_result",                (void *)&(m->_last_result)} ,
        {(void * )"last_result_function_value", (void *)&(m->_last_result_function_value)} ,
        {(void * )"last_absolute_error",        (void *)&(m->_last_absolute_error)} ,
        {(void * )"last_relative_error",        (void *)&(m->_last_relative_error)} ,
        {(void * )"last_complexity",            (void *)&(m->_last_complexity)} 
    };
*/

    return result;
}