/* Copyright 2016 The ChromiumOS Authors

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#include "cras/src/server/cras_bt_player.h"

#include <dbus/dbus.h>

#include <errno.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <syslog.h>

#include "cras/src/server/cras_bt_adapter.h"

#include "cras/src/server/cras_bt_constants.h"

#include "cras/src/server/cras_dbus_util.h"

#include "cras/src/server/cras_utf8.h"

#include "third_party/strlcpy/strlcpy.h"

/* Object to hold current metadata. This is not a full list of what BlueZ/MPRIS

 * supports but a subset because Chromium only provides the following.

 */

struct cras_bt_player_metadata {

  char title[CRAS_PLAYER_METADATA_SIZE_MAX];

  char artist[CRAS_PLAYER_METADATA_SIZE_MAX];

  char album[CRAS_PLAYER_METADATA_SIZE_MAX];

  int64_t length;

};

/* Object to register as media player so that bluetoothd will report hardware

 * volume from device through bt_transport. Properties of the player are defined

 * in BlueZ's media API.

 */

struct cras_bt_player {

  const char* object_path;

  char* playback_status;

  char* identity;

  const char* loop_status;

  struct cras_bt_player_metadata* metadata;

  int64_t position;

  bool can_go_next;

  bool can_go_prev;

  bool can_play;

  bool can_pause;

  bool can_control;

  bool shuffle;

  void (*message_cb)(const char* message);

};

static void cras_bt_on_player_registered(DBusPendingCall* pending_call,

                                         void* data) {

  DBusMessage* reply;

  reply = dbus_pending_call_steal_reply(pending_call);

  dbus_pending_call_unref(pending_call);

  if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {

    syslog(LOG_WARNING, "RegisterPlayer returned error: %s",

           dbus_message_get_error_name(reply));

    dbus_message_unref(reply);

    return;

  }

  dbus_message_unref(reply);

}

/* Note that player properties will be used mostly for AVRCP qualification and

 * not for normal use cases. The corresponding media events won't be routed by

 * CRAS until we have a plan to provide general system API to handle media

 * control.

 */

static struct cras_bt_player player = {

    .object_path = CRAS_DEFAULT_PLAYER,

    .playback_status = NULL,

    .identity = NULL,

    .loop_status = "None",

    .shuffle = 0,

    .metadata = NULL,

    .position = 0,

    .can_go_next = 0,

    .can_go_prev = 0,

    .can_play = 0,

    .can_pause = 0,

    .can_control = 0,

    .message_cb = NULL,

};

int cras_bt_register_player(DBusConnection* conn,

                            const struct cras_bt_adapter* adapter) {

  const char* adapter_path;

  DBusMessage* method_call;

  DBusMessageIter message_iter, dict;

  DBusPendingCall* pending_call;

  adapter_path = cras_bt_adapter_object_path(adapter);

  method_call = dbus_message_new_method_call(

      BLUEZ_SERVICE, adapter_path, BLUEZ_INTERFACE_MEDIA, "RegisterPlayer");

  if (!method_call) {

    return -ENOMEM;

  }

  dbus_message_iter_init_append(method_call, &message_iter);

  dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_OBJECT_PATH,

                                 &player.object_path);

  dbus_message_iter_open_container(

      &message_iter, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &dict);

  append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &player.playback_status);

  append_key_value(&dict, "Identity", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &player.identity);

  append_key_value(&dict, "LoopStatus", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &player.loop_status);

  append_key_value(&dict, "Position", DBUS_TYPE_INT64,

                   DBUS_TYPE_INT64_AS_STRING, &player.position);

  append_key_value(&dict, "Shuffle", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.shuffle);

  append_key_value(&dict, "CanGoNext", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.can_go_next);

  append_key_value(&dict, "CanGoPrevious", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.can_go_prev);

  append_key_value(&dict, "CanPlay", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.can_play);

  append_key_value(&dict, "CanPause", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.can_pause);

  append_key_value(&dict, "CanControl", DBUS_TYPE_BOOLEAN,

                   DBUS_TYPE_BOOLEAN_AS_STRING, &player.can_control);

  dbus_message_iter_close_container(&message_iter, &dict);

  if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,

                                       DBUS_TIMEOUT_USE_DEFAULT)) {

    dbus_message_unref(method_call);

    return -ENOMEM;

  }

  dbus_message_unref(method_call);

  if (!pending_call) {

    return -EIO;

  }

  if (!dbus_pending_call_set_notify(pending_call, cras_bt_on_player_registered,

                                    &player, NULL)) {

    dbus_pending_call_cancel(pending_call);

    dbus_pending_call_unref(pending_call);

    return -ENOMEM;

  }

  return 0;

}

