#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gst/gst.h>
#include <gst/base/gstcollectpads.h>

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

/* gpac includes */
#include <gpac/isomedia.h>

#define GST_TYPE_GPAC_MUX (gst_gpac_mux_get_type())
#define GST_GPAC_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GPAC_MUX, GstGpacMux))
#define GST_GPAC_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GPAC_MUX, GstGpacMux))
#define GST_IS_GPAC_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GPAC_MUX))
#define GST_IS_GPAC_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GPAC_MUX))

typedef struct _GstGpacMux GstGpacMux;
typedef struct _GstGpacMuxClass GstGpacMuxClass;

typedef enum
{
  GST_GPAC_PAD_STATE_CONTROL = 0,
  GST_GPAC_PAD_STATE_DATA = 1
}
GstGpacPadState;

typedef struct
{
  GstCollectData collect;       /* we extend the CollectData */

  gint track_number;
  guint32 di; /* outDescriptionIndex */

  GstBuffer *buffer;
  GstBuffer *next_buffer;

  guint32 frame_count;
  gboolean is_video;

  gboolean eos;

} GstGpacPad;

struct _GstGpacMux
{
  GstElement element;

  GstPad *srcpad;
  GstCollectPads *collect;
  gint active_pads;

  GF_ISOFile *file;

};

struct _GstGpacMuxClass
{
  GstElementClass parent_class;
};

/* elementfactory information */
static const GstElementDetails gst_gpac_mux_details =
GST_ELEMENT_DETAILS ("Gpac muxer",
    "Codec/Muxer",
    "mux mp4 streams",
    "Hallyson Melo <hallyson.melo@indt.org.br");

/* GpacMux signals and args */
enum
{
  /* FILL ME */
  LAST_SIGNAL
};

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("video/quicktime")
    );

static GstStaticPadTemplate audio_sink_factory = GST_STATIC_PAD_TEMPLATE ("audio_%d",
    GST_PAD_SINK,
    GST_PAD_REQUEST,
    GST_STATIC_CAPS (
        "audio/mpeg, " 
        "mpegversion = (int) 4, " 
        "channels = (int) { 1, 2 }, " 
        "rate = (int) [ 8000, 96000 ]")
    );
    //GST_STATIC_CAPS ("audio/mpeg, mpegversion = 1, layer = 3")

static GstStaticPadTemplate video_sink_factory = GST_STATIC_PAD_TEMPLATE ("video_%d",
    GST_PAD_SINK,
    GST_PAD_REQUEST,
    GST_STATIC_CAPS ("video/mpeg, mpegversion = 4")
   );

static void gst_gpac_mux_base_init (gpointer g_class);
static void gst_gpac_mux_class_init (GstGpacMuxClass * klass);
static void gst_gpac_mux_init (GstGpacMux * gpac_mux);
static void gst_gpac_mux_finalize (GObject * object);

static GstFlowReturn
gst_gpac_mux_collected (GstCollectPads * pads, GstGpacMux * gpac_mux);

static gboolean gst_gpac_mux_handle_src_event (GstPad * pad, GstEvent * event);
static GstPad *gst_gpac_mux_request_new_pad (GstElement * element,
    GstPadTemplate * templ, const gchar * name);
static void gst_gpac_mux_release_pad (GstElement * element, GstPad * pad);

static GstStateChangeReturn gst_gpac_mux_change_state (GstElement * element,
    GstStateChange transition);

static GstGpacPad* gst_gpac_mux_queue_pads (GstGpacMux * gpac_mux);
static GstFlowReturn gst_gpac_mux_process_pad (GstGpacMux * gpac_mux, GstGpacPad *pad);
static gboolean gst_gpac_mux_all_pads_eos (GstCollectPads * pads);
static gint gst_gpac_mux_compare_pads (GstGpacMux * ogg_mux, GstGpacPad *first,
    GstGpacPad *second);


static GstElementClass *parent_class = NULL;

GType
gst_gpac_mux_get_type (void)
{
  static GType gpac_mux_type = 0;

  if (G_UNLIKELY (gpac_mux_type == 0)) {
    static const GTypeInfo gpac_mux_info = {
      sizeof (GstGpacMuxClass),
      gst_gpac_mux_base_init,
      NULL,
      (GClassInitFunc) gst_gpac_mux_class_init,
      NULL,
      NULL,
      sizeof (GstGpacMux),
      0,
      (GInstanceInitFunc) gst_gpac_mux_init,
    };

    gpac_mux_type =
        g_type_register_static (GST_TYPE_ELEMENT, "GstGpacMux", &gpac_mux_info,
        0);
  }
  return gpac_mux_type;
}

