/* -*- 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) 2012 Google, Inc.
 */

#include <ModemManager.h>
#define _LIBMM_INSIDE_MM
#include <libmm-glib.h>

#include "mm-iface-modem.h"
#include "mm-iface-modem-firmware.h"
#include "mm-error-helpers.h"
#include "mm-log-object.h"

#if defined WITH_QMI
# include "mm-broadband-modem-qmi.h"
#endif
#if defined WITH_MBIM
# include "mm-broadband-modem-mbim.h"
#endif

G_DEFINE_INTERFACE (MMIfaceModemFirmware, mm_iface_modem_firmware, MM_TYPE_IFACE_MODEM)

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

void
mm_iface_modem_firmware_bind_simple_status (MMIfaceModemFirmware *self,
                                             MMSimpleStatus *status)
{
}

/*****************************************************************************/
/* Load update settings in port (Firmware interface) */

MMFirmwareUpdateSettings *
mm_iface_modem_firmware_load_update_settings_in_port_finish (MMIfaceModemFirmware  *self,
                                                             GAsyncResult          *res,
                                                             GError               **error)
{
    return g_task_propagate_pointer (G_TASK (res), error);
}

static gboolean
modem_is_sahara_supported (MMKernelDevice *kernel_device)
{
    return mm_kernel_device_get_global_property_as_boolean (kernel_device, "ID_MM_QUALCOMM_SAHARA");
}

static gboolean
modem_is_firehose_supported (MMKernelDevice *kernel_device)
{
    return mm_kernel_device_get_global_property_as_boolean (kernel_device, "ID_MM_QUALCOMM_FIREHOSE");
}

void
mm_iface_modem_firmware_load_update_settings_in_port (MMIfaceModemFirmware *self,
                                                      MMPort               *port,
                                                      GAsyncReadyCallback   callback,
                                                      gpointer              user_data)
{
    GTask                               *task;
    MMModemFirmwareUpdateMethod          update_methods;
    g_autoptr(MMFirmwareUpdateSettings)  update_settings = NULL;

    task = g_task_new (self, NULL, callback, user_data);

    update_methods = MM_MODEM_FIRMWARE_UPDATE_METHOD_NONE;
    if (MM_IS_PORT (port)) {
        MMKernelDevice *kernel_device;

        kernel_device = mm_port_peek_kernel_device (MM_PORT (port));

        if (modem_is_firehose_supported (kernel_device))
            update_methods |= MM_MODEM_FIRMWARE_UPDATE_METHOD_FIREHOSE;
        if (modem_is_sahara_supported (kernel_device))
            update_methods |= MM_MODEM_FIRMWARE_UPDATE_METHOD_SAHARA;
    }

    update_settings = mm_firmware_update_settings_new (update_methods);
    g_task_return_pointer (task, g_object_ref (update_settings), (GDestroyNotify)g_object_unref);
    g_object_unref (task);
}

/*****************************************************************************/
/* Handle the 'List' method from DBus */

typedef struct {
    MMIfaceModemFirmware *self;
    MmGdbusModemFirmware *skeleton;
    GDBusMethodInvocation *invocation;
    GList *list;
    MMFirmwareProperties *current;
} HandleListContext;

static void
handle_list_context_free (HandleListContext *ctx)
{
    if (ctx->list)
        g_list_free_full (ctx->list, g_object_unref);
    if (ctx->current)
        g_object_unref (ctx->current);
    g_object_unref (ctx->skeleton);
    g_object_unref (ctx->invocation);
    g_object_unref (ctx->self);
    g_slice_free (HandleListContext, ctx);
}

static void
load_current_ready (MMIfaceModemFirmware *self,
                    GAsyncResult *res,
                    HandleListContext *ctx)
{
    GVariantBuilder builder;
    GList *l;
    GError *error = NULL;

    ctx->current = MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_current_finish (self, res, &error);
    if (!ctx->current) {
        /* Not found isn't fatal */
        if (!g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_NOT_FOUND)) {
            mm_dbus_method_invocation_take_error (ctx->invocation, error);
            handle_list_context_free (ctx);
            return;
        }
        mm_obj_dbg (self, "couldn't load current firmware image: %s", error->message);
        g_clear_error (&error);
    }

    /* Build array of dicts */
    g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}"));
    for (l = ctx->list; l; l = g_list_next (l)) {
        GVariant *dict;

        dict = mm_firmware_properties_get_dictionary (MM_FIRMWARE_PROPERTIES (l->data));
        g_variant_builder_add_value (&builder, dict);
        g_variant_unref (dict);
    }

    mm_gdbus_modem_firmware_complete_list (
        ctx->skeleton,
        ctx->invocation,
        (ctx->current ? mm_firmware_properties_get_unique_id (ctx->current) : ""),
        g_variant_builder_end (&builder));
    handle_list_context_free (ctx);
}