static void cras_bt_on_player_unregistered(DBusPendingCall* pending_call,

                                           void* data) {

  DBusMessage* reply;

  reply = dbus_pending_call_steal_reply(pending_call);

  dbus_pending_call_unref(pending_call);

  if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {

    syslog(LOG_WARNING, "UnregisterPlayer returned error: %s",

           dbus_message_get_error_name(reply));

  }

  dbus_message_unref(reply);

}

int cras_bt_unregister_player(DBusConnection* conn,

                              const struct cras_bt_adapter* adapter) {

  const char* adapter_path;

  DBusMessage* method_call;

  DBusPendingCall* pending_call;

  adapter_path = cras_bt_adapter_object_path(adapter);

  method_call = dbus_message_new_method_call(

      BLUEZ_SERVICE, adapter_path, BLUEZ_INTERFACE_MEDIA, "UnregisterPlayer");

  if (!method_call) {

    return -ENOMEM;

  }

  if (!dbus_message_append_args(method_call, DBUS_TYPE_OBJECT_PATH,

                                &player.object_path, DBUS_TYPE_INVALID)) {

    dbus_message_unref(method_call);

    return -ENOMEM;

  }

  if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,

                                       DBUS_TIMEOUT_USE_DEFAULT)) {

    dbus_message_unref(method_call);

    return -ENOMEM;

  }

  dbus_message_unref(method_call);

  if (!pending_call) {

    return -EIO;

  }

  if (!dbus_pending_call_set_notify(

          pending_call, cras_bt_on_player_unregistered, &player, NULL)) {

    dbus_pending_call_cancel(pending_call);

    dbus_pending_call_unref(pending_call);

    return -ENOMEM;

  }

  return 0;

}

static DBusHandlerResult cras_bt_player_handle_message(DBusConnection* conn,

                                                       DBusMessage* message,

                                                       void* arg) {

  const char* msg = dbus_message_get_member(message);

  if (player.message_cb) {

    player.message_cb(msg);

  }

  return DBUS_HANDLER_RESULT_HANDLED;

}

static int cras_bt_player_init() {

  player.playback_status = calloc(1, CRAS_PLAYER_PLAYBACK_STATUS_SIZE_MAX);

  if (!player.playback_status) {

    return -ENOMEM;

  }

  player.identity = calloc(1, CRAS_PLAYER_IDENTITY_SIZE_MAX);

  if (!player.identity) {

    goto nomem;

  }

  strlcpy(player.playback_status, CRAS_PLAYER_PLAYBACK_STATUS_DEFAULT,

          CRAS_PLAYER_PLAYBACK_STATUS_SIZE_MAX);

  strlcpy(player.identity, CRAS_PLAYER_IDENTITY_DEFAULT,

          CRAS_PLAYER_IDENTITY_SIZE_MAX);

  player.position = 0;

  player.metadata = calloc(1, sizeof(*(player.metadata)));

  if (!player.metadata) {

    goto nomem;

  }

  return 0;

nomem:

  free(player.playback_status);

  free(player.identity);

  return -ENOMEM;

}

static void cras_bt_player_append_metadata_artist(DBusMessageIter* iter,

                                                  const char* artist) {

  DBusMessageIter dict, variant, array;

  const char* artist_key = "xesam:artist";

  dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict);

  dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &artist_key);

  dbus_message_iter_open_container(

      &dict, DBUS_TYPE_VARIANT,

      DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &variant);

  dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,

                                   DBUS_TYPE_STRING_AS_STRING, &array);

  dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &artist);

  dbus_message_iter_close_container(&variant, &array);

  dbus_message_iter_close_container(&dict, &variant);

  dbus_message_iter_close_container(iter, &dict);

}

