/* GStreamer
 * Copyright (C) 2008 Nokia Corporation. (contact <stefan.kost@nokia.com>)
 * Copyright (C) 2010 Thiago Santos <thiago.sousa.santos@collabora.co.uk>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include <gst/check/gstcheck.h>
#include <glib/gstdio.h>

static GstTagList *received_tags = NULL;

static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
  GMainLoop *loop = (GMainLoop *) data;

  switch (message->type) {
    case GST_MESSAGE_EOS:
      g_main_loop_quit (loop);
      break;
    case GST_MESSAGE_WARNING:
    case GST_MESSAGE_ERROR:{
      GError *gerror;

      gchar *debug;

      gst_message_parse_error (message, &gerror, &debug);
      gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
      g_error_free (gerror);
      g_free (debug);
      g_main_loop_quit (loop);
      break;
    }
    case GST_MESSAGE_TAG:{
      if (received_tags == NULL) {
        gst_message_parse_tag (message, &received_tags);
      } else {
        GstTagList *tl = NULL, *ntl = NULL;

        gst_message_parse_tag (message, &tl);
        if (tl) {
          ntl = gst_tag_list_merge (received_tags, tl, GST_TAG_MERGE_PREPEND);
          if (ntl) {
            GST_LOG ("taglists merged: %" GST_PTR_FORMAT, ntl);
            gst_tag_list_unref (received_tags);
            received_tags = ntl;
          }
          gst_tag_list_unref (tl);
        }
      }
      break;
    }
    default:
      break;
  }

  return TRUE;
}

/*
 * Creates a pipeline in the form:
 * fakesrc num-buffers=1 ! caps ! muxer ! filesink location=file
 *
 * And sets the tags in tag_str into the muxer via tagsetter.
 */
static void
test_mux_tags (const gchar * tag_str, const gchar * caps,
    const gchar * muxer, const gchar * file)
{
  GstElement *pipeline;
  GstBus *bus;
  GMainLoop *loop;
  GstTagList *sent_tags;
  GstElement *mux;
  GstTagSetter *setter;
  gchar *launch_str;
  guint bus_watch = 0;

  GST_DEBUG ("testing xmp muxing on : %s", muxer);

  launch_str =
      g_strdup_printf ("fakesrc num-buffers=1 format=time datarate=100 ! "
      "%s ! %s name=mux ! filesink location=%s name=sink", caps, muxer, file);
  pipeline = gst_parse_launch (launch_str, NULL);
  g_free (launch_str);
  fail_unless (pipeline != NULL);

  mux = gst_bin_get_by_name (GST_BIN (pipeline), "mux");
  fail_unless (mux != NULL);

  loop = g_main_loop_new (NULL, TRUE);
  fail_unless (loop != NULL);

  bus = gst_element_get_bus (pipeline);
  fail_unless (bus != NULL);
  bus_watch = gst_bus_add_watch (bus, bus_handler, loop);
  gst_object_unref (bus);

  gst_element_set_state (pipeline, GST_STATE_READY);

  setter = GST_TAG_SETTER (mux);
  fail_unless (setter != NULL);
  sent_tags = gst_tag_list_new_from_string (tag_str);
  fail_unless (sent_tags != NULL);
  gst_tag_setter_merge_tags (setter, sent_tags, GST_TAG_MERGE_REPLACE);
  gst_tag_list_unref (sent_tags);

  gst_element_set_state (pipeline, GST_STATE_PLAYING);
  g_main_loop_run (loop);

  gst_element_set_state (pipeline, GST_STATE_NULL);

  g_main_loop_unref (loop);
  g_object_unref (mux);
  g_object_unref (pipeline);
  g_source_remove (bus_watch);
}

/*
 * Makes a pipeline in the form:
 * filesrc location=file ! demuxer ! fakesink
 *
 * And gets the tags that are posted on the bus to compare
 * with the tags in 'tag_str'
 */