static void
load_list_ready (MMIfaceModemFirmware *self,
                 GAsyncResult *res,
                 HandleListContext *ctx)
{
    GError *error = NULL;

    ctx->list = MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_list_finish (self, res, &error);
    if (!ctx->list) {
        /* Not found isn't fatal */
        if (!g_error_matches (error, MM_CORE_ERROR, MM_CORE_ERROR_NOT_FOUND)) {
            mm_dbus_method_invocation_take_error (ctx->invocation, error);
            handle_list_context_free (ctx);
            return;
        }
        mm_obj_dbg (self, "couldn't load firmware image list: %s", error->message);
        g_clear_error (&error);
    }

    MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_current (
        MM_IFACE_MODEM_FIRMWARE (self),
        (GAsyncReadyCallback)load_current_ready,
        ctx);
}

static void
list_auth_ready (MMIfaceAuth *_self,
                 GAsyncResult *res,
                 HandleListContext *ctx)
{
    MMIfaceModemFirmware *self = MM_IFACE_MODEM_FIRMWARE (_self);
    GError *error = NULL;

    if (!mm_iface_auth_authorize_finish (_self, res, &error)) {
        mm_dbus_method_invocation_take_error (ctx->invocation, error);
        handle_list_context_free (ctx);
        return;
    }

    if (!MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_list ||
        !MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_list_finish ||
        !MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_current ||
        !MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_current_finish) {
        mm_dbus_method_invocation_return_error_literal (ctx->invocation, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
                                                        "Cannot list firmware: operation not supported");
        handle_list_context_free (ctx);
        return;
    }

    mm_obj_info (self, "processing user request to load firmware list...");
    MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_list (
        MM_IFACE_MODEM_FIRMWARE (self),
        (GAsyncReadyCallback)load_list_ready,
        ctx);
}

static gboolean
handle_list (MmGdbusModemFirmware *skeleton,
             GDBusMethodInvocation *invocation,
             MMIfaceModemFirmware *self)
{
    HandleListContext *ctx;

    ctx = g_slice_new0 (HandleListContext);
    ctx->skeleton = g_object_ref (skeleton);
    ctx->invocation = g_object_ref (invocation);
    ctx->self = g_object_ref (self);

    mm_iface_auth_authorize (MM_IFACE_AUTH (self),
                             invocation,
                             MM_AUTHORIZATION_FIRMWARE,
                             (GAsyncReadyCallback)list_auth_ready,
                             ctx);

    return TRUE;
}

/*****************************************************************************/
/* Handle the 'Select' method from DBus */

typedef struct {
    MMIfaceModemFirmware *self;
    MmGdbusModemFirmware *skeleton;
    GDBusMethodInvocation *invocation;
    gchar *name;
} HandleSelectContext;

static void
handle_select_context_free (HandleSelectContext *ctx)
{
    g_free (ctx->name);
    g_object_unref (ctx->skeleton);
    g_object_unref (ctx->invocation);
    g_object_unref (ctx->self);
    g_slice_free (HandleSelectContext, ctx);
}

static void
change_current_ready (MMIfaceModemFirmware *self,
                      GAsyncResult *res,
                      HandleSelectContext *ctx)
{
    GError *error = NULL;

    if (!MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->change_current_finish (self, res, &error))
        mm_dbus_method_invocation_take_error (ctx->invocation, error);
    else
        mm_gdbus_modem_firmware_complete_select (ctx->skeleton, ctx->invocation);
    handle_select_context_free (ctx);
}

static void
select_auth_ready (MMIfaceAuth *_self,
                   GAsyncResult *res,
                   HandleSelectContext *ctx)
{
    MMIfaceModemFirmware *self = MM_IFACE_MODEM_FIRMWARE (_self);
    GError *error = NULL;

    if (!mm_iface_auth_authorize_finish (_self, res, &error)) {
        mm_dbus_method_invocation_take_error (ctx->invocation, error);
        handle_select_context_free (ctx);
        return;
    }


    if (!MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->change_current ||
        !MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->change_current_finish) {
        mm_dbus_method_invocation_return_error_literal (ctx->invocation, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED,
                                                        "Cannot select firmware: operation not supported");
        handle_select_context_free (ctx);
        return;
    }

    mm_obj_info (self, "processing user request to select firmware...");
    MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->change_current (
        MM_IFACE_MODEM_FIRMWARE (self),
        ctx->name,
        (GAsyncReadyCallback)change_current_ready,
        ctx);
}