static void
gst_gpac_mux_base_init (gpointer g_class)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&audio_sink_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&video_sink_factory));

  gst_element_class_set_details (element_class, &gst_gpac_mux_details);
}

static void
gst_gpac_mux_class_init (GstGpacMuxClass * klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;
  gstelement_class = (GstElementClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->finalize = gst_gpac_mux_finalize;

  gstelement_class->request_new_pad = gst_gpac_mux_request_new_pad;
  gstelement_class->release_pad = gst_gpac_mux_release_pad;

  gstelement_class->change_state = gst_gpac_mux_change_state;

}

static void
gst_gpac_mux_init (GstGpacMux * gpac_mux)
{
  GstElementClass *klass = GST_ELEMENT_GET_CLASS (gpac_mux);

  gpac_mux->srcpad =
      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
          "src"), "src");
  gst_pad_set_event_function (gpac_mux->srcpad, gst_gpac_mux_handle_src_event);
  gst_element_add_pad (GST_ELEMENT (gpac_mux), gpac_mux->srcpad);

  gpac_mux->collect = gst_collect_pads_new ();
  gst_collect_pads_set_function (gpac_mux->collect,
      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_gpac_mux_collected),
      gpac_mux);

  /* Opens gpac library */
  /* FIXME */
  gpac_mux->file = gf_isom_open("/tmp/gpac.mp4", GF_ISOM_OPEN_WRITE, NULL);
  gf_isom_set_storage_mode(gpac_mux->file, GF_ISOM_STORE_FLAT /*STREAMABLE*/);

  //gst_gpac_mux_clear (gpac_mux);
}

