/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * Copyright (C) 2003 Imendio AB

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this program; if not, see <https://www.gnu.org/licenses>

 */

/**

 * SECTION:lm-message

 * @Title: LmMessage

 * @Short_description: A message is built up like a tree of message nodes.

 *

 * Represents a message that can be sent with lm_connection_send(), lm_connection_send_with_reply() or lm_connection_send_with_reply_and_block(). Either use lm_message_new() or lm_message_new_with_subtype() to create a message. You need to call lm_message_unref() when are finished with it.

 */

#include <config.h>

#include <string.h>

#include "lm-internals.h"

#include "lm-message.h"

#define PRIV(o) ((LmMessage *)o)->priv

static struct TypeNames

{

    LmMessageType  type;

    const gchar   *name;

} type_names[] = {

    { LM_MESSAGE_TYPE_MESSAGE,         "message"         },

    { LM_MESSAGE_TYPE_PRESENCE,        "presence"        },

    { LM_MESSAGE_TYPE_IQ,              "iq"              },

    { LM_MESSAGE_TYPE_STREAM,          "stream:stream"   },

    { LM_MESSAGE_TYPE_STREAM_ERROR,    "stream:error"    },

    { LM_MESSAGE_TYPE_STREAM_FEATURES, "stream:features" },

    { LM_MESSAGE_TYPE_AUTH,            "auth"            },

    { LM_MESSAGE_TYPE_CHALLENGE,       "challenge"       },

    { LM_MESSAGE_TYPE_RESPONSE,        "response"        },

    { LM_MESSAGE_TYPE_SUCCESS,         "success"         },

    { LM_MESSAGE_TYPE_FAILURE,         "failure"         },

    { LM_MESSAGE_TYPE_PROCEED,         "proceed"         },

    { LM_MESSAGE_TYPE_STARTTLS,        "starttls"        },

    { LM_MESSAGE_TYPE_UNKNOWN,         NULL              }

};

static struct SubTypeNames

{

    LmMessageSubType  type;

    const gchar      *name;

} sub_type_names[] = {

    { LM_MESSAGE_SUB_TYPE_NORMAL,          "normal"        },

    { LM_MESSAGE_SUB_TYPE_CHAT,            "chat"          },

    { LM_MESSAGE_SUB_TYPE_GROUPCHAT,       "groupchat"     },

    { LM_MESSAGE_SUB_TYPE_HEADLINE,        "headline"      },

    { LM_MESSAGE_SUB_TYPE_UNAVAILABLE,     "unavailable"   },

    { LM_MESSAGE_SUB_TYPE_PROBE,           "probe"         },

    { LM_MESSAGE_SUB_TYPE_SUBSCRIBE,       "subscribe"     },

    { LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE,     "unsubscribe"   },

    { LM_MESSAGE_SUB_TYPE_SUBSCRIBED,      "subscribed"    },

    { LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED,    "unsubscribed"  },

    { LM_MESSAGE_SUB_TYPE_GET,             "get"           },

    { LM_MESSAGE_SUB_TYPE_SET,             "set"           },

    { LM_MESSAGE_SUB_TYPE_RESULT,          "result"        },

    { LM_MESSAGE_SUB_TYPE_ERROR,           "error"         }

};

struct LmMessagePriv {

    LmMessageType    type;

    LmMessageSubType sub_type;

    gint             ref_count;

};

static LmMessageType

message_type_from_string (const gchar *type_str)

{

    gint i;

    if (!type_str) {

        return LM_MESSAGE_TYPE_UNKNOWN;

    }

    for (i = LM_MESSAGE_TYPE_MESSAGE;

         i < LM_MESSAGE_TYPE_UNKNOWN;

         ++i) {

        if (strcmp (type_str, type_names[i].name) == 0) {

            return type_names[i].type;

        }

    }

    return LM_MESSAGE_TYPE_UNKNOWN;

}

const gchar *

_lm_message_type_to_string (LmMessageType type)

{

    if (type < LM_MESSAGE_TYPE_MESSAGE ||

        type > LM_MESSAGE_TYPE_STARTTLS) {

        type = LM_MESSAGE_TYPE_UNKNOWN;

    }

    return type_names[type].name;

}

static LmMessageSubType

message_sub_type_from_string (const gchar *type_str)

{

    gint i;

    if (!type_str) {

        return LM_MESSAGE_SUB_TYPE_NOT_SET;

    }

    for (i = LM_MESSAGE_SUB_TYPE_NORMAL;

         i <= LM_MESSAGE_SUB_TYPE_ERROR;

         ++i) {

        if (g_ascii_strcasecmp (type_str,

                                sub_type_names[i].name) == 0) {

            return i;

        }

    }

    return LM_MESSAGE_SUB_TYPE_NOT_SET;

}

const gchar *

_lm_message_sub_type_to_string (LmMessageSubType type)

{

    if (type < LM_MESSAGE_SUB_TYPE_NORMAL ||

        type > LM_MESSAGE_SUB_TYPE_ERROR) {

        return NULL;

    }

    return sub_type_names[type].name;

}

static LmMessageSubType

