/*
 * Copyright (C) 2010 Igalia S.L.
 *
 * Contact: mswl-dm-2009@igalia.com
 *
 * This library 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; version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser 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 <math.h>

#include "jmp-mplayer.h"
#include "jmp-marshal.h"

#define INITIAL_VOLUME 1.0
#define TICK_INTERVAL 200

G_DEFINE_TYPE (JmpMplayer, jmp_mplayer, G_TYPE_OBJECT)

enum {
        PROP_0,
        PROP_URI,
        PROP_VOLUME
};

enum {
        END_OF_STREAM,
        ERROR,
        PLAYBACK_TICK,
        LAST_SIGNAL
};

static guint
jmp_mplayer_signals[LAST_SIGNAL] = { 0 };

#define GET_PRIVATE(o) \
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), JMP_TYPE_MPLAYER, JmpMplayerPrivate))

struct _JmpMplayerPrivate {
        gchar *uri;
        GstElement *element;
        gboolean playing;
};

static gchar*
get_error_message (GstMessage *message)
{
        GError *error = NULL;
        gchar *debug_info = NULL;
        gchar *error_message = NULL;

        gst_message_parse_error (message, &error, &debug_info);
        error_message = g_strdup_printf ("%s\n\t%s", error->message,
                                         (debug_info) ? debug_info : "none");

        g_error_free (error);
        g_free (debug_info);
        return error_message;
}

static void
check_element_state (JmpMplayer *self)
{
        GstState current_state;
        GstState next_state;
        GstStateChangeReturn change_return;
        change_return = gst_element_get_state (self->priv->element,
                        &current_state, &next_state, GST_CLOCK_TIME_NONE);
        g_message ("Return: %s\n",
                   gst_element_state_change_return_get_name (change_return));
        g_message ("Current state: %s\n",
                   gst_element_state_get_name (current_state));
        g_message ("Next state: %s\n",
                   gst_element_state_get_name (next_state));
}

static gboolean
message_received_callback (GstBus *bus,
                           GstMessage *message,
                           gpointer data)
{
        JmpMplayer *self = JMP_MPLAYER (data);
        gchar *error_message = NULL;

        switch (GST_MESSAGE_TYPE (message)) {
        case GST_MESSAGE_EOS:
                g_signal_emit (self, jmp_mplayer_signals[END_OF_STREAM], 0);
                break;
        case GST_MESSAGE_ERROR:
                error_message = get_error_message (message);
                g_signal_emit (self, jmp_mplayer_signals[ERROR], 0,
                               error_message);
                g_free (error_message);
                break;
        default:
                /* unhandled messages */
                break;
        }
}

static void
jmp_mplayer_make_playbin (JmpMplayer *self)
{
        g_return_if_fail (JMP_IS_MPLAYER (self) && !self->priv->element);

        self->priv->element = gst_element_factory_make ("playbin2", "mainplayer");
        g_assert (self->priv->element);
        jmp_mplayer_set_volume (self, INITIAL_VOLUME);

        GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE (self->priv->element));
        gst_bus_add_watch (bus, message_received_callback, self);
        gst_object_unref (bus);
}

static gboolean
jmp_mplayer_emit_tick (gpointer data)
{
        JmpMplayer *self = JMP_MPLAYER (data);
        gint64 position, duration;

        if (jmp_mplayer_get_position (self, &position) &&
                        jmp_mplayer_get_duration (self, &duration)) {

                g_signal_emit (self, jmp_mplayer_signals[PLAYBACK_TICK], 0, position, duration);

        }

        return self->priv->playing;
}

static void
jmp_mplayer_get_property (GObject *object, guint property_id,
                         GValue *value, GParamSpec *pspec)
{
        JmpMplayer *self = JMP_MPLAYER (object);

        switch (property_id) {
        case PROP_URI:
                g_value_set_string (value, self->priv->uri);
                break;
        case PROP_VOLUME:
                g_value_set_double (value, jmp_mplayer_get_volume (self));
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
        }
}

static void
jmp_mplayer_set_property (GObject *object, guint property_id,
                         const GValue *value, GParamSpec *pspec)
{
        JmpMplayer *self = JMP_MPLAYER (object);

        switch (property_id) {
        case PROP_URI:
                jmp_mplayer_set_uri (self, g_value_get_string (value));
                break;
        case PROP_VOLUME:
                jmp_mplayer_set_volume (self, g_value_get_double (value));
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
        }
}

