/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details:
 *
 * Copyright (C) 2008 - 2009 Novell, Inc.
 * Copyright (C) 2009 Red Hat, Inc.
 */

#define _GNU_SOURCE  /* for strcasestr() */

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

#include "mm-port-serial-at.h"
#include "mm-log.h"

G_DEFINE_TYPE (MMPortSerialAt, mm_port_serial_at, MM_TYPE_PORT_SERIAL)

enum {
    PROP_0,
    PROP_REMOVE_ECHO,
    PROP_INIT_SEQUENCE_ENABLED,
    PROP_INIT_SEQUENCE,
    PROP_SEND_LF,
    LAST_PROP
};

struct _MMPortSerialAtPrivate {
    /* Response parser data */
    MMPortSerialAtResponseParserFn response_parser_fn;
    gpointer response_parser_user_data;
    GDestroyNotify response_parser_notify;

    GSList *unsolicited_msg_handlers;

    MMPortSerialAtFlag flags;

    /* Properties */
    gboolean remove_echo;
    guint init_sequence_enabled;
    gchar **init_sequence;
    gboolean send_lf;
};

/*****************************************************************************/

gchar *
mm_port_serial_at_quote_string (const char *string)
{
    int len, i;
    gchar *quoted, *pos;

    if (string == NULL)
        len = 0;
    else
        len = strlen (string);
    quoted = g_malloc (3 + 3 * len); /* worst case */

    pos = quoted;
    *pos++ = '"';
    for (i = 0 ; i < len; i++) {
        if (string[i] < 0x20 || string[i] == '"' || string[i] == '\\')
            pos += sprintf (pos, "\\%02X", string[i]);
        else
            *pos++ = string[i];
    }
    *pos++ = '"';
    *pos++ = '\0';

    return quoted;
}

void
mm_port_serial_at_set_response_parser (MMPortSerialAt *self,
                                       MMPortSerialAtResponseParserFn fn,
                                       gpointer user_data,
                                       GDestroyNotify notify)
{
    g_return_if_fail (MM_IS_PORT_SERIAL_AT (self));

    if (self->priv->response_parser_notify)
        self->priv->response_parser_notify (self->priv->response_parser_user_data);

    self->priv->response_parser_fn = fn;
    self->priv->response_parser_user_data = user_data;
    self->priv->response_parser_notify = notify;
}

void
mm_port_serial_at_remove_echo (GByteArray *response)
{
    guint i;

    if (response->len <= 2)
        return;

    for (i = 0; i < (response->len - 1); i++) {
        /* If there is any content before the first
         * <CR><LF>, assume it's echo or garbage, and skip it */
        if (response->data[i] == '\r' && response->data[i + 1] == '\n') {
            if (i > 0)
                g_byte_array_remove_range (response, 0, i);
            /* else, good, we're already started with <CR><LF> */
            break;
        }
    }
}

static MMPortSerialResponseType
parse_response (MMPortSerial *port,
                GByteArray *response,
                GByteArray **parsed_response,
                GError **error)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (port);
    GString *string;
    gsize parsed_len;
    GError *inner_error = NULL;

    g_return_val_if_fail (self->priv->response_parser_fn != NULL, FALSE);

    /* Remove echo */
    if (self->priv->remove_echo)
        mm_port_serial_at_remove_echo (response);

    /* If there's no response to receive, we're done; e.g. if we only got
     * unsolicited messages */
    if (!response->len)
        return MM_PORT_SERIAL_RESPONSE_NONE;

    /* Construct the string that AT-parsing functions expect */
    string = g_string_sized_new (response->len + 1);
    g_string_append_len (string, (const char *) response->data, response->len);

    /* Fully cleanup the response array, we'll consider the contents we got
     * as the full reply that the command may expect. */
    g_byte_array_remove_range (response, 0, response->len);

    /* Parse it; returns FALSE if there is nothing we can do with this
     * response yet. */
    if (!self->priv->response_parser_fn (self->priv->response_parser_user_data, string, &inner_error)) {
        /* Copy what we got back in the response buffer. */
        g_byte_array_append (response, (const guint8 *) string->str, string->len);
        g_string_free (string, TRUE);
        return MM_PORT_SERIAL_RESPONSE_NONE;
    }

    /* If we got an error, propagate it without any further response string */
    if (inner_error) {
        g_string_free (string, TRUE);
        g_propagate_error (error, inner_error);
        return MM_PORT_SERIAL_RESPONSE_ERROR;
    }

    /* Otherwise, build a new GByteArray considered as parsed response */
    parsed_len = string->len;
    *parsed_response = g_byte_array_new_take ((guint8 *) g_string_free (string, FALSE), parsed_len);
    return MM_PORT_SERIAL_RESPONSE_BUFFER;
}