static void
gst_gpac_mux_finalize (GObject * object)
{
  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (object);

  if (gpac_mux->collect) {
    gst_object_unref (gpac_mux->collect);
    gpac_mux->collect = NULL;
  }

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

static void
gst_gpac_mux_gpac_pad_destroy_notify (GstCollectData * data)
{
  GstGpacPad *gpacpad = (GstGpacPad *) data;
  GstBuffer *buf;

}

static GstPadLinkReturn
gst_gpac_mux_sinkconnect (GstPad * pad, GstPad * peer)
{
  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (gst_pad_get_parent (pad));

  GST_DEBUG_OBJECT (gpac_mux, "sinkconnect triggered on %s", GST_PAD_NAME (pad));

  gst_object_unref (gpac_mux);

  return GST_PAD_LINK_OK;
}

static GstPad *
gst_gpac_mux_request_new_pad (GstElement * element,
    GstPadTemplate * templ, const gchar * req_name)
{
  GstGpacMux *gpac_mux;
  GstPad *newpad;
  GstElementClass *klass;
  gchar *padname = NULL;
  gint serial;
  gboolean is_video = FALSE;

  g_return_val_if_fail (templ != NULL, NULL);

  if (templ->direction != GST_PAD_SINK)
    goto wrong_direction;

  g_return_val_if_fail (GST_IS_GPAC_MUX (element), NULL);
  gpac_mux = GST_GPAC_MUX (element);

  klass = GST_ELEMENT_GET_CLASS (element);

    if (req_name == NULL || strlen (req_name) < 6) {
      /* no name given when requesting the pad, use random serial number */
      serial = rand ();
    } else {
      /* parse serial number from requested padname */
      serial = atoi (&req_name[5]);
    }

  if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {
    is_video = TRUE;      
    padname = g_strdup_printf ("video_%d", serial);
  } else if (templ != gst_element_class_get_pad_template (klass, "audio_%d")) {
    goto wrong_template;
  } else {
    padname = g_strdup_printf ("audio_%d", serial);
  }


  {
    
    /* create new pad with the name */
    GST_DEBUG_OBJECT (gpac_mux, "Creating new pad for serial %d", serial);

    newpad = gst_pad_new_from_template (templ, padname);
    g_free (padname);

    /* construct our own wrapper data structure for the pad to
     * keep track of its status */
    {
      GstGpacPad *gpacpad;

      gpacpad = (GstGpacPad *)
          gst_collect_pads_add_pad_full (gpac_mux->collect, newpad,
          sizeof (GstGpacPad), gst_gpac_mux_gpac_pad_destroy_notify);
      gpac_mux->active_pads++;

      /* gpac new track */
      gpacpad->is_video = is_video;
      if (gpacpad->is_video) {
        gpacpad->track_number = gf_isom_new_track(gpac_mux->file, 0, 
          GF_ISOM_MEDIA_VISUAL, 10 * 1000 /* time scale */);
      } else {
        gpacpad->track_number = gf_isom_new_track(gpac_mux->file, 0, 
          GF_ISOM_MEDIA_AUDIO, 48000 /*time scale */);
        
      }
      if (gpacpad->track_number == 0) {
        g_warning ("Error while adding the new gpac track");
      } else {
        gf_isom_set_track_enabled(gpac_mux->file, gpacpad->track_number, 1);
        if (is_video) {
          GF_ESD *esd = gf_odf_desc_esd_new (0);
          esd->ESID = gf_isom_get_track_id(gpac_mux->file, gpacpad->track_number);

          gf_isom_new_mpeg4_description( gpac_mux->file, gpacpad->track_number,
                        esd, NULL, NULL, &(gpacpad->di));

           gf_isom_set_visual_info (gpac_mux->file, gpacpad->track_number, gpacpad->di, 320, 240);//fixme
          //gf_isom_set_cts_packing (gpac_mux->file, gpacpad->track_number, 0);
        } else {
          GF_ESD *esd = gf_odf_desc_esd_new (2);
          esd->ESID = gf_isom_get_track_id(gpac_mux->file, gpacpad->track_number);

          gf_isom_new_mpeg4_description(gpac_mux->file, gpacpad->track_number,
                         esd, NULL, NULL, &(gpacpad->di));

          gf_isom_set_audio_info(gpac_mux->file, gpacpad->track_number, 
                          gpacpad->di, 48000, 2 /*num channels */, 16);
        }
      }
    }
  }

  /* setup some pad functions */
  gst_pad_set_link_function (newpad, gst_gpac_mux_sinkconnect);
  /* dd the pad to the element */
  gst_element_add_pad (element, newpad);

  return newpad;

  /* ERRORS */
wrong_direction:
  {
    g_warning ("gpac_mux: request pad that is not a SINK pad\n");
    return NULL;
  }
wrong_template:
  {
    g_warning ("gpac_mux: this is not our template!\n");
    return NULL;
  }
}

static void
gst_gpac_mux_release_pad (GstElement * element, GstPad * pad)
{
  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (gst_pad_get_parent (pad));

  gst_collect_pads_remove_pad (gpac_mux->collect, pad);
  gst_element_remove_pad (element, pad);
}

/* handle events */
static gboolean
gst_gpac_mux_handle_src_event (GstPad * pad, GstEvent * event)
{
  GstEventType type;

  type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

  switch (type) {
    case GST_EVENT_SEEK:
      /* disable seeking for now */
      return FALSE;
    default:
      break;
  }

  return gst_pad_event_default (pad, event);
}

static GstFlowReturn
gst_gpac_mux_push_buffer (GstGpacMux * mux, GstBuffer * buffer)
{
  GstCaps *caps;
#if 0
  /* fix up OFFSET and OFFSET_END again */
  GST_BUFFER_OFFSET (buffer) = mux->offset;
  mux->offset += GST_BUFFER_SIZE (buffer);
  GST_BUFFER_OFFSET_END (buffer) = mux->offset;

  /* Ensure we have monotonically increasing timestamps in the output. */
  if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {
    if (mux->last_ts != GST_CLOCK_TIME_NONE &&
        GST_BUFFER_TIMESTAMP (buffer) < mux->last_ts)
      GST_BUFFER_TIMESTAMP (buffer) = mux->last_ts;
    else
      mux->last_ts = GST_BUFFER_TIMESTAMP (buffer);
  }
#endif
  
  caps = gst_pad_get_negotiated_caps (mux->srcpad);
  gst_buffer_set_caps (buffer, caps);
  if (caps != NULL) {
    gst_caps_unref (caps);
  }

  return gst_pad_push (mux->srcpad, buffer);
}

static GstFlowReturn
gst_gpac_mux_collected (GstCollectPads * pads, GstGpacMux * gpac_mux)
{
  GstFlowReturn ret = GST_FLOW_OK;
  GstGpacPad *pad;
  gint active_before;

  GST_LOG_OBJECT (gpac_mux, "collected");

  active_before = gpac_mux->active_pads;

  pad = gst_gpac_mux_queue_pads (gpac_mux);
  if (!pad) {
    return GST_FLOW_WRONG_STATE;
  }

  if (pad->buffer) {
    ret = gst_gpac_mux_process_pad (gpac_mux, pad);
  }

  if (gpac_mux->active_pads < active_before) {
    /* If the active pad count went down, this mean at least one pad has gone
     * EOS. Since CollectPads only calls _collected() once when all pads are
     * EOS, and our code doesn't _pop() from all pads we need to check that by
     * peeking on all pads, else we won't be called again and the muxing will
     * not terminate (push out EOS). */
          printf ("XXXX um pad foi desativado %" GST_PTR_FORMAT "\n", pad);

    /* if all the pads have been removed, flush all pending data */
    if ((ret == GST_FLOW_OK) && gst_gpac_mux_all_pads_eos (pads)) {
      GST_LOG_OBJECT (gpac_mux, "no pads remaining, flushing data");

      do {
        pad = gst_gpac_mux_queue_pads (gpac_mux);
        if (pad)
          ret = gst_gpac_mux_process_pad (gpac_mux, pad);
      } while ((ret == GST_FLOW_OK) && (pad != NULL));

      /* gpac file close (eos) */
      // Fixme: this should flush all data to src pad
      // Fixme: where to release gpac_mux->file?
      printf ("CCCCCCCCCCCCCCCCcclosing the file\n");
      gf_isom_close (gpac_mux->file);


      GST_DEBUG_OBJECT (gpac_mux, "Pushing EOS");
      gst_pad_push_event (gpac_mux->srcpad, gst_event_new_eos ());
    }
  }

  return ret;

}

static gboolean
gst_gpac_mux_all_pads_eos (GstCollectPads * pads)
{
  GSList *walk;
  gboolean alleos = TRUE;

  walk = pads->data;
  while (walk) {
    GstBuffer *buf;
    GstCollectData *data = (GstCollectData *) walk->data;

    buf = gst_collect_pads_peek (pads, data);
    if (buf) {
      alleos = FALSE;
      gst_buffer_unref (buf);
      break;
    }
    walk = walk->next;
  }

  return alleos;
}


static GstFlowReturn
gst_gpac_mux_process_pad (GstGpacMux *gpac_mux, GstGpacPad *pad)
{
  GstFlowReturn ret = GST_FLOW_OK;
  GF_ISOSample *sample;

  if (pad->buffer == NULL) {
          printf ("Buffer is null, wrong state\n");
      return GST_FLOW_WRONG_STATE;
  }

  /* gpac output */
  printf ("xxxxxx buffer size: %d\n", GST_BUFFER_SIZE(pad->buffer)); fflush (stdout);
  printf ("xxxx frames %d\n", pad->frame_count);

  sample = gf_isom_sample_new();
  sample->dataLength = GST_BUFFER_SIZE(pad->buffer);
  sample->data = GST_BUFFER_DATA(pad->buffer);
  sample->CTS_Offset = 0;

  if (pad->is_video) {
    sample->IsRAP = 0;
    sample->DTS += 1000*pad->frame_count;
  } else {
    sample->IsRAP = 0;
    sample->DTS = 2048*pad->frame_count;
  }

  gf_isom_add_sample(gpac_mux->file, pad->track_number, 
                     pad->di, sample);
  sample->data = NULL;

  gf_isom_sample_del(&sample);


  /* gstreamer output (push) */
  ret = gst_gpac_mux_push_buffer (gpac_mux, pad->buffer);
  pad->buffer = NULL;

  if (ret != GST_FLOW_OK) {
  }

  pad->frame_count++;
 
  return ret;
}

/* reset all variables in the gpac pads. */
static void
gst_gpac_mux_init_collectpads (GstCollectPads * collect)
{
  GSList *iter;

  iter = collect->data;
  while (iter) {
    GstGpacPad *gpacpad = (GstGpacPad *) iter->data;

    //gpac_stream_init (&gpacpad->stream, gpacpad->serial);
    //gpacpad->packetno = 0;
    //gpacpad->pageno = 0;
    //gpacpad->eos = FALSE;
    /* we assume there will be some control data first for this pad */
    //gpacpad->state = GST_GPAC_PAD_STATE_CONTROL;
    //gpacpad->new_page = TRUE;
    //gpacpad->first_delta = FALSE;
    //gpacpad->prev_delta = FALSE;
    //gpacpad->pagebuffers = g_queue_new ();

    iter = g_slist_next (iter);
  }
}

/* Clear all buffers from the collectpads object */
static void
gst_gpac_mux_clear_collectpads (GstCollectPads * collect)
{
  GSList *iter;

  for (iter = collect->data; iter; iter = g_slist_next (iter)) {
    GstGpacPad *gpacpad = (GstGpacPad *) iter->data;
    GstBuffer *buf;

    //gpac_stream_clear (&gpacpad->stream);
/*
    while ((buf = g_queue_pop_head (gpacpad->pagebuffers)) != NULL) {
      gst_buffer_unref (buf);
    }
    g_queue_free (gpacpad->pagebuffers);
    gpacpad->pagebuffers = NULL;*/
  }
}

static GstStateChangeReturn
gst_gpac_mux_change_state (GstElement * element, GstStateChange transition)
{
  GstGpacMux *gpac_mux;
  GstStateChangeReturn ret;

  gpac_mux = GST_GPAC_MUX (element);

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      break;
    case GST_STATE_CHANGE_READY_TO_PAUSED:
      //gst_gpac_mux_clear (gpac_mux);
      //gst_gpac_mux_init_collectpads (gpac_mux->collect);
      gst_collect_pads_start (gpac_mux->collect);
      break;
    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
      break;
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      gst_collect_pads_stop (gpac_mux->collect);
      break;
    default:
      break;
  }

  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

  switch (transition) {
    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
      break;
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      gst_gpac_mux_clear_collectpads (gpac_mux->collect);
      break;
    case GST_STATE_CHANGE_READY_TO_NULL:
      break;
    default:
      break;
  }

  return ret;

}