static gboolean
handle_select (MmGdbusModemFirmware *skeleton,
               GDBusMethodInvocation *invocation,
               const gchar *name,
               MMIfaceModemFirmware *self)
{
    HandleSelectContext *ctx;

    ctx = g_slice_new (HandleSelectContext);
    ctx->skeleton = g_object_ref (skeleton);
    ctx->invocation = g_object_ref (invocation);
    ctx->self = g_object_ref (self);
    ctx->name = g_strdup (name);

    mm_iface_auth_authorize (MM_IFACE_AUTH (self),
                             invocation,
                             MM_AUTHORIZATION_FIRMWARE,
                             (GAsyncReadyCallback)select_auth_ready,
                             ctx);

    return TRUE;
}

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

typedef struct _InitializationContext InitializationContext;
static void interface_initialization_step (GTask *task);

typedef enum {
    INITIALIZATION_STEP_FIRST,
    INITIALIZATION_STEP_UPDATE_SETTINGS,
    INITIALIZATION_STEP_LAST
} InitializationStep;

struct _InitializationContext {
    MmGdbusModemFirmware *skeleton;
    InitializationStep    step;
};

static void
initialization_context_free (InitializationContext *ctx)
{
    g_object_unref (ctx->skeleton);
    g_free (ctx);
}

gboolean
mm_iface_modem_firmware_initialize_finish (MMIfaceModemFirmware  *self,
                                           GAsyncResult          *res,
                                           GError               **error)
{
    return g_task_propagate_boolean (G_TASK (res), error);
}

static gboolean
add_generic_version (MMBaseModem               *self,
                     MMFirmwareUpdateSettings  *update_settings,
                     GError                   **error)
{
    const gchar      *firmware_revision;
    const gchar      *carrier_revision = NULL;
    g_autofree gchar *combined = NULL;
    gboolean          ignore_carrier = FALSE;

    firmware_revision = mm_iface_modem_get_revision (MM_IFACE_MODEM (self));
    if (!firmware_revision) {
        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Unknown revision");
        return FALSE;
    }

    g_object_get (self,
                  MM_IFACE_MODEM_FIRMWARE_IGNORE_CARRIER, &ignore_carrier,
                  NULL);

    if (!ignore_carrier)
        mm_iface_modem_get_carrier_config (MM_IFACE_MODEM (self), NULL, &carrier_revision);

    if (!carrier_revision) {
        mm_firmware_update_settings_set_version (update_settings, firmware_revision);
        return TRUE;
    }

    combined = g_strdup_printf ("%s - %s", firmware_revision, carrier_revision);
    mm_firmware_update_settings_set_version (update_settings, combined);
    return TRUE;
}