/*****************************************************************************/

typedef struct {
    GRegex *regex;
    MMPortSerialAtUnsolicitedMsgFn callback;
    gboolean enable;
    gpointer user_data;
    GDestroyNotify notify;
} MMAtUnsolicitedMsgHandler;

static gint
unsolicited_msg_handler_cmp (MMAtUnsolicitedMsgHandler *handler,
                             GRegex *regex)
{
    return g_strcmp0 (g_regex_get_pattern (handler->regex),
                      g_regex_get_pattern (regex));
}

void
mm_port_serial_at_add_unsolicited_msg_handler (MMPortSerialAt *self,
                                               GRegex *regex,
                                               MMPortSerialAtUnsolicitedMsgFn callback,
                                               gpointer user_data,
                                               GDestroyNotify notify)
{
    GSList *existing;
    MMAtUnsolicitedMsgHandler *handler;

    g_return_if_fail (MM_IS_PORT_SERIAL_AT (self));
    g_return_if_fail (regex != NULL);

    existing = g_slist_find_custom (self->priv->unsolicited_msg_handlers,
                                    regex,
                                    (GCompareFunc)unsolicited_msg_handler_cmp);
    if (existing) {
        handler = existing->data;
        /* We OVERWRITE any existing one, so if any context data existing, free it */
        if (handler->notify)
            handler->notify (handler->user_data);
    } else {
        /* The new handler is always PREPENDED, so that e.g. plugins can provide
         * more specific matches for URCs that are also handled by the generic
         * plugin. */
        handler = g_slice_new (MMAtUnsolicitedMsgHandler);
        handler->regex = g_regex_ref (regex);
        self->priv->unsolicited_msg_handlers = g_slist_prepend (self->priv->unsolicited_msg_handlers, handler);
    }

    handler->callback = callback;
    handler->enable = TRUE;
    handler->user_data = user_data;
    handler->notify = notify;
}

void
mm_port_serial_at_enable_unsolicited_msg_handler (MMPortSerialAt *self,
                                                  GRegex *regex,
                                                  gboolean enable)
{
    GSList *existing;
    MMAtUnsolicitedMsgHandler *handler;

    g_return_if_fail (MM_IS_PORT_SERIAL_AT (self));
    g_return_if_fail (regex != NULL);

    existing = g_slist_find_custom (self->priv->unsolicited_msg_handlers,
                                    regex,
                                    (GCompareFunc)unsolicited_msg_handler_cmp);
    if (existing) {
        handler = existing->data;
        handler->enable = enable;
    }
}

static gboolean
remove_eval_cb (const GMatchInfo *match_info,
                GString *result,
                gpointer user_data)
{
    int *result_len = (int *) user_data;
    int start;
    int end;

    if (g_match_info_fetch_pos  (match_info, 0, &start, &end))
        *result_len -= (end - start);

    return FALSE;
}

static void
parse_unsolicited (MMPortSerial *port, GByteArray *response)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (port);
    GSList *iter;

    /* Remove echo */
    if (self->priv->remove_echo)
        mm_port_serial_at_remove_echo (response);

    for (iter = self->priv->unsolicited_msg_handlers; iter; iter = iter->next) {
        MMAtUnsolicitedMsgHandler *handler = (MMAtUnsolicitedMsgHandler *) iter->data;
        GMatchInfo *match_info;
        gboolean matches;

        if (!handler->enable)
            continue;

        matches = g_regex_match_full (handler->regex,
                                      (const char *) response->data,
                                      response->len,
                                      0, 0, &match_info, NULL);
        if (handler->callback) {
            while (g_match_info_matches (match_info)) {
                handler->callback (self, match_info, handler->user_data);
                g_match_info_next (match_info, NULL);
            }
        }

        g_match_info_free (match_info);

        if (matches) {
            /* Remove matches */
            char *str;
            int result_len = response->len;

            str = g_regex_replace_eval (handler->regex,
                                        (const char *) response->data,
                                        response->len,
                                        0, 0,
                                        remove_eval_cb, &result_len, NULL);

            g_byte_array_remove_range (response, 0, response->len);
            g_byte_array_append (response, (const guint8 *) str, result_len);
            g_free (str);
        }
    }
}