message_sub_type_when_unset (LmMessageType type) {

    LmMessageSubType sub_type = LM_MESSAGE_SUB_TYPE_NORMAL;

    switch (type) {

    case LM_MESSAGE_TYPE_MESSAGE:

        /* A message without type should be handled like a message with

         * type=normal, but we won't set it to that since then the user

         * will not know if it's set or not.

         */

        sub_type = LM_MESSAGE_SUB_TYPE_NOT_SET;

        break;

    case LM_MESSAGE_TYPE_PRESENCE:

        sub_type = LM_MESSAGE_SUB_TYPE_AVAILABLE;

        break;

    case LM_MESSAGE_TYPE_IQ:

        sub_type = LM_MESSAGE_SUB_TYPE_GET;

        break;

    default:

        break;

    }

    return sub_type;

}

LmMessage *

_lm_message_new_from_node (LmMessageNode *node)

{

    LmMessage        *m;

    LmMessageType     type;

    LmMessageSubType  sub_type;

    const gchar      *sub_type_str;

    type = message_type_from_string (node->name);

    if (type == LM_MESSAGE_TYPE_UNKNOWN) {

        return NULL;

    }

    sub_type_str = lm_message_node_get_attribute (node, "type");

    if (sub_type_str) {

        sub_type = message_sub_type_from_string (sub_type_str);

    } else {

        sub_type = message_sub_type_when_unset (type);

    }

    m = g_new0 (LmMessage, 1);

    m->priv = g_new0 (LmMessagePriv, 1);

    PRIV(m)->ref_count = 1;

    PRIV(m)->type = type;

    PRIV(m)->sub_type = sub_type;

    m->node = lm_message_node_ref (node);

    return m;

}

/**

 * lm_message_new:

 * @to: receipient jid

 * @type: message type

 *

 * Creates a new #LmMessage which can be sent with lm_connection_send() or

 * lm_connection_send_with_reply(). If @to is %NULL the message is sent to the

 * server. The returned message should be unreferenced with lm_message_unref()

 * when caller is finished with it.

 *

 * Return value: a newly created #LmMessage

 **/

LmMessage *

lm_message_new (const gchar *to, LmMessageType type)

{

    LmMessage *m;

    gchar     *id;

    m       = g_new0 (LmMessage, 1);

    m->priv = g_new0 (LmMessagePriv, 1);

    PRIV(m)->ref_count = 1;

    PRIV(m)->type      = type;

    PRIV(m)->sub_type  = message_sub_type_when_unset (type);

    m->node = _lm_message_node_new (_lm_message_type_to_string (type));

    if (type != LM_MESSAGE_TYPE_STREAM) {

        id = _lm_utils_generate_id ();

        lm_message_node_set_attribute (m->node, "id", id);

        g_free (id);

    }

    if (to) {

        lm_message_node_set_attribute (m->node, "to", to);

    }

    if (type == LM_MESSAGE_TYPE_IQ) {

        lm_message_node_set_attribute (m->node, "type", "get");

    }

    return m;

}

/**

 * lm_message_new_with_sub_type:

 * @to: receipient jid

 * @type: message type

 * @sub_type: message sub type

 *

 * Creates a new #LmMessage with sub type set. See lm_message_new() for more

 * information.

 *

 * Return value: a newly created #LmMessage

 **/

LmMessage *

lm_message_new_with_sub_type (const gchar      *to,

                              LmMessageType     type,

                              LmMessageSubType  sub_type)

{

    LmMessage   *m;

    const gchar *type_str;

    m = lm_message_new (to, type);

    type_str = _lm_message_sub_type_to_string (sub_type);

    if (type_str) {

        lm_message_node_set_attributes (m->node,

                                        "type", type_str, NULL);

        PRIV(m)->sub_type = sub_type;

    }

    return m;

}

/**

 * lm_message_get_type:

 * @message: an #LmMessage

 *

 * Fetches the type of @message.

 *

 * Return value: the message type

 **/

LmMessageType

lm_message_get_type (LmMessage *message)

{

    g_return_val_if_fail (message != NULL, LM_MESSAGE_TYPE_UNKNOWN);

    return PRIV(message)->type;

}

/**

 * lm_message_get_sub_type:

 * @message:

 *

 * Fetches the sub type of @message.

 *

 * Return value: the message sub type

 **/

LmMessageSubType

lm_message_get_sub_type (LmMessage *message)

{

    g_return_val_if_fail (message != NULL, LM_MESSAGE_SUB_TYPE_NOT_SET);

    return PRIV(message)->sub_type;

}

/**

 * lm_message_get_node:

 * @message: an #LmMessage

 *

 * Retrieves the root node from @message.

 *

 * Return value: an #LmMessageNode

 **/

LmMessageNode *

lm_message_get_node (LmMessage *message)

{

    g_return_val_if_fail (message != NULL, NULL);

    return message->node;

}

/**

 * lm_message_ref:

 * @message: an #LmMessage

 *

 * Adds a reference to @message.

 *

 * Return value: the message

 **/

LmMessage *

lm_message_ref (LmMessage *message)

{

    g_return_val_if_fail (message != NULL, NULL);

    PRIV(message)->ref_count++;

    return message;

}

/**

 * lm_message_unref:

 * @message: an #LmMessage

 *

 * Removes a reference from @message. When no more references are present the

 * message is freed.

 **/

void

lm_message_unref (LmMessage *message)

{

    g_return_if_fail (message != NULL);

    PRIV(message)->ref_count--;

    if (PRIV(message)->ref_count == 0) {

        lm_message_node_unref (message->node);

        g_free (message->priv);

        g_free (message);

    }

}