GPtrArray *
mm_iface_firmware_build_generic_device_ids (MMIfaceModemFirmware  *self,
                                            GError               **error)
{
    static const gchar   *supported_subsystems[] = { "USB", "PCI" };
    guint16               vid;
    guint16               pid;
    guint16               subsystem_vid;
    guint16               subsystem_pid;
    guint16               rid;
    MMPort               *primary = NULL;
    const gchar          *subsystem;
    const gchar          *carrier_config = NULL;
    g_autoptr(GPtrArray)  ids = NULL;
    guint                 i;
    gboolean              ignore_carrier = FALSE;

    vid = mm_base_modem_get_vendor_id (MM_BASE_MODEM (self));
    pid = mm_base_modem_get_product_id (MM_BASE_MODEM (self));
    subsystem_vid = mm_base_modem_get_subsystem_vendor_id (MM_BASE_MODEM (self));
    subsystem_pid = mm_base_modem_get_subsystem_device_id (MM_BASE_MODEM (self));

#if defined WITH_QMI
    if (MM_IS_BROADBAND_MODEM_QMI (self))
        primary = MM_PORT (mm_broadband_modem_qmi_peek_port_qmi (MM_BROADBAND_MODEM_QMI (self)));
#endif
#if defined WITH_MBIM
    if (!primary && MM_IS_BROADBAND_MODEM_MBIM (self))
        primary = MM_PORT (mm_broadband_modem_mbim_peek_port_mbim (MM_BROADBAND_MODEM_MBIM (self)));
#endif
    if (!primary)
        primary = MM_PORT (mm_base_modem_peek_port_primary (MM_BASE_MODEM (self)));

    if (!primary) {
        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                     "No valid primary port");
        return NULL;
    }

    rid = mm_kernel_device_get_physdev_revision (mm_port_peek_kernel_device (primary));

    subsystem = mm_kernel_device_get_physdev_subsystem (mm_port_peek_kernel_device (primary));
    if (!subsystem) {
        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                     "Unknown device subsystem");
        return NULL;
    }

    for (i = 0; i < G_N_ELEMENTS (supported_subsystems); i++) {
        if (g_ascii_strcasecmp (supported_subsystems[i], subsystem) == 0)
            break;
    }
    if (i == G_N_ELEMENTS (supported_subsystems)) {
        g_set_error (error, MM_CORE_ERROR, MM_CORE_ERROR_FAILED,
                     "Unsupported subsystem: %s", subsystem);
        return NULL;
    }

    g_object_get (self,
                  MM_IFACE_MODEM_FIRMWARE_IGNORE_CARRIER, &ignore_carrier,
                  NULL);

    if (!ignore_carrier)
        mm_iface_modem_get_carrier_config (MM_IFACE_MODEM (self), &carrier_config, NULL);

    ids = g_ptr_array_new_with_free_func (g_free);
    if (carrier_config) {
        g_autofree gchar *carrier = NULL;

        carrier = g_ascii_strup (carrier_config, -1);

        /* Expect non-zero values for PCI devices only */
        if (subsystem_vid && subsystem_pid)
            g_ptr_array_add (ids, g_strdup_printf ("%s\\SSVID_%04X&SSPID_%04X&REV_%04X&CARRIER_%s",
                                                    supported_subsystems[i], subsystem_vid,
                                                    subsystem_pid, rid, carrier));

        g_ptr_array_add (ids, g_strdup_printf ("%s\\VID_%04X&PID_%04X&REV_%04X&CARRIER_%s",
                                               supported_subsystems[i], vid, pid, rid, carrier));
    }
    g_ptr_array_add (ids, g_strdup_printf ("%s\\VID_%04X&PID_%04X&REV_%04X",
                                           supported_subsystems[i], vid, pid, rid));
    g_ptr_array_add (ids, g_strdup_printf ("%s\\VID_%04X&PID_%04X",
                                           supported_subsystems[i], vid, pid));
    g_ptr_array_add (ids, g_strdup_printf ("%s\\VID_%04X",
                                           supported_subsystems[i], vid));
    g_ptr_array_add (ids, NULL);

    return g_steal_pointer (&ids);
}

static void
load_update_settings_ready (MMIfaceModemFirmware *self,
                            GAsyncResult         *res,
                            GTask                *task)
{
    InitializationContext    *ctx;
    MMFirmwareUpdateSettings *update_settings;
    GError                   *error = NULL;
    GVariant                 *variant = NULL;
    g_autoptr(GPtrArray)      ids = NULL;

    ctx = g_task_get_task_data (task);

    update_settings = MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_update_settings_finish (self, res, &error);
    if (!update_settings) {
        mm_obj_dbg (self, "couldn't load update settings: %s", error->message);
        g_error_free (error);
        goto out;
    }

    /* If the plugin didn't specify custom device ids, add the default ones ourselves */
    if (!mm_firmware_update_settings_get_device_ids (update_settings)) {
        mm_obj_dbg (self, "No device ids set by plugin, adding generic ids");
        ids = mm_iface_firmware_build_generic_device_ids (self, &error);
        if (error) {
            mm_obj_warn (self, "couldn't build device ids: %s", error->message);
            g_error_free (error);
            g_clear_object (&update_settings);
            goto out;
        }

        mm_firmware_update_settings_set_device_ids (update_settings, (const gchar **)ids->pdata);
    }

    /* If the plugin didn't specify custom version, add the default one ourselves */
    if (!mm_firmware_update_settings_get_version (update_settings) &&
        !add_generic_version (MM_BASE_MODEM (self), update_settings, &error)) {
        mm_obj_warn (self, "couldn't set version: %s", error->message);
        g_error_free (error);
        g_clear_object (&update_settings);
        goto out;
    }

out:
    if (update_settings) {
        variant = mm_firmware_update_settings_get_variant (update_settings);
        g_object_unref (update_settings);
    }
    mm_gdbus_modem_firmware_set_update_settings (ctx->skeleton, variant);
    if (variant)
        g_variant_unref (variant);

    /* Go on to next step */
    ctx->step++;
    interface_initialization_step (task);
}