/*****************************************************************************/

static GByteArray *
at_command_to_byte_array (const char *command, gboolean is_raw, gboolean send_lf)
{
    GByteArray *buf;
    int cmdlen;

    g_return_val_if_fail (command != NULL, NULL);

    cmdlen = strlen (command);
    buf = g_byte_array_sized_new (cmdlen + 4);

    if (!is_raw) {
        /* Make sure there's an AT in the front */
        if (!g_str_has_prefix (command, "AT"))
            g_byte_array_append (buf, (const guint8 *) "AT", 2);
    }

    g_byte_array_append (buf, (const guint8 *) command, cmdlen);

    if (!is_raw) {
        /* Make sure there's a trailing carriage return */
        if ((cmdlen == 0) ||
            (command[cmdlen - 1] != '\r' && (cmdlen == 1 || command[cmdlen - 2] != '\r')))
             g_byte_array_append (buf, (const guint8 *) "\r", 1);
        if (send_lf) {
            /* Make sure there's a trailing line-feed */
            if ((cmdlen == 0) ||
                (command[cmdlen - 1] != '\n' && (cmdlen == 1 || command[cmdlen - 2] != '\n')))
                 g_byte_array_append (buf, (const guint8 *) "\n", 1);
        }
    }

    return buf;
}

const gchar *
mm_port_serial_at_command_finish (MMPortSerialAt *self,
                                  GAsyncResult *res,
                                  GError **error)
{
    GString *str;

    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
        return NULL;

    str = (GString *)g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res));
    return str->str;
}

static void
string_free (GString *str)
{
    g_string_free (str, TRUE);
}

static void
serial_command_ready (MMPortSerial *port,
                      GAsyncResult *res,
                      GSimpleAsyncResult *simple)
{
    GByteArray *response_buffer;
    GError *error = NULL;
    GString *response;

    response_buffer = mm_port_serial_command_finish (port, res, &error);
    if (!response_buffer) {
        g_simple_async_result_take_error (simple, error);
        g_simple_async_result_complete (simple);
        g_object_unref (simple);
        return;
    }

    /* Build a GString just with the response we need, and clear the
     * processed range from the response buffer */
    response = g_string_new_len ((const gchar *)response_buffer->data, response_buffer->len);
    if (response_buffer->len > 0)
        g_byte_array_remove_range (response_buffer, 0, response_buffer->len);
    g_byte_array_unref (response_buffer);

    g_simple_async_result_set_op_res_gpointer (simple,
                                               response,
                                               (GDestroyNotify)string_free);
    g_simple_async_result_complete (simple);
    g_object_unref (simple);
}

void
mm_port_serial_at_command (MMPortSerialAt *self,
                           const char *command,
                           guint32 timeout_seconds,
                           gboolean is_raw,
                           gboolean allow_cached,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data)
{
    GSimpleAsyncResult *simple;
    GByteArray *buf;

    g_return_if_fail (self != NULL);
    g_return_if_fail (MM_IS_PORT_SERIAL_AT (self));
    g_return_if_fail (command != NULL);

    buf = at_command_to_byte_array (command,
                                    is_raw,
                                    (mm_port_get_subsys (MM_PORT (self)) == MM_PORT_SUBSYS_TTY ?
                                     self->priv->send_lf :
                                     TRUE));
    g_return_if_fail (buf != NULL);

    simple = g_simple_async_result_new (G_OBJECT (self),
                                        callback,
                                        user_data,
                                        mm_port_serial_at_command);

    mm_port_serial_command (MM_PORT_SERIAL (self),
                            buf,
                            timeout_seconds,
                            allow_cached,
                            is_raw, /* raw commands always run next, never queued last */
                            cancellable,
                            (GAsyncReadyCallback)serial_command_ready,
                            simple);
    g_byte_array_unref (buf);
}