static void
jmp_mplayer_finalize (GObject *object)
{
        JmpMplayer *self = JMP_MPLAYER (object);

        if (self->priv->element) {
                gst_element_set_state (self->priv->element, GST_STATE_NULL);
                gst_object_unref (GST_OBJECT (self->priv->element));
        }

        if (self->priv->uri)
                g_free (self->priv->uri);

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

static void
jmp_mplayer_class_init (JmpMplayerClass *klass)
{
        GObjectClass *object_class = G_OBJECT_CLASS (klass);

        g_type_class_add_private (klass, sizeof (JmpMplayerPrivate));

        object_class->get_property = jmp_mplayer_get_property;
        object_class->set_property = jmp_mplayer_set_property;
        object_class->finalize = jmp_mplayer_finalize;

        g_object_class_install_property
                (object_class, PROP_URI,
                 g_param_spec_string ("uri", "Stream URI",
                                      "URI of the stream to playback",
                                      NULL,
                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

        g_object_class_install_property
                (object_class, PROP_VOLUME,
                 g_param_spec_double ("volume", "Playback volume",
                                 "Volume of the stream to playback",
                                 0.0,
                                 1.0,
                                 1.0,
                                 G_PARAM_READWRITE));

        jmp_mplayer_signals[END_OF_STREAM] =
                        g_signal_newv ("end-of-stream",
                                        G_TYPE_FROM_CLASS (klass),
                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
                                        NULL,
                                        NULL,
                                        NULL,
                                        g_cclosure_marshal_VOID__VOID,
                                        G_TYPE_NONE,
                                        0,
                                        NULL);

        jmp_mplayer_signals[ERROR] =
                        g_signal_new ("error",
                                        G_TYPE_FROM_CLASS (klass),
                                        G_SIGNAL_RUN_LAST,
                                        0,
                                        NULL,
                                        NULL,
                                        g_cclosure_marshal_VOID__STRING,
                                        G_TYPE_NONE,
                                        1,
                                        G_TYPE_STRING);

        jmp_mplayer_signals[PLAYBACK_TICK] =
                        g_signal_new ("playback-tick",
                                        G_TYPE_FROM_CLASS (klass),
                                        G_SIGNAL_RUN_LAST,
                                        0,
                                        NULL,
                                        NULL,
                                        jmp_marshal_VOID__INT64_INT64,
                                        G_TYPE_NONE,
                                        2,
                                        G_TYPE_INT64,
                                        G_TYPE_INT64,
                                        NULL);
}

static void
jmp_mplayer_init (JmpMplayer *self)
{
        self->priv = GET_PRIVATE (self);
        self->priv->uri = NULL;
        self->priv->element = NULL;
}

JmpMplayer*
jmp_mplayer_new (void)
{
        return g_object_new (JMP_TYPE_MPLAYER, NULL);
}

gboolean
jmp_mplayer_set_uri (JmpMplayer *self, const gchar *uri)
{
        g_return_val_if_fail (JMP_IS_MPLAYER(self), FALSE);

        if (self->priv->uri) {
                g_free (self->priv->uri);
        }

        if (self->priv->element) {
                gst_element_set_state (self->priv->element, GST_STATE_NULL);
        }

        if (uri) {
                self->priv->uri = g_strdup (uri);
                if (!self->priv->element) {
                        jmp_mplayer_make_playbin (self);
                }
                g_object_set (G_OBJECT (self->priv->element),
                              "uri", self->priv->uri, NULL);
        }
        return TRUE;
}

gboolean
jmp_mplayer_play (JmpMplayer *self)
{
        g_return_val_if_fail (JMP_IS_MPLAYER(self), FALSE);

        if (self->priv->element && !self->priv->playing) {
                gst_element_set_state (self->priv->element, GST_STATE_PLAYING);

                self->priv->playing = TRUE;
                g_timeout_add (TICK_INTERVAL, jmp_mplayer_emit_tick, self);

                return TRUE;
        }
        return FALSE;
}

gboolean
jmp_mplayer_stop (JmpMplayer *self)
{
        g_return_val_if_fail (JMP_IS_MPLAYER(self), FALSE);

        if (self->priv->element) {
                gst_element_set_state (self->priv->element, GST_STATE_NULL);

                self->priv->playing = FALSE;

                return TRUE;
        }
        return FALSE;
}

gboolean
jmp_mplayer_pause (JmpMplayer *self)
{
        g_return_val_if_fail (JMP_IS_MPLAYER(self), FALSE);

        if (self->priv->element) {
                gst_element_set_state (self->priv->element, GST_STATE_PAUSED);

                self->priv->playing = FALSE;

                return TRUE;
        }
        return FALSE;
}

gboolean
jmp_mplayer_set_volume (JmpMplayer *self, gdouble volume)
{
        g_return_val_if_fail (JMP_IS_MPLAYER(self), FALSE);

        g_return_val_if_fail (self->priv->element, FALSE);

        /* Volume range should be in the [0, 10] interval, according to
         * playbin2 documentation */
        if (volume > 10.0 || volume < 0.0)
                return FALSE;

        g_object_set (self->priv->element, "volume", volume, NULL);

        return TRUE;
}

gdouble
jmp_mplayer_get_volume (JmpMplayer *self)
{
        g_return_if_fail (JMP_IS_MPLAYER(self));

        g_return_if_fail (self->priv->element);
        gdouble volume;

        g_object_get (self->priv->element, "volume", &volume, NULL);
        return volume;
}

gboolean
jmp_mplayer_toggle_mute (JmpMplayer *self)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);

        gboolean mute;

        g_return_val_if_fail (self->priv->element, FALSE);
        g_object_get (self->priv->element, "mute", &mute, NULL);
        g_object_set (self->priv->element, "mute", !mute, NULL);

        return TRUE;
}

gboolean
jmp_mplayer_get_duration (JmpMplayer *self, gint64 *duration)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        GstFormat format = GST_FORMAT_TIME;
        return gst_element_query_duration (self->priv->element, &format, duration);
}