static void
interface_initialization_step (GTask *task)
{
    MMIfaceModemFirmware *self;
    InitializationContext *ctx;

    /* Don't run new steps if we're cancelled */
    if (g_task_return_error_if_cancelled (task)) {
        g_object_unref (task);
        return;
    }

    self = g_task_get_source_object (task);
    ctx = g_task_get_task_data (task);

    switch (ctx->step) {
    case INITIALIZATION_STEP_FIRST:
        ctx->step++;
        /* fall through */

    case INITIALIZATION_STEP_UPDATE_SETTINGS:
        if (MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_update_settings &&
            MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_update_settings_finish) {
            MM_IFACE_MODEM_FIRMWARE_GET_IFACE (self)->load_update_settings (
                self,
                (GAsyncReadyCallback)load_update_settings_ready,
                task);
            return;
        }
        ctx->step++;
        /* fall through */

    case INITIALIZATION_STEP_LAST:
        /* We are done without errors! */

        /* Handle method invocations */
        g_object_connect (ctx->skeleton,
                          "signal::handle-list",   G_CALLBACK (handle_list),   self,
                          "signal::handle-select", G_CALLBACK (handle_select), self,
                          NULL);

        /* Finally, export the new interface */
        mm_gdbus_object_skeleton_set_modem_firmware (MM_GDBUS_OBJECT_SKELETON (self),
                                                     MM_GDBUS_MODEM_FIRMWARE (ctx->skeleton));

        g_task_return_boolean (task, TRUE);
        g_object_unref (task);
        return;

    default:
        break;
    }

    g_assert_not_reached ();
}

void
mm_iface_modem_firmware_initialize (MMIfaceModemFirmware *self,
                                    GCancellable         *cancellable,
                                    GAsyncReadyCallback   callback,
                                    gpointer              user_data)
{
    InitializationContext *ctx;
    MmGdbusModemFirmware  *skeleton = NULL;
    GTask                 *task;

    /* Did we already create it? */
    g_object_get (self,
                  MM_IFACE_MODEM_FIRMWARE_DBUS_SKELETON, &skeleton,
                  NULL);
    if (!skeleton) {
        skeleton = mm_gdbus_modem_firmware_skeleton_new ();
        g_object_set (self,
                      MM_IFACE_MODEM_FIRMWARE_DBUS_SKELETON, skeleton,
                      NULL);
    }

    /* Perform async initialization here */
    ctx = g_new0 (InitializationContext, 1);
    ctx->step = INITIALIZATION_STEP_FIRST;
    ctx->skeleton = skeleton;

    task = g_task_new (self, cancellable, callback, user_data);
    g_task_set_task_data (task, ctx, (GDestroyNotify)initialization_context_free);

    interface_initialization_step (task);
}

void
mm_iface_modem_firmware_shutdown (MMIfaceModemFirmware *self)
{
    g_return_if_fail (MM_IS_IFACE_MODEM_FIRMWARE (self));

    /* Unexport DBus interface and remove the skeleton */
    mm_gdbus_object_skeleton_set_modem_firmware (MM_GDBUS_OBJECT_SKELETON (self), NULL);
    g_object_set (self,
                  MM_IFACE_MODEM_FIRMWARE_DBUS_SKELETON, NULL,
                  NULL);
}

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

static void
mm_iface_modem_firmware_default_init (MMIfaceModemFirmwareInterface *iface)
{
    static gsize initialized = 0;

    if (!g_once_init_enter (&initialized))
        return;

    /* Properties */
    g_object_interface_install_property (
        iface,
        g_param_spec_object (MM_IFACE_MODEM_FIRMWARE_DBUS_SKELETON,
                             "Firmware DBus skeleton",
                             "DBus skeleton for the Firmware interface",
                             MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON,
                             G_PARAM_READWRITE));

    g_object_interface_install_property (
        iface,
        g_param_spec_boolean (MM_IFACE_MODEM_FIRMWARE_IGNORE_CARRIER,
                              "Ignore carrier info in firmware details",
                              "Whether carrier info (version, name) should be ignored when showing the firmware details",
                              FALSE,
                              G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));

    g_once_init_leave (&initialized, 1);
}