static void
debug_log (MMPortSerial *port, const char *prefix, const char *buf, gsize len)
{
    static GString *debug = NULL;
    const char *s;

    if (!debug)
        debug = g_string_sized_new (256);

    g_string_append (debug, prefix);
    g_string_append (debug, " '");

    s = buf;
    while (len--) {
        if (g_ascii_isprint (*s))
            g_string_append_c (debug, *s);
        else if (*s == '\r')
            g_string_append (debug, "<CR>");
        else if (*s == '\n')
            g_string_append (debug, "<LF>");
        else
            g_string_append_printf (debug, "\\%u", (guint8) (*s & 0xFF));

        s++;
    }

    g_string_append_c (debug, '\'');
    mm_dbg ("(%s): %s", mm_port_get_device (MM_PORT (port)), debug->str);
    g_string_truncate (debug, 0);
}

void
mm_port_serial_at_set_flags (MMPortSerialAt *self, MMPortSerialAtFlag flags)
{
    g_return_if_fail (self != NULL);
    g_return_if_fail (MM_IS_PORT_SERIAL_AT (self));
    g_return_if_fail (flags <= (MM_PORT_SERIAL_AT_FLAG_PRIMARY |
                                MM_PORT_SERIAL_AT_FLAG_SECONDARY |
                                MM_PORT_SERIAL_AT_FLAG_PPP |
                                MM_PORT_SERIAL_AT_FLAG_GPS_CONTROL));

    self->priv->flags = flags;
}

MMPortSerialAtFlag
mm_port_serial_at_get_flags (MMPortSerialAt *self)
{
    g_return_val_if_fail (self != NULL, MM_PORT_SERIAL_AT_FLAG_NONE);
    g_return_val_if_fail (MM_IS_PORT_SERIAL_AT (self), MM_PORT_SERIAL_AT_FLAG_NONE);

    return self->priv->flags;
}

/*****************************************************************************/

void
mm_port_serial_at_run_init_sequence (MMPortSerialAt *self)
{
    guint i;

    if (!self->priv->init_sequence)
        return;

    mm_dbg ("(%s): running init sequence...", mm_port_get_device (MM_PORT (self)));

    /* Just queue the init commands, don't wait for reply */
    for (i = 0; self->priv->init_sequence[i]; i++) {
        mm_port_serial_at_command (self,
                                   self->priv->init_sequence[i],
                                   3,
                                   FALSE,
                                   FALSE,
                                   NULL,
                                   NULL,
                                   NULL);
    }
}

static void
config (MMPortSerial *_self)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (_self);

    if (self->priv->init_sequence_enabled)
        mm_port_serial_at_run_init_sequence (self);
}

/*****************************************************************************/

MMPortSerialAt *
mm_port_serial_at_new (const char *name,
                       MMPortSubsys subsys)
{
    g_return_val_if_fail (subsys == MM_PORT_SUBSYS_TTY ||
                          subsys == MM_PORT_SUBSYS_USB ||
                          subsys == MM_PORT_SUBSYS_UNIX, NULL);

    return MM_PORT_SERIAL_AT (g_object_new (MM_TYPE_PORT_SERIAL_AT,
                                            MM_PORT_DEVICE, name,
                                            MM_PORT_SUBSYS, subsys,
                                            MM_PORT_TYPE, MM_PORT_TYPE_AT,
                                            NULL));
}

static void
mm_port_serial_at_init (MMPortSerialAt *self)
{
    self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, MM_TYPE_PORT_SERIAL_AT, MMPortSerialAtPrivate);

    /* By default, remove echo */
    self->priv->remove_echo = TRUE;
    /* By default, run init sequence during first port opening */
    self->priv->init_sequence_enabled = TRUE;

    /* By default, don't send line feed */
    self->priv->send_lf = FALSE;
}