gboolean
jmp_mplayer_get_duration_string (JmpMplayer *self, gchar **duration)
{

        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        gint64 dur;

        if (jmp_mplayer_get_duration (self, &dur)) {
               *duration =  g_strdup_printf ("%" GST_TIME_FORMAT, GST_TIME_ARGS (dur));
               return TRUE;
        }

        return FALSE;
}

gboolean
jmp_mplayer_get_position (JmpMplayer *self, gint64 *position)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        GstFormat format = GST_FORMAT_TIME;
        return gst_element_query_position (self->priv->element, &format, position);
}

gboolean
jmp_mplayer_get_position_in_percentage (JmpMplayer *self, gdouble *position_percentage)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);
        g_return_val_if_fail (position_percentage, FALSE);

        GstFormat format = GST_FORMAT_PERCENT;
        gint64 position = 0, duration = 0;

        if (gst_element_query_position (self->priv->element,
                                        &format, &position)) {
                *position_percentage = (1.0 * position) / (1.0 * GST_FORMAT_PERCENT_MAX);
                return TRUE;
        } else {
                format = GST_FORMAT_TIME;

                if (gst_element_query_position (self->priv->element,
                                                &format, &position) &&
                    gst_element_query_duration (self->priv->element, &format, &duration)) {
                        *position_percentage = (1.0 * position) / (1.0 * duration);
                        return TRUE;
                }
        }

        return FALSE;
}

gboolean
jmp_mplayer_get_position_string (JmpMplayer *self, gchar **position)
{

        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        gint64 pos;

        if (jmp_mplayer_get_position (self, &pos)) {
               *position =  g_strdup_printf ("%" GST_TIME_FORMAT, GST_TIME_ARGS (pos));
               return TRUE;
        }

        return FALSE;
}

gboolean
jmp_mplayer_seek (JmpMplayer *self, gint64 seek_position)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        return gst_element_seek_simple (self->priv->element,
                        GST_FORMAT_TIME,
                        GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
                        seek_position);
}

gboolean
jmp_mplayer_seek_in_percentage (JmpMplayer *self, gdouble seek_position_percentage)
{
        g_return_val_if_fail (JMP_IS_MPLAYER (self), FALSE);
        g_return_val_if_fail (self->priv->element, FALSE);

        GstFormat format = GST_FORMAT_PERCENT;
        gint64 position = 0, duration = 0;

        position = (gint64)(seek_position_percentage * GST_FORMAT_PERCENT_MAX);

        if (gst_element_seek_simple (self->priv->element,
                                     format,
                                     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
                                     position)) {
                return TRUE;
        } else {
                format = GST_FORMAT_TIME;

                if (gst_element_query_duration (self->priv->element, &format,
                                                &duration)) {

                        position = nearbyint (duration * seek_position_percentage);

                        gst_element_seek_simple
                                (self->priv->element,
                                 format,
                                 GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
                                 position);
                        return TRUE;
                }
        }
        return FALSE;
}