static void cras_bt_player_append_metadata(DBusMessageIter* iter,

                                           const char* title,

                                           const char* artist,

                                           const char* album,

                                           dbus_int64_t length) {

  DBusMessageIter variant, array;

  dbus_message_iter_open_container(

      iter, DBUS_TYPE_VARIANT,

      DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING

          DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING

              DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &variant);

  dbus_message_iter_open_container(

      &variant, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &array);

  if (!is_utf8_string(title)) {

    syslog(LOG_DEBUG, "Non-utf8 title: %s", title);

    title = "";

  }

  if (!is_utf8_string(album)) {

    syslog(LOG_DEBUG, "Non-utf8 album: %s", album);

    album = "";

  }

  if (!is_utf8_string(artist)) {

    syslog(LOG_DEBUG, "Non-utf8 artist: %s", artist);

    artist = "";

  }

  append_key_value(&array, "xesam:title", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &title);

  append_key_value(&array, "xesam:album", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &album);

  append_key_value(&array, "mpris:length", DBUS_TYPE_INT64,

                   DBUS_TYPE_INT64_AS_STRING, &length);

  cras_bt_player_append_metadata_artist(&array, artist);

  dbus_message_iter_close_container(&variant, &array);

  dbus_message_iter_close_container(iter, &variant);

}

static bool cras_bt_player_parse_metadata(const char* title,

                                          const char* album,

                                          const char* artist,

                                          const dbus_int64_t length) {

  bool require_update = false;

  if (title && strcmp(player.metadata->title, title)) {

    snprintf(player.metadata->title, CRAS_PLAYER_METADATA_SIZE_MAX, "%s",

             title);

    require_update = true;

  }

  if (artist && strcmp(player.metadata->artist, artist)) {

    snprintf(player.metadata->artist, CRAS_PLAYER_METADATA_SIZE_MAX, "%s",

             artist);

    require_update = true;

  }

  if (album && strcmp(player.metadata->album, album)) {

    snprintf(player.metadata->album, CRAS_PLAYER_METADATA_SIZE_MAX, "%s",

             album);

    require_update = true;

  }

  if (length && player.metadata->length != length) {

    player.metadata->length = length;

    require_update = true;

  }

  return require_update;

}

int cras_bt_player_create(DBusConnection* conn) {

  static const DBusObjectPathVTable player_vtable = {

      .message_function = cras_bt_player_handle_message};

  DBusError dbus_error;

  struct cras_bt_adapter** adapters;

  size_t num_adapters, i;

  int ret;

  ret = cras_bt_player_init();

  if (ret < 0) {

    return ret;

  }

  dbus_error_init(&dbus_error);

  if (!dbus_connection_register_object_path(conn, player.object_path,

                                            &player_vtable, &dbus_error)) {

    syslog(LOG_WARNING, "Cannot register player %s", player.object_path);

    dbus_error_free(&dbus_error);

    return -ENOMEM;

  }

  num_adapters = cras_bt_adapter_get_list(&adapters);

  for (i = 0; i < num_adapters; ++i) {

    cras_bt_register_player(conn, adapters[i]);

  }

  free(adapters);

  return 0;

}

int cras_bt_player_destroy(DBusConnection* conn) {

  struct cras_bt_adapter** adapters;

  size_t num_adapters, i;

  num_adapters = cras_bt_adapter_get_list(&adapters);

  for (i = 0; i < num_adapters; ++i) {

    cras_bt_unregister_player(conn, adapters[i]);

  }

  free(adapters);

  return dbus_connection_unregister_object_path(conn, player.object_path);

}

int cras_bt_player_update_playback_status(DBusConnection* conn,

                                          const char* status) {

  DBusMessage* msg;

  DBusMessageIter iter, dict;

  const char* playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

  if (!player.playback_status) {

    return -ENXIO;

  }

  /* Verify the string value matches one of the possible status defined in

   * bluez/profiles/audio/avrcp.c

   */

  if (strcasecmp(status, "stopped") != 0 &&

      strcasecmp(status, "playing") != 0 && strcasecmp(status, "paused") != 0 &&

      strcasecmp(status, "forward-seek") != 0 &&

      strcasecmp(status, "reverse-seek") != 0 &&

      strcasecmp(status, "error") != 0) {

    return -EINVAL;

  }

  if (!strcasecmp(player.playback_status, status)) {

    return 0;

  }

  strlcpy(player.playback_status, status, CRAS_PLAYER_PLAYBACK_STATUS_SIZE_MAX);

  msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER, DBUS_INTERFACE_PROPERTIES,

                                "PropertiesChanged");

  if (!msg) {

    return -ENOMEM;

  }

  dbus_message_iter_init_append(msg, &iter);

  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &playerInterface);

  dbus_message_iter_open_container(

      &iter, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &dict);

  append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &status);

  dbus_message_iter_close_container(&iter, &dict);

  if (!dbus_connection_send(conn, msg, NULL)) {

    dbus_message_unref(msg);

    return -ENOMEM;

  }

  dbus_message_unref(msg);

  return 0;

}

int cras_bt_player_update_identity(DBusConnection* conn, const char* identity) {

  DBusMessage* msg;

  DBusMessageIter iter, dict;

  const char* playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

  if (!player.identity) {

    return -ENXIO;

  }

  if (!identity) {

    return -EINVAL;

  }

  if (strnlen(identity, CRAS_PLAYER_IDENTITY_SIZE_MAX - 1) ==

      CRAS_PLAYER_IDENTITY_SIZE_MAX - 1) {

    syslog(LOG_WARNING, "Identity is too long, using default");

    identity = CRAS_PLAYER_IDENTITY_DEFAULT;

  }

  if (!is_utf8_string(identity)) {

    syslog(LOG_DEBUG, "Non-utf8 identity: %s", identity);

    identity = "";

  }

  if (!strcasecmp(player.identity, identity)) {

    return 0;

  }

  strlcpy(player.identity, identity, CRAS_PLAYER_IDENTITY_SIZE_MAX);

  msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER, DBUS_INTERFACE_PROPERTIES,

                                "PropertiesChanged");

  if (!msg) {

    return -ENOMEM;

  }

  dbus_message_iter_init_append(msg, &iter);

  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &playerInterface);

  dbus_message_iter_open_container(

      &iter, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &dict);

  append_key_value(&dict, "Identity", DBUS_TYPE_STRING,

                   DBUS_TYPE_STRING_AS_STRING, &identity);

  dbus_message_iter_close_container(&iter, &dict);

  if (!dbus_connection_send(conn, msg, NULL)) {

    dbus_message_unref(msg);

    return -ENOMEM;

  }

  dbus_message_unref(msg);

  return 0;

}

int cras_bt_player_update_position(DBusConnection* conn,

                                   const dbus_int64_t position) {

  DBusMessage* msg;

  DBusMessageIter iter, dict;

  const char* playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

  if (position < 0) {

    return -EINVAL;

  }

  player.position = position;

  msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER, DBUS_INTERFACE_PROPERTIES,

                                "PropertiesChanged");

  if (!msg) {

    return -ENOMEM;

  }

  dbus_message_iter_init_append(msg, &iter);

  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &playerInterface);

  dbus_message_iter_open_container(

      &iter, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &dict);

  append_key_value(&dict, "Position", DBUS_TYPE_INT64,

                   DBUS_TYPE_INT64_AS_STRING, &player.position);

  dbus_message_iter_close_container(&iter, &dict);

  if (!dbus_connection_send(conn, msg, NULL)) {

    dbus_message_unref(msg);

    return -ENOMEM;

  }

  dbus_message_unref(msg);

  return 0;

}

int cras_bt_player_update_metadata(DBusConnection* conn,

                                   const char* title,

                                   const char* artist,

                                   const char* album,

                                   const dbus_int64_t length) {

  DBusMessage* msg;

  DBusMessageIter iter, array, dict;

  const char* property = "Metadata";

  const char* playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

  if (!player.metadata) {

    return -ENXIO;

  }

  msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER, DBUS_INTERFACE_PROPERTIES,

                                "PropertiesChanged");

  if (!msg) {

    return -ENOMEM;

  }

  dbus_message_iter_init_append(msg, &iter);

  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &playerInterface);

  dbus_message_iter_open_container(

      &iter, DBUS_TYPE_ARRAY,

      DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING

          DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,

      &array);

  dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &dict);

  dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &property);

  if (!cras_bt_player_parse_metadata(title, album, artist, length)) {

    // Nothing to update.

    dbus_message_unref(msg);

    return 0;

  }

  cras_bt_player_append_metadata(

      &dict, player.metadata->title, player.metadata->artist,

      player.metadata->album, player.metadata->length);

  dbus_message_iter_close_container(&array, &dict);

  dbus_message_iter_close_container(&iter, &array);

  if (!dbus_connection_send(conn, msg, NULL)) {

    dbus_message_unref(msg);

    return -ENOMEM;

  }

  dbus_message_unref(msg);

  return 0;

}