static void
set_property (GObject *object,
              guint prop_id,
              const GValue *value,
              GParamSpec *pspec)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (object);

    switch (prop_id) {
    case PROP_REMOVE_ECHO:
        self->priv->remove_echo = g_value_get_boolean (value);
        break;
    case PROP_INIT_SEQUENCE_ENABLED:
        self->priv->init_sequence_enabled = g_value_get_boolean (value);
        break;
    case PROP_INIT_SEQUENCE:
        g_strfreev (self->priv->init_sequence);
        self->priv->init_sequence = g_value_dup_boxed (value);
        break;
    case PROP_SEND_LF:
        self->priv->send_lf = g_value_get_boolean (value);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        break;
    }
}

static void
get_property (GObject *object,
              guint prop_id,
              GValue *value,
              GParamSpec *pspec)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (object);

    switch (prop_id) {
    case PROP_REMOVE_ECHO:
        g_value_set_boolean (value, self->priv->remove_echo);
        break;
    case PROP_INIT_SEQUENCE_ENABLED:
        g_value_set_boolean (value, self->priv->init_sequence_enabled);
        break;
    case PROP_INIT_SEQUENCE:
        g_value_set_boxed (value, self->priv->init_sequence);
        break;
    case PROP_SEND_LF:
        g_value_set_boolean (value, self->priv->send_lf);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
        break;
    }
}

static void
finalize (GObject *object)
{
    MMPortSerialAt *self = MM_PORT_SERIAL_AT (object);

    while (self->priv->unsolicited_msg_handlers) {
        MMAtUnsolicitedMsgHandler *handler = (MMAtUnsolicitedMsgHandler *) self->priv->unsolicited_msg_handlers->data;

        if (handler->notify)
            handler->notify (handler->user_data);

        g_regex_unref (handler->regex);
        g_slice_free (MMAtUnsolicitedMsgHandler, handler);
        self->priv->unsolicited_msg_handlers = g_slist_delete_link (self->priv->unsolicited_msg_handlers,
                                                                    self->priv->unsolicited_msg_handlers);
    }

    if (self->priv->response_parser_notify)
        self->priv->response_parser_notify (self->priv->response_parser_user_data);

    g_strfreev (self->priv->init_sequence);

    G_OBJECT_CLASS (mm_port_serial_at_parent_class)->finalize (object);
}

static void
mm_port_serial_at_class_init (MMPortSerialAtClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
    MMPortSerialClass *serial_class = MM_PORT_SERIAL_CLASS (klass);

    g_type_class_add_private (object_class, sizeof (MMPortSerialAtPrivate));

    /* Virtual methods */
    object_class->set_property = set_property;
    object_class->get_property = get_property;
    object_class->finalize = finalize;

    serial_class->parse_unsolicited = parse_unsolicited;
    serial_class->parse_response = parse_response;
    serial_class->debug_log = debug_log;
    serial_class->config = config;

    g_object_class_install_property
        (object_class, PROP_REMOVE_ECHO,
         g_param_spec_boolean (MM_PORT_SERIAL_AT_REMOVE_ECHO,
                               "Remove echo",
                               "Built-in echo removal should be applied",
                               TRUE,
                               G_PARAM_READWRITE));

    g_object_class_install_property
        (object_class, PROP_INIT_SEQUENCE_ENABLED,
         g_param_spec_boolean (MM_PORT_SERIAL_AT_INIT_SEQUENCE_ENABLED,
                               "Init sequence enabled",
                               "Whether the initialization sequence should be run",
                               TRUE,
                               G_PARAM_READWRITE));

    g_object_class_install_property
        (object_class, PROP_INIT_SEQUENCE,
         g_param_spec_boxed (MM_PORT_SERIAL_AT_INIT_SEQUENCE,
                             "Init sequence",
                             "Initialization sequence",
                             G_TYPE_STRV,
                             G_PARAM_READWRITE));

    g_object_class_install_property
        (object_class, PROP_SEND_LF,
         g_param_spec_boolean (MM_PORT_SERIAL_AT_SEND_LF,
                               "Send LF",
                               "Send line-feed at the end of each AT command sent",
                               FALSE,
                               G_PARAM_READWRITE));
}