static GstGpacPad *
gst_gpac_mux_queue_pads (GstGpacMux * gpac_mux)
{
  GstGpacPad *bestpad = NULL;//, *still_hungry = NULL;
  GSList *iter;

  /* try to make sure we have a buffer from each usable pad first */
  iter = gpac_mux->collect->data;
  while (iter) {
    GstGpacPad *pad;
    GstCollectData *data;

    data = (GstCollectData *) iter->data;
    pad = (GstGpacPad *) data;

    iter = g_slist_next (iter);

    GST_LOG_OBJECT (data->pad, "looking at pad for buffer");

    /* try to get a new buffer for this pad if needed and possible */
    if (pad->buffer == NULL) {
      GstBuffer *buf;

      buf = gst_collect_pads_pop (gpac_mux->collect, data);
      GST_LOG_OBJECT (data->pad, "popped buffer %" GST_PTR_FORMAT, buf);

      /* On EOS we get a NULL buffer */
      if (buf == NULL) {
              printf ("EENENENENENEND OF STREAM EOS\n");
        GST_DEBUG_OBJECT (data->pad, "EOS on pad");
        if (!pad->eos) {
          /* it's no longer active */
          gpac_mux->active_pads--;
          pad->eos = TRUE;

        }
      }

      pad->buffer = buf;
    } 

    /* we should have a buffer now, see if it is the best pad to
     * pull on */
      if (gst_gpac_mux_compare_pads (gpac_mux, bestpad, pad) > 0) {
        GST_LOG_OBJECT (data->pad,
            "new best pad, with buffers %" GST_PTR_FORMAT, pad->buffer);
        bestpad = pad;
      }
  }
 
  return bestpad;
}

