/*
 *  mur.sat
 *
 *  Somewhen in the year 2011, mur.at will have a nano satellite launched
 *  into a low earth orbit (310 km above the surface of our planet). The
 *  satellite itself is a TubeSat personal satellite kit, developed and
 *  launched by interorbital systems. mur.sat is a joint venture of mur.at,
 *  ESC im Labor and realraum.
 *
 *  Please visit the project hompage at sat.mur.at for further information.
 * 
 *
 *  Copyright (C) 2011 Christian Pointner <equinox@mur.at>
 *                         
 *  This file is part of mur.sat.
 *
 *  mur.sat 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 3 of the License, or
 *  any later version.
 *
 *  mur.sat 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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with mur.sat. If not, see <http://www.gnu.org/licenses/>.
 */
#include <stdio.h>
#include <gst/gst.h>
#include <string.h>
#include <errno.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>

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

  switch (GST_MESSAGE_TYPE (msg)) {

    case GST_MESSAGE_EOS:
      g_print ("End of stream\n");
      g_main_loop_quit (loop);
      break;

    case GST_MESSAGE_ERROR: {
      gchar  *debug;
      GError *error;

      gst_message_parse_error (msg, &error, &debug);
      g_free (debug);

      g_printerr ("Error: %s\n", error->message);
      g_error_free (error);

      g_main_loop_quit (loop);
      break;
    }
    default:
      break;
  }

  return TRUE;
}


struct thread_param {
  GstElement* element;
  GMainLoop* loop;
};

static GThread *reader_thread;

static gpointer reader_thread_func(gpointer data)
{
  struct thread_param* param = (struct thread_param *)data;

  GMainLoop* loop = param->loop;
  GstElement* element = param->element;
  free(param);

  printf("reader thread started\n");

  struct termios tio;

  tcgetattr(fileno(stdin), &tio);
  tio.c_lflag &= ~ICANON;
  tcsetattr(fileno(stdin), TCSANOW, &tio);

  for(;;) {
    char sign;

    int ret = read(0, &sign, 1);
    if(!ret) break;
    if(ret < 0) {
      printf("read error: %s", strerror(errno));
      break;
    }

    int code = 0;
    switch(sign) {
      case '0': code = 0; break;
      case '1': code = 1; break;
      case '2': code = 2; break;
      case '3': code = 3; break;
      case '4': code = 4; break;
      case '5': code = 5; break;
      case '6': code = 6; break;
      case '7': code = 7; break;
      case '8': code = 8; break;
      case '9': code = 9; break;
      case '*': code = 10; break;
      case '#': code = 11; break;
      case 'a': code = 12; break;
      case 'b': code = 13; break;
      case 'c': code = 14; break;
      case 'd': code = 15; break;
      default: continue;
    }

    GstStructure* st = gst_structure_new ("dtmf-event", "type", G_TYPE_INT, 1, "number", G_TYPE_INT, code, "volume", G_TYPE_INT, 25, "start", G_TYPE_BOOLEAN, TRUE, NULL);
    GstEvent* ev = gst_event_new_custom(GST_EVENT_CUSTOM_UPSTREAM, st);
    gst_element_send_event(element, ev);

        // sleep is useless
    st = gst_structure_new ("dtmf-event", "type", G_TYPE_INT, 1, "number", G_TYPE_INT, code, "start", G_TYPE_BOOLEAN, FALSE, NULL);
    ev = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM, st);
    gst_element_send_event(element, ev);
  }

  g_main_loop_quit(loop);
  return NULL;
}

int init_code_reader(GMainLoop *loop, GstElement* element)
{
	g_assert(!reader_thread);

  struct thread_param* p = malloc(sizeof(struct thread_param));
  if(!p)
    return -1;

  p->element = element;
  p->loop = loop;

  reader_thread = g_thread_create(reader_thread_func, p, TRUE, NULL);
  if(!reader_thread)
    return -1;

  return 0;
}


int main (int argc, char *argv[])
{
  GMainLoop *loop;

  GstElement *pipeline, *source, *demuxer, *decoder, *conv, *sink;
  GstBus *bus;

  /* Initialisation */
  gst_init (&argc, &argv);

  loop = g_main_loop_new (NULL, FALSE);

  /* Create gstreamer elements */
  pipeline = gst_pipeline_new ("dtmftest");
  source   = gst_element_factory_make ("dtmfsrc",       "source");
  sink     = gst_element_factory_make ("autoaudiosink", "output");

  if (!pipeline || !source || !sink) {
    g_printerr ("One element could not be created. Exiting.\n");
    return -1;
  }

  g_object_set(G_OBJECT (source), "interval", 10, NULL);

  /* Set up the pipeline */

  /* we add a message handler */
  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
  gst_bus_add_watch (bus, bus_call, loop);
  gst_object_unref (bus);

  /* we add all elements into the pipeline */
  /* file-source | ogg-demuxer | vorbis-decoder | converter | alsa-output */
  gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);
  gst_element_link_many (source, sink, NULL);

  /* Set the pipeline to "playing" state*/
  gst_element_set_state (pipeline, GST_STATE_PLAYING);

 
  init_code_reader(loop, pipeline);

  /* Iterate */
  g_print ("Running...\n");
  g_main_loop_run (loop);


  /* Out of the main loop, clean up nicely */
  g_print ("Returned, stopping playback\n");
  gst_element_set_state (pipeline, GST_STATE_NULL);

  g_print ("Deleting pipeline\n");
  gst_object_unref (GST_OBJECT (pipeline));

  return 0;
}