static void
test_demux_tags (const gchar * tag_str, const gchar * demuxer,
    const gchar * file)
{
  GstElement *pipeline;
  GstBus *bus;
  GMainLoop *loop;
  GstTagList *sent_tags;
  gint i, j, k, n_recv, n_sent;
  const gchar *name_sent, *name_recv;
  const GValue *value_sent, *value_recv;
  gboolean found;
  gint comparison;
  GstElement *demux;
  gchar *launch_str;
  guint bus_watch = 0;

  GST_DEBUG ("testing tags : %s", tag_str);

  if (received_tags) {
    gst_tag_list_unref (received_tags);
    received_tags = NULL;
  }

  launch_str = g_strdup_printf ("filesrc location=%s ! %s name=demux ! "
      "fakesink", file, demuxer);
  pipeline = gst_parse_launch (launch_str, NULL);
  g_free (launch_str);
  fail_unless (pipeline != NULL);

  demux = gst_bin_get_by_name (GST_BIN (pipeline), "demux");
  fail_unless (demux != NULL);

  loop = g_main_loop_new (NULL, TRUE);
  fail_unless (loop != NULL);

  bus = gst_element_get_bus (pipeline);
  fail_unless (bus != NULL);
  bus_watch = gst_bus_add_watch (bus, bus_handler, loop);
  gst_object_unref (bus);

  sent_tags = gst_tag_list_new_from_string (tag_str);
  fail_unless (sent_tags != NULL);

  gst_element_set_state (pipeline, GST_STATE_PLAYING);
  g_main_loop_run (loop);

  GST_DEBUG ("mainloop done : %p", received_tags);

  /* verify tags */
  fail_unless (received_tags != NULL);
  n_recv = gst_tag_list_n_tags (received_tags);
  n_sent = gst_tag_list_n_tags (sent_tags);
  fail_unless (n_recv >= n_sent);
  /* FIXME: compare taglits values */
  for (i = 0; i < n_sent; i++) {
    name_sent = gst_tag_list_nth_tag_name (sent_tags, i);

    found = FALSE;
    for (j = 0; j < n_recv; j++) {
      name_recv = gst_tag_list_nth_tag_name (received_tags, j);

      if (!strcmp (name_sent, name_recv)) {
        guint sent_len, recv_len;

        sent_len = gst_tag_list_get_tag_size (sent_tags, name_sent);
        recv_len = gst_tag_list_get_tag_size (received_tags, name_recv);

        fail_unless (sent_len == recv_len,
            "tag item %s has been received with different size", name_sent);

        for (k = 0; k < sent_len; k++) {
          value_sent = gst_tag_list_get_value_index (sent_tags, name_sent, k);
          value_recv =
              gst_tag_list_get_value_index (received_tags, name_recv, k);

          comparison = gst_value_compare (value_sent, value_recv);
          if (comparison != GST_VALUE_EQUAL) {
            gchar *vs = g_strdup_value_contents (value_sent);
            gchar *vr = g_strdup_value_contents (value_recv);
            GST_DEBUG ("sent = %s:'%s', recv = %s:'%s'",
                G_VALUE_TYPE_NAME (value_sent), vs,
                G_VALUE_TYPE_NAME (value_recv), vr);
            g_free (vs);
            g_free (vr);
          }
          fail_unless (comparison == GST_VALUE_EQUAL,
              "tag item %s has been received with different type or value",
              name_sent);
          found = TRUE;
          break;
        }
      }
    }
    fail_unless (found, "tag item %s is lost", name_sent);
  }

  gst_tag_list_unref (received_tags);
  received_tags = NULL;
  gst_tag_list_unref (sent_tags);

  gst_element_set_state (pipeline, GST_STATE_NULL);

  g_main_loop_unref (loop);
  g_object_unref (demux);
  g_object_unref (pipeline);
  g_source_remove (bus_watch);
}

/*
 * Tests if the muxer/demuxer pair can serialize the tags in 'tag_str'
 * to a file and recover them correctly.
 *
 * 'caps' are used to assure the muxer accepts the fake buffer fakesrc
 * will send to it.
 */
static void
test_tags (const gchar * tag_str, const gchar * caps, const gchar * muxer,
    const gchar * demuxer)
{
  gchar *tmpfile;
  gchar *tmpdir;

  tmpdir = g_dir_make_tmp ("gst-check-good-XXXXXX", NULL);
  fail_unless (tmpdir != NULL);
  tmpfile = g_build_filename (tmpdir, "tagschecking-xmp", NULL);

  GST_DEBUG ("testing tags : %s", tag_str);
  test_mux_tags (tag_str, caps, muxer, tmpfile);
  test_demux_tags (tag_str, demuxer, tmpfile);
  g_unlink (tmpfile);
  g_rmdir (tmpdir);
  g_free (tmpfile);
  g_free (tmpdir);
}

#define H264_CAPS "video/x-h264, width=(int)320, height=(int)240," \
                  " framerate=(fraction)30/1, codec_data=(buffer)" \
                  "01401592ffe10017674d401592540a0fd8088000000300" \
                  "8000001e478b175001000468ee3c80, "\
                  "stream-format=(string)avc, alignment=(string)au"

#define COMMON_TAGS \
    "taglist,title=test_title,"    \
    "artist=test_artist,"          \
    "keywords=\"key1,key2\","      \
    "description=test_desc"

GST_START_TEST (test_common_tags)
{
  if (!gst_registry_check_feature_version (gst_registry_get (), "qtdemux", 0,
          10, 23)) {
    GST_INFO ("Skipping test, qtdemux either not available or too old");
    return;
  }
  test_tags (COMMON_TAGS, H264_CAPS, "qtmux", "qtdemux");
  test_tags (COMMON_TAGS, H264_CAPS, "mp4mux", "qtdemux");
  test_tags (COMMON_TAGS, H264_CAPS, "3gppmux", "qtdemux");
}

GST_END_TEST;

#define GEO_LOCATION_TAGS \
    "taglist,geo-location-country=Brazil,"    \
      "geo-location-city=\"Campina Grande\"," \
      "geo-location-sublocation=Bodocongo,"   \
      "geo-location-latitude=-12.125,"        \
      "geo-location-longitude=56.75,"         \
      "geo-location-elevation=327.5"

GST_START_TEST (test_geo_location_tags)
{
  if (!gst_registry_check_feature_version (gst_registry_get (), "qtdemux", 0,
          10, 23)) {
    GST_INFO ("Skipping test, qtdemux either not available or too old");
    return;
  }
  test_tags (GEO_LOCATION_TAGS, H264_CAPS, "qtmux", "qtdemux");
  test_tags (GEO_LOCATION_TAGS, H264_CAPS, "mp4mux", "qtdemux");
  test_tags (GEO_LOCATION_TAGS, H264_CAPS, "3gppmux", "qtdemux");
}

GST_END_TEST;


#define USER_TAGS \
    "taglist,user-rating=(uint)85"

GST_START_TEST (test_user_tags)
{
  if (!gst_registry_check_feature_version (gst_registry_get (), "qtdemux", 0,
          10, 23)) {
    GST_INFO ("Skipping test, qtdemux either not available or too old");
    return;
  }

  test_tags (USER_TAGS, H264_CAPS, "qtmux", "qtdemux");
  test_tags (USER_TAGS, H264_CAPS, "mp4mux", "qtdemux");
  test_tags (USER_TAGS, H264_CAPS, "3gppmux", "qtdemux");
}

GST_END_TEST;

static Suite *
metadata_suite (void)
{
  Suite *s = suite_create ("tagschecking");

  TCase *tc_chain = tcase_create ("general");

  /* time out after 60s, not the default 3 */
  tcase_set_timeout (tc_chain, 60);

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_common_tags);
  tcase_add_test (tc_chain, test_geo_location_tags);
  tcase_add_test (tc_chain, test_user_tags);

  return s;
}

GST_CHECK_MAIN (metadata);