static gint
gst_gpac_mux_compare_pads (GstGpacMux * ogg_mux, GstGpacPad *first,
    GstGpacPad *second)
{
  guint64 firsttime, secondtime;

  /* if the first pad doesn't contain anything or is even NULL, return
   * the second pad as best candidate and vice versa */
  if (first == NULL || (first->buffer == NULL))
    return 1;
  if (second == NULL || (second->buffer == NULL))
    return -1;

  /* no timestamp on first buffer, it must go first */
  if (first->buffer)
    firsttime = GST_BUFFER_TIMESTAMP (first->buffer);
  if (firsttime == GST_CLOCK_TIME_NONE)
    return -1;

  /* no timestamp on second buffer, it must go first */
  if (second->buffer)
    secondtime = GST_BUFFER_TIMESTAMP (second->buffer);
  if (secondtime == GST_CLOCK_TIME_NONE)
    return 1;

  /* first buffer has higher timestamp, second one should go first */
  if (secondtime < firsttime)
    return 1;
  /* second buffer has higher timestamp, first one should go first */
  else if (secondtime > firsttime)
    return -1;

  /* same priority if all of the above failed */
  return 0;
}



static gboolean
gst_gpac_mux_plugin_init (GstPlugin * plugin)
{
  return gst_element_register (plugin, "gpacmux", GST_RANK_NONE,
      GST_TYPE_GPAC_MUX);
}

GST_PLUGIN_DEFINE(GST_VERSION_MAJOR,
                  GST_VERSION_MINOR,
                  "gpacmux",
                  "Muxes audio and video",
                  gst_gpac_mux_plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME,
                  GST_PACKAGE_ORIGIN)