/**
 * {関数名}: (関数に対するアノテーション)
 * @{引数名}: (引数に対するアノテーション): {引数の説明}
 * @{引数名}: (引数に対するアノテーション): {引数の説明}
 * ...
 * 
 * {関数の説明}
 *
 * Returns: (返り値に対するアノテーション): {返り値の説明}
 * 
 * {その他(tag)}
 */

/**
 * milter_agent_get_decoder:
 * @agent: A agent from which to get the decoder.
 *
 * Returns: (transfer none): The decoder of the agent.
 */
MilterDecoder *
milter_agent_get_decoder (MilterAgent *agent)
{
    return MILTER_AGENT_GET_PRIVATE(agent)->decoder;
}

/**
 * milter_logger:
 *
 * Returns: (transfer none): The singleton logger in this process.
 */
MilterLogger *
milter_logger (void)
{
    return singleton_milter_logger;
}

/**
 * milter_agent_get_encoder:
 * @agent: A agent from which to get the encoder.
 *
 * Returns: (transfer none): The encoder of the agent.
 */
MilterEncoder *
milter_agent_get_encoder (MilterAgent *agent)
{
    return MILTER_AGENT_GET_PRIVATE(agent)->encoder;
}

/**
 * milter_option_copy:
 * @option: A option to be copied.
 *
 * Returns: (transfer full): The copied option.
 */
MilterOption *
milter_option_copy (MilterOption *option)
{
    return g_object_new(MILTER_TYPE_OPTION,
                        "version", milter_option_get_version(option),
                        "action", milter_option_get_action(option),
                        "step", milter_option_get_step(option),
                        NULL);
}

/**
 * milter_libev_event_loop_default:
 *
 * Returns: (transfer full): The default event loop.
 */
MilterEventLoop *
milter_libev_event_loop_default (void)
{
    if (!default_event_loop) {
        default_event_loop =
            g_object_new(MILTER_TYPE_LIBEV_EVENT_LOOP,
                         "ev-loop", ev_default_loop(EVFLAG_FORKCHECK),
                         NULL);
    } else {
        g_object_ref(default_event_loop);
    }

    return default_event_loop;
}

/**
 * milter_manager_module_collect_names:
 * @modules: (element-type MilterManagerModule):
 *   A list of #MilterManagerModule.
 *
 * Returns: (transfer container) (element-type utf8):
 *    Names of @modules.
 */
GList *
milter_manager_module_collect_names (GList *modules)
{
    GList *results = NULL;
    GList *node;

    for (node = modules; node; node = g_list_next(node)) {
        MilterManagerModule *module;

        module = node->data;
        results = g_list_prepend(results, G_TYPE_MODULE(module)->name);
    }

    return results;
}

/**
 * milter_macros_requests_get_symbols:
 * @requests: A #MilterMacrosRequests.
 * @command: A #MilterCommand.
 *
 * Returns: (transfer none) (element-type utf8): The symbols of the requests.
 */
GList *
milter_macros_requests_get_symbols (MilterMacrosRequests *requests,
                                    MilterCommand command)
{
    GHashTable *symbols_table;

    symbols_table = MILTER_MACROS_REQUESTS_GET_PRIVATE(requests)->symbols_table;
    return g_hash_table_lookup(symbols_table, GINT_TO_POINTER(command));
}

static void
symbols_free (gpointer data)
{
    GList *symbols = data;

    g_list_foreach(symbols, (GFunc)g_free, NULL);
    g_list_free(symbols);
}

static void
milter_macros_requests_init (MilterMacrosRequests *requests)
{
    MilterMacrosRequestsPrivate *priv;

    priv = MILTER_MACROS_REQUESTS_GET_PRIVATE(requests);

    priv->symbols_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
                                                NULL, symbols_free);
}

void
milter_macros_requests_set_symbols_string_array (MilterMacrosRequests *requests,
                                                 MilterCommand command,
                                                 const gchar **strings)
{
    MilterMacrosRequestsPrivate *priv;
    GList *symbols = NULL;
    gint i;

    for (i = 0; strings[i]; i++) {
        symbols = g_list_append(symbols, g_strdup(strings[i]));
    }

    priv = MILTER_MACROS_REQUESTS_GET_PRIVATE(requests);
    g_hash_table_insert(priv->symbols_table, GINT_TO_POINTER(command), symbols);
}

/**
 * milter_manager_configuration_instantiate: (skip)
 * @first_property: The value of the first property.
 * 
 * This function takes the property values as variable length arguments.
 *
 * Returns: (transfer full): A newly created #MilterManagerConfiguration.
 */
MilterManagerConfiguration *
milter_manager_configuration_instantiate (const gchar *first_property,
                                          ...)
{
    MilterManagerConfiguration *configuration;
    va_list var_args;

    va_start(var_args, first_property);
    configuration =
        milter_manager_configuration_instantiate_va_list(first_property,
                                                         var_args);
    va_end(var_args);

    return configuration;
}

/**
 * milter_decoder_decode_negotiate:
 * @buffer: A buffer that has the target data.
 * @length: The number of bytes of @buffer.
 * @processed_length: (out): The number of bytes that are processed.
 * @error: (nullable): Return location for a #GError or %NULL.
 *
 * Returns: (transfer full) (nullable): The decoded #MilterOption on success,
 *   %NULL on error.
 */
MilterOption *
milter_decoder_decode_negotiate (const gchar *buffer,
                                 gint length,
                                 gint *processed_length,
                                 GError **error)
{
    gsize i;
    guint32 version, action, step;

    *processed_length = 0;

    i = 1;
    if (!milter_decoder_check_command_length(
            buffer + i, length - i, sizeof(version),
            MILTER_DECODER_COMPARE_AT_LEAST, error,
            "version on option negotiation command")) {
        return NULL;
    }
    memcpy(&version, buffer + i, sizeof(version));
    i += sizeof(version);

    if (!milter_decoder_check_command_length(
            buffer + i, length - i, sizeof(action),
            MILTER_DECODER_COMPARE_AT_LEAST, error,
            "action flags on option negotiation command")) {
        return NULL;
    }
    memcpy(&action, buffer + i, sizeof(action));
    i += sizeof(action);

    if (!milter_decoder_check_command_length(
            buffer + i, length - i, sizeof(step),
            MILTER_DECODER_COMPARE_AT_LEAST, error,
            "step flags on option negotiation command")) {
        return NULL;
    }
    memcpy(&step, buffer + i, sizeof(step));
    i += sizeof(step);

    *processed_length = i;

    return milter_option_new(g_ntohl(version), g_ntohl(action), g_ntohl(step));
}