#include "e.h"
#include "emix.h"

#include <pulse/pulseaudio.h>

#undef ERR
#undef DBG
#undef WRN
#define ERR(...)      EINA_LOG_ERR(__VA_ARGS__)
#define DBG(...)      EINA_LOG_DBG(__VA_ARGS__)
#define WRN(...)      EINA_LOG_WARN(__VA_ARGS__)

#define PA_VOLUME_TO_INT(_vol) \
   (((_vol * EMIX_VOLUME_BARRIER) / \
    (double)PA_VOLUME_NORM) + 0.5)
#define INT_TO_PA_VOLUME(_vol) \
   (((PA_VOLUME_NORM * _vol) / \
    (double)EMIX_VOLUME_BARRIER) + 0.5)

typedef struct _Context
{
   pa_mainloop_api api;
   pa_context *context;
   pa_context_state_t state;
   Emix_Event_Cb cb;
   const void *userdata;
   Ecore_Timer *connect;

   Eina_List *sinks, *sources, *inputs, *outputs, *cards;
   Eina_Bool connected;
} Context;

typedef struct _Sink
{
   Emix_Sink base;
   int idx, monitor_idx;
   const char *pulse_name;
   const char *monitor_source_name;
   int mon_count;
   pa_stream *mon_stream;
   Eina_Bool running : 1;
} Sink;

typedef struct _Sink_Input
{
   Emix_Sink_Input base;
   int idx, sink_idx;
   int mon_count;
   pa_stream *mon_stream;
   Eina_Bool running : 1;
} Sink_Input;

typedef struct _Source
{
   Emix_Source base;
   int idx;
   const char *pulse_name;
   int mon_count;
   pa_stream *mon_stream;
} Source;

typedef struct _Source_Output
{
   Emix_Source_Output base;
   int idx, source_idx;
   Eina_Bool running : 1;
} Source_Output;

typedef struct _Profile
{
   Emix_Profile base;
   uint32_t priority;
} Profile;

typedef struct _Card
{
   Emix_Card base;
   int idx;
} Card;

static Context *ctx = NULL;
extern pa_mainloop_api functable;

static void _sink_monitor_begin(Sink *sink);
static void _sink_monitor_end(Sink *sink);
static void _sink_input_monitor_begin(Sink_Input *i);
static void _sink_input_monitor_end(Sink_Input *i);
static void _source_monitor_begin(Source *s);
static void _source_monitor_end(Source *s);

static pa_cvolume
_emix_volume_convert(const Emix_Volume *volume)
{
   pa_cvolume vol;
   unsigned int i;

   vol.channels = volume->channel_count;
   for (i = 0; i < volume->channel_count; i++)
     vol.values[i] = INT_TO_PA_VOLUME(volume->volumes[i]);
   return vol;
}

static void
_pa_cvolume_convert(const pa_cvolume *volume, Emix_Volume *vol)
{
   int i;

   if (vol->volumes) free(vol->volumes);
   vol->volumes = calloc(volume->channels, sizeof(int));
   if (!vol->volumes)
     {
        WRN("Could not allocate memory for volume");
        vol->channel_count = 0;
        return;
     }

   vol->channel_count = volume->channels;
   for (i = 0; i < volume->channels; i++)
     vol->volumes[i] = PA_VOLUME_TO_INT(volume->values[i]);
}

static void
_sink_del(Sink *sink)
{
   unsigned int i;
   Emix_Port *port;

   EINA_SAFETY_ON_NULL_RETURN(sink);
   EINA_LIST_FREE(sink->base.ports, port)
     {
        eina_stringshare_del(port->name);
        eina_stringshare_del(port->description);
        free(port);
     }

   free(sink->base.volume.volumes);
   for(i = 0; i < sink->base.volume.channel_count; ++i)
     eina_stringshare_del(sink->base.volume.channel_names[i]);
   free(sink->base.volume.channel_names);
   eina_stringshare_del(sink->base.name);
   eina_stringshare_del(sink->pulse_name);
   eina_stringshare_del(sink->monitor_source_name);
   if (sink->mon_stream) pa_stream_disconnect(sink->mon_stream);
   free(sink);
}

static void
_sink_input_del(Sink_Input *input)
{
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(input);

   free(input->base.volume.volumes);
   for(i = 0; i < input->base.volume.channel_count; ++i)
     eina_stringshare_del(input->base.volume.channel_names[i]);
   free(input->base.volume.channel_names);
   eina_stringshare_del(input->base.name);
   eina_stringshare_del(input->base.icon);
   if (input->mon_stream) pa_stream_disconnect(input->mon_stream);
   free(input);
}

static void
_source_del(Source *source)
{
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(source);

   free(source->base.volume.volumes);
   for(i = 0; i < source->base.volume.channel_count; ++i)
     eina_stringshare_del(source->base.volume.channel_names[i]);
   free(source->base.volume.channel_names);
   eina_stringshare_del(source->base.name);
   eina_stringshare_del(source->pulse_name);
   free(source);
}

static void
_source_output_del(Source_Output *output)
{
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(output);

   free(output->base.volume.volumes);
   for(i = 0; i < output->base.volume.channel_count; ++i)
     eina_stringshare_del(output->base.volume.channel_names[i]);
   free(output->base.volume.channel_names);
   eina_stringshare_del(output->base.name);
   eina_stringshare_del(output->base.icon);
   free(output);
}

static void
_card_del(Card *card)
{
   Profile *profile;
   EINA_SAFETY_ON_NULL_RETURN(card);

   EINA_LIST_FREE(card->base.profiles, profile)
     {
        eina_stringshare_del(profile->base.name);
        eina_stringshare_del(profile->base.description);
        free(profile);
     }
   eina_stringshare_del(card->base.name);
   free(card);
}

static void
_sink_state_running_set(Sink *sink, Eina_Bool running)
{
   if (running)
     {
        if ((!sink->running) && (sink->mon_count > 0))
          {
             sink->running = running;
             _sink_monitor_begin(sink);
             return;
          }
     }
   else
     {
        if ((sink->running) && (sink->mon_count > 0))
          {
             sink->running = running;
             _sink_monitor_end(sink);
             return;
          }
     }
   sink->running = running;
}

static void
_sink_cb(pa_context *c EINA_UNUSED, const pa_sink_info *info, int eol,
         void *userdata EINA_UNUSED)
{
   Sink *sink;
   Emix_Port *port;
   uint32_t i;

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Sink callback failure");
        return;
     }

   if (eol > 0)
      return;

   DBG("sink index: %d\nsink name: %s", info->index,
       info->name);

   sink = calloc(1, sizeof(Sink));
   sink->idx = info->index;
   sink->monitor_idx = info->monitor_source;
   sink->pulse_name = eina_stringshare_add(info->name);
   sink->base.name = eina_stringshare_add(info->description);
   _pa_cvolume_convert(&info->volume, &sink->base.volume);
   sink->base.volume.channel_names = calloc(sink->base.volume.channel_count, sizeof(Emix_Channel));
   for (i = 0; i < sink->base.volume.channel_count; ++i)
     sink->base.volume.channel_names[i] = eina_stringshare_add(pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   sink->base.mute = !!info->mute;
   sink->monitor_source_name = eina_stringshare_add(info->monitor_source_name);

   for (i = 0; i < info->n_ports; i++)
     {
        port = calloc(1, sizeof(Emix_Port));
        if (!port)
          {
             WRN("Could not allocate memory for Sink's port");
             continue;
          }

        port->available = !!info->ports[i]->available;
        port->name = eina_stringshare_add(info->ports[i]->name);
        port->description =  eina_stringshare_add(info->ports[i]->description);
        sink->base.ports = eina_list_append(sink->base.ports, port);
        if (info->ports[i]->name == info->active_port->name)
           port->active = EINA_TRUE;
     }
   if (info->state == PA_SINK_RUNNING) _sink_state_running_set(sink, EINA_TRUE);
   else _sink_state_running_set(sink, EINA_FALSE);
   ctx->sinks = eina_list_append(ctx->sinks, sink);

   if (ctx->cb)
      ctx->cb((void *)ctx->userdata, EMIX_SINK_ADDED_EVENT,
              (Emix_Sink *)sink);
}

static void
_sink_changed_cb(pa_context *c EINA_UNUSED, const pa_sink_info *info, int eol,
                 void *userdata EINA_UNUSED)
{
   Sink *sink = NULL, *s;
   Emix_Port *port;
   uint32_t i;
   Eina_List *l;

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Sink callback failure");
        return;
     }

   if (eol > 0)
      return;

   DBG("sink index: %d\nsink name: %s", info->index,
       info->name);

   EINA_LIST_FOREACH(ctx->sinks, l, s)
     {
        if (s->idx == (int)info->index)
          {
             sink = s;
             break;
          }
     }

   EINA_SAFETY_ON_NULL_RETURN(sink);

   eina_stringshare_replace(&sink->base.name, info->description);

   if (sink->base.volume.channel_count != info->volume.channels)
     {
        for (i = 0; i < sink->base.volume.channel_count; ++i)
          eina_stringshare_del(sink->base.volume.channel_names[i]);
        free(sink->base.volume.channel_names);
        sink->base.volume.channel_names = calloc(info->volume.channels, sizeof(Emix_Channel));
     }
   _pa_cvolume_convert(&info->volume, &sink->base.volume);
   for (i = 0; i < sink->base.volume.channel_count; ++i)
     eina_stringshare_replace(&sink->base.volume.channel_names[i],
                              pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   sink->base.mute = !!info->mute;

   if (sink->base.ports)
     {
        EINA_LIST_FREE(sink->base.ports, port)
          {
             eina_stringshare_del(port->name);
             eina_stringshare_del(port->description);
             free(port);
          }
     }
   for (i = 0; i < info->n_ports; i++)
     {
        port = calloc(1, sizeof(Emix_Port));
        if (!port)
          {
             WRN("Could not allocate memory for Sink's port");
             continue;
          }

        port->available = !!info->ports[i]->available;
        port->name = eina_stringshare_add(info->ports[i]->name);
        port->description =  eina_stringshare_add(info->ports[i]->description);
        sink->base.ports = eina_list_append(sink->base.ports, port);
        if (info->ports[i]->name == info->active_port->name)
           port->active = EINA_TRUE;
     }

   sink->monitor_idx = info->monitor_source;

   if (info->state == PA_SINK_RUNNING) _sink_state_running_set(sink, EINA_TRUE);
   else _sink_state_running_set(sink, EINA_FALSE);

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SINK_CHANGED_EVENT,
                  (Emix_Sink *)sink);
}

static void
_sink_remove_cb(int index, void *data EINA_UNUSED)
{
   Sink *sink;
   Eina_List *l;
   DBG("Removing sink: %d", index);

   EINA_LIST_FOREACH(ctx->sinks, l, sink)
     {
        if (sink->idx == index)
          {
             ctx->sinks = eina_list_remove_list(ctx->sinks, l);
             if (ctx->cb)
               ctx->cb((void *)ctx->userdata, EMIX_SINK_REMOVED_EVENT,
                            (Emix_Sink *)sink);
             _sink_del(sink);
             break;
          }
     }
}

static const char *
_icon_from_properties(pa_proplist *l)
{
   const char *t;

   if ((t = pa_proplist_gets(l, PA_PROP_MEDIA_ICON_NAME))) return t;
   if ((t = pa_proplist_gets(l, PA_PROP_WINDOW_ICON_NAME))) return t;
   if ((t = pa_proplist_gets(l, PA_PROP_APPLICATION_ICON_NAME))) return t;
   if ((t = pa_proplist_gets(l, PA_PROP_APPLICATION_ICON))) return t;
   if ((t = pa_proplist_gets(l, PA_PROP_APPLICATION_ID))) return t;
   if ((t = pa_proplist_gets(l, PA_PROP_APPLICATION_NAME))) return t;

   if ((t = pa_proplist_gets(l, PA_PROP_MEDIA_ROLE)))
     {
        if ((!strcmp(t, "video")) || (!strcmp(t, "phone"))) return t;
        if (!strcmp(t, "music")) return "multimedia-player";
        if (!strcmp(t, "game")) return "applications-games";
        if (!strcmp(t, "event")) return "dialog-information";
     }
   return NULL;
}

static void
_sink_input_state_running_set(Sink_Input *input, Eina_Bool running)
{
   if (running)
     {
        if ((!input->running) && (input->mon_count > 0))
          {
             input->running = running;
             _sink_input_monitor_begin(input);
             return;
          }
     }
   else
     {
        if ((input->running) && (input->mon_count > 0))
          {
             input->running = running;
             _sink_input_monitor_end(input);
             return;
          }
     }
   input->running = running;
}

static void
_sink_input_cb(pa_context *c EINA_UNUSED, const pa_sink_input_info *info,
               int eol, void *userdata EINA_UNUSED)
{
   Sink_Input *input;
   Eina_List *l;
   Sink *s;
   const char *t;
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
          return;

        ERR("Sink input callback failure");
        return;
     }

   if (eol > 0)
      return;

   input = calloc(1, sizeof(Sink_Input));
   EINA_SAFETY_ON_NULL_RETURN(input);

   DBG("sink input index: %d\nsink input name: %s", info->index,
       info->name);

   input->idx = info->index;
   input->sink_idx = info->sink;

   Eina_Strbuf *input_name;

   input_name = eina_strbuf_new();
   const char *application = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_NAME);
   if (application)
     {
        eina_strbuf_append(input_name, application);
        eina_strbuf_append(input_name, ":");
        eina_strbuf_append(input_name, info->name);
     }
   else if (info->name)
     {
        eina_strbuf_append(input_name, info->name);
     }
   input->base.name = eina_stringshare_add(eina_strbuf_string_get(input_name));
   eina_strbuf_free(input_name);
   _pa_cvolume_convert(&info->volume, &input->base.volume);
   input->base.volume.channel_names = calloc(input->base.volume.channel_count, sizeof(Emix_Channel));
   for (i = 0; i < input->base.volume.channel_count; ++i)
     input->base.volume.channel_names[i] = eina_stringshare_add(pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   input->base.mute = !!info->mute;
   EINA_LIST_FOREACH(ctx->sinks, l, s)
     {
        if (s->idx == (int)info->sink)
          input->base.sink = (Emix_Sink *)s;
     }
   input->base.icon = eina_stringshare_add(_icon_from_properties(info->proplist));
   ctx->inputs = eina_list_append(ctx->inputs, input);

   if ((t = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_PROCESS_ID)))
     {
        input->base.pid = atoi(t);
     }
   if (!info->corked) _sink_input_state_running_set(input, EINA_TRUE);
   else _sink_input_state_running_set(input, EINA_FALSE);

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SINK_INPUT_ADDED_EVENT,
             (Emix_Sink_Input *)input);
}

static void
_sink_input_changed_cb(pa_context *c EINA_UNUSED,
                       const pa_sink_input_info *info, int eol,
                       void *userdata EINA_UNUSED)
{
   Sink_Input *input = NULL, *si;
   Sink *s = NULL;
   Eina_List *l;
   const char *t;
   unsigned int i;

   EINA_SAFETY_ON_NULL_RETURN(ctx);
   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Sink input changed callback failure");
        return;
     }

   if (eol > 0)
      return;

   EINA_LIST_FOREACH(ctx->inputs, l, si)
     {
        if (si->idx == (int)info->index)
          {
            input = si;
            break;
          }
     }

   DBG("sink input changed index: %d\n", info->index);

   if (!input)
     {
        input = calloc(1, sizeof(Sink_Input));
        EINA_SAFETY_ON_NULL_RETURN(input);
        ctx->inputs = eina_list_append(ctx->inputs, input);
     }
   input->idx = info->index;
   input->sink_idx = info->sink;
   if (input->base.volume.channel_count != info->volume.channels)
     {
        for (i = 0; i < input->base.volume.channel_count; ++i)
          eina_stringshare_del(input->base.volume.channel_names[i]);
        free(input->base.volume.channel_names);
        input->base.volume.channel_names = calloc(info->volume.channels, sizeof(Emix_Channel));
     }
   _pa_cvolume_convert(&info->volume, &input->base.volume);
   for (i = 0; i < input->base.volume.channel_count; ++i)
     eina_stringshare_replace(&input->base.volume.channel_names[i],
                              pa_channel_position_to_pretty_string(info->channel_map.map[i]));

   input->base.mute = !!info->mute;

   EINA_LIST_FOREACH(ctx->sinks, l, s)
     {
        if (s->idx == (int)info->sink)
          input->base.sink = (Emix_Sink *)s;
     }
   if ((t = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_PROCESS_ID)))
     {
        input->base.pid = atoi(t);
     }

   if (!info->corked) _sink_input_state_running_set(input, EINA_TRUE);
   else _sink_input_state_running_set(input, EINA_FALSE);

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SINK_INPUT_CHANGED_EVENT,
             (Emix_Sink_Input *)input);

   if (input->mon_count > 0)
     {
        _sink_input_monitor_end(input);
        if (input->running) _sink_input_monitor_begin(input);
     }
}

static void
_sink_input_remove_cb(int index, void *data EINA_UNUSED)
{
   Sink_Input *input;
   Eina_List *l;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   DBG("Removing sink input: %d", index);

   EINA_LIST_FOREACH(ctx->inputs, l, input)
     {
        if (input->idx == index)
          {
             ctx->inputs = eina_list_remove_list(ctx->inputs, l);
             if (ctx->cb)
               ctx->cb((void *)ctx->userdata,
                       EMIX_SINK_INPUT_REMOVED_EVENT,
                       (Emix_Sink_Input *)input);
             _sink_input_del(input);

             break;
          }
     }
}

static void
_source_cb(pa_context *c EINA_UNUSED, const pa_source_info *info,
           int eol, void *userdata EINA_UNUSED)
{
   Source *source;
   unsigned int i;
   size_t len;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Source callback failure");
        return;
     }

   if (eol > 0)
      return;

   len = strlen(info->name);
   if (len > 8)
     {
        const char *s = info->name + len - 8;
        if (!strcmp(s, ".monitor")) return;
     }

   source = calloc(1, sizeof(Source));
   EINA_SAFETY_ON_NULL_RETURN(source);

   source->idx = info->index;
   source->pulse_name = eina_stringshare_add(info->name);
   source->base.name = eina_stringshare_add(info->description);
   _pa_cvolume_convert(&info->volume, &source->base.volume);
   source->base.volume.channel_names = calloc(source->base.volume.channel_count, sizeof(Emix_Channel));
   for (i = 0; i < source->base.volume.channel_count; ++i)
     source->base.volume.channel_names[i] = eina_stringshare_add(pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   source->base.mute = !!info->mute;

   ctx->sources = eina_list_append(ctx->sources, source);
   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SOURCE_ADDED_EVENT,
             (Emix_Source *)source);
}

static void
_source_changed_cb(pa_context *c EINA_UNUSED,
                       const pa_source_info *info, int eol,
                       void *userdata EINA_UNUSED)
{
   Source *source = NULL, *s;
   Eina_List *l;
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Source changed callback failure");
        return;
     }

   if (eol > 0)
      return;

   EINA_LIST_FOREACH(ctx->sources, l, s)
     {
        if (s->idx == (int)info->index)
          {
             source = s;
             break;
          }
     }

   DBG("source changed index: %d\n", info->index);

   if (!source)
     {
        source = calloc(1, sizeof(Source));
        EINA_SAFETY_ON_NULL_RETURN(source);
        ctx->sources = eina_list_append(ctx->sources, source);
     }
   source->idx = info->index;
   if (source->base.volume.channel_count != info->volume.channels)
     {
        for (i = 0; i < source->base.volume.channel_count; ++i)
          eina_stringshare_del(source->base.volume.channel_names[i]);
        free(source->base.volume.channel_names);
        source->base.volume.channel_names = calloc(info->volume.channels, sizeof(Emix_Channel));
     }
   _pa_cvolume_convert(&info->volume, &source->base.volume);
   for (i = 0; i < source->base.volume.channel_count; ++i)
     eina_stringshare_replace(&source->base.volume.channel_names[i],
                              pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   source->base.mute = !!info->mute;

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SOURCE_CHANGED_EVENT,
                  (Emix_Source *)source);
}

static void
_source_remove_cb(int index, void *data EINA_UNUSED)
{
   Source *source;
   Eina_List *l;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   DBG("Removing source: %d", index);

   EINA_LIST_FOREACH(ctx->sources, l, source)
     {
        if (source->idx == index)
          {
             ctx->sources = eina_list_remove_list(ctx->sources, l);
             if (ctx->cb)
               ctx->cb((void *)ctx->userdata, EMIX_SOURCE_REMOVED_EVENT,
                       (Emix_Source *)source);

             _source_del(source);
             break;
          }
     }
}

static void
_source_output_state_running_set(Source_Output *output, Eina_Bool running)
{
   output->running = running;
}

static void
_source_output_cb(pa_context *c EINA_UNUSED, const pa_source_output_info *info,
                  int eol, void *userdata EINA_UNUSED)
{
   Source_Output *output;
   Eina_List *l;
   Source *s;
   const char *t;
   unsigned int i;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
          return;

        ERR("Source output callback failure");
        return;
     }

   if (eol > 0)
      return;

   if ((info->name) &&
       ((!strcmp(info->name, "__e_mon")) ||
        (!strcmp(info->name, "Peak detect"))))
     return;

   output = calloc(1, sizeof(Source_Output));
   EINA_SAFETY_ON_NULL_RETURN(output);

   DBG("source output index: %d\nsink input name: %s", info->index,
       info->name);

   output->idx = info->index;
   output->source_idx = info->source;

   Eina_Strbuf *output_name;

   output_name = eina_strbuf_new();
   const char *application = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_NAME);
   if (application)
     {
        eina_strbuf_append(output_name, application);
        eina_strbuf_append(output_name, ":");
        eina_strbuf_append(output_name, info->name);
     }
   else if (info->name)
     {
        eina_strbuf_append(output_name, info->name);
     }
   output->base.name = eina_stringshare_add(eina_strbuf_string_get(output_name));
   eina_strbuf_free(output_name);
   _pa_cvolume_convert(&info->volume, &output->base.volume);
   output->base.volume.channel_names = calloc(output->base.volume.channel_count, sizeof(Emix_Channel));
   for (i = 0; i < output->base.volume.channel_count; ++i)
     output->base.volume.channel_names[i] = eina_stringshare_add(pa_channel_position_to_pretty_string(info->channel_map.map[i]));
   output->base.mute = !!info->mute;
   EINA_LIST_FOREACH(ctx->sources, l, s)
     {
        if (s->idx == (int)info->source)
          output->base.source = (Emix_Source *)s;
     }
   output->base.icon = eina_stringshare_add(_icon_from_properties(info->proplist));
   ctx->outputs = eina_list_append(ctx->outputs, output);

   if ((t = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_PROCESS_ID)))
     {
        output->base.pid = atoi(t);
     }
   if (!info->corked) _source_output_state_running_set(output, EINA_TRUE);
   else _source_output_state_running_set(output, EINA_FALSE);

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SOURCE_OUTPUT_ADDED_EVENT,
             (Emix_Source_Output *)output);
}

static void
_source_output_changed_cb(pa_context *c EINA_UNUSED,
                          const pa_source_output_info *info, int eol,
                          void *userdata EINA_UNUSED)
{
   Source_Output *output = NULL, *so;
   Source *s = NULL;
   Eina_List *l;
   const char *t;
   unsigned int i;

   EINA_SAFETY_ON_NULL_RETURN(ctx);
   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Source output changed callback failure");
        return;
     }

   if (eol > 0)
      return;

   if ((info->name) && (!strcmp(info->name, "__e_mon"))) return;

   EINA_LIST_FOREACH(ctx->outputs, l, so)
     {
        if (so->idx == (int)info->index)
          {
            output = so;
            break;
          }
     }

   DBG("source output changed index: %d\n", info->index);

   if (!output)
     {
        output = calloc(1, sizeof(Source_Output));
        EINA_SAFETY_ON_NULL_RETURN(output);
        ctx->outputs = eina_list_append(ctx->outputs, output);
     }
   output->idx = info->index;
   output->source_idx = info->source;
   if (output->base.volume.channel_count != info->volume.channels)
     {
        for (i = 0; i < output->base.volume.channel_count; ++i)
          eina_stringshare_del(output->base.volume.channel_names[i]);
        free(output->base.volume.channel_names);
        output->base.volume.channel_names = calloc(info->volume.channels, sizeof(Emix_Channel));
     }
   _pa_cvolume_convert(&info->volume, &output->base.volume);
   for (i = 0; i < output->base.volume.channel_count; ++i)
     eina_stringshare_replace(&output->base.volume.channel_names[i],
                              pa_channel_position_to_pretty_string(info->channel_map.map[i]));

   output->base.mute = !!info->mute;

   EINA_LIST_FOREACH(ctx->sources, l, s)
     {
        if (s->idx == (int)info->source)
          output->base.source = (Emix_Source *)s;
     }
   if ((t = pa_proplist_gets(info->proplist, PA_PROP_APPLICATION_PROCESS_ID)))
     {
        output->base.pid = atoi(t);
     }

   if (!info->corked) _source_output_state_running_set(output, EINA_TRUE);
   else _source_output_state_running_set(output, EINA_FALSE);

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_SOURCE_OUTPUT_CHANGED_EVENT,
             (Emix_Source_Output *)output);
}

static void
_source_output_remove_cb(int index, void *data EINA_UNUSED)
{
   Source_Output *output;
   Eina_List *l;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   DBG("Removing source output: %d", index);

   EINA_LIST_FOREACH(ctx->outputs, l, output)
     {
        if (output->idx == index)
          {
             ctx->outputs = eina_list_remove_list(ctx->outputs, l);
             if (ctx->cb)
               ctx->cb((void *)ctx->userdata,
                       EMIX_SOURCE_OUTPUT_REMOVED_EVENT,
                       (Emix_Source_Output *)output);
             _source_output_del(output);

             break;
          }
     }
}

static void
_sink_default_cb(pa_context *c EINA_UNUSED, const pa_sink_info *info, int eol,
                 void *userdata EINA_UNUSED)
{
   Sink *sink;
   Eina_List *l;

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Sink callback failure");
        return;
     }

   if (eol > 0)
      return;

   DBG("sink index: %d\nsink name: %s", info->index,
       info->name);

   EINA_LIST_FOREACH(ctx->sinks, l, sink)
     {
        Eina_Bool prev_default = sink->base.default_sink;
        sink->base.default_sink = (uint32_t)sink->idx == info->index;
        if (ctx->cb && (prev_default != sink->base.default_sink))
          ctx->cb((void *)ctx->userdata, EMIX_SINK_CHANGED_EVENT,
                  (Emix_Sink *)sink);
     }

   if (ctx->cb)
      ctx->cb((void *)ctx->userdata, EMIX_READY_EVENT, NULL);
}

static void
_source_default_cb(pa_context *c EINA_UNUSED, const pa_source_info *info, int eol,
                 void *userdata EINA_UNUSED)
{
   Source *source;
   Eina_List *l;

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Source callback failure");
        return;
     }

   if (eol > 0)
      return;

   DBG("source index: %d\nsource name: %s", info->index,
       info->name);

   EINA_LIST_FOREACH(ctx->sources, l, source)
     {
        Eina_Bool prev_default = source->base.default_source;
        source->base.default_source = (uint32_t)source->idx == info->index;
        if (ctx->cb && prev_default != source->base.default_source)
          ctx->cb((void *)ctx->userdata, EMIX_SOURCE_CHANGED_EVENT,
                  (Emix_Source *)source);
     }

   if (ctx->cb)
      ctx->cb((void *)ctx->userdata, EMIX_READY_EVENT, NULL);
}

static void
_server_info_cb(pa_context *c, const pa_server_info *info,
           void *userdata)
{
   pa_operation *o;

// this seems to trap old errors then forget to update defaults as below
//   if (pa_context_errno(c) != PA_OK)
//     {
//        WRN("Could not get pa server info, error: %d", pa_context_errno(c));
//        return;
//     }

   EINA_SAFETY_ON_NULL_RETURN(info);

   if (!(o = pa_context_get_sink_info_by_name(c, info->default_sink_name,
                                              _sink_default_cb, userdata)))
     {
        ERR("pa_context_get_sink_info_by_name() failed");
        return;
     }
   pa_operation_unref(o);

   if (!(o = pa_context_get_source_info_by_name(c, info->default_source_name,
                                              _source_default_cb, userdata)))
     {
        ERR("pa_context_get_source_info_by_name() failed");
        return;
     }
   pa_operation_unref(o);
}

static int
_profile_sort_cb(const Profile *p1, const Profile *p2)
{
   if (p1->priority < p2->priority) return 1;
   if (p1->priority > p2->priority) return -1;
   return 0;
}

static void
_card_cb(pa_context *c, const pa_card_info *info, int eol, void *userdata EINA_UNUSED)
{
     Card *card;
     const char *description;
     uint32_t i, j;
     Profile *profile;

     if (eol < 0) {
          if (pa_context_errno(c) == PA_ERR_NOENTITY)
            return;

          ERR("Card callback failure: %d", pa_context_errno(c));
          return;
     }
   if (eol > 0)
      return;

   card = calloc(1, sizeof(Card));
   EINA_SAFETY_ON_NULL_RETURN(card);

   card->idx = info->index;

   description = pa_proplist_gets(info->proplist, PA_PROP_DEVICE_DESCRIPTION);
   card->base.name = description
      ? eina_stringshare_add(description)
      : eina_stringshare_add(info->name);

   for (i = 0; i < info->n_ports; ++i)
     {
        for (j = 0; j < info->ports[i]->n_profiles; ++j)
          {
             profile = calloc(1, sizeof(Profile));
             profile->base.name = eina_stringshare_add(info->ports[i]->profiles[j]->name);
             profile->base.description = eina_stringshare_add(info->ports[i]->profiles[j]->description);
             profile->priority = info->ports[i]->profiles[j]->priority;
             if ((info->ports[i]->available == PA_PORT_AVAILABLE_NO)
               && ((strcmp("analog-output-speaker", profile->base.name))
                   || (strcmp("analog-input-microphone-internal", profile->base.name))))
                  profile->base.plugged = EINA_FALSE;
             else
               profile->base.plugged = EINA_TRUE;

             if (info->active_profile)
               {
                  if (info->ports[i]->profiles[j]->name == info->active_profile->name)
                    profile->base.active = EINA_TRUE;
               }
             card->base.profiles =
                eina_list_sorted_insert(card->base.profiles,
                                        (Eina_Compare_Cb)_profile_sort_cb,
                                        profile);
          }
     }
   ctx->cards = eina_list_append(ctx->cards, card);
   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_CARD_ADDED_EVENT,
             (Emix_Card *)card);
}

static void
_card_changed_cb(pa_context *c EINA_UNUSED, const pa_card_info *info, int eol,
                 void *userdata EINA_UNUSED)
{
   Card *card = NULL, *ca;
   Eina_List *l;
   const char *description;
   uint32_t i, j;
   Profile *profile;

   if (eol < 0)
     {
        if (pa_context_errno(c) == PA_ERR_NOENTITY)
           return;

        ERR("Card callback failure");
        return;
     }

   if (eol > 0)
      return;

   DBG("card index: %d\n", info->index);

   EINA_LIST_FOREACH(ctx->cards, l, ca)
     {
        if (ca->idx == (int)info->index)
          {
             card = ca;
             break;
          }
     }

   EINA_SAFETY_ON_NULL_RETURN(card);

   description = pa_proplist_gets(info->proplist, PA_PROP_DEVICE_DESCRIPTION);
   eina_stringshare_replace(&card->base.name,
                            (description
                             ? eina_stringshare_add(description)
                             : eina_stringshare_add(info->name)));

   EINA_LIST_FREE(card->base.profiles, profile)
     {
        eina_stringshare_del(profile->base.name);
        eina_stringshare_del(profile->base.description);
        free(profile);
     }
   for (i = 0; i < info->n_ports; ++i)
     {
        for (j = 0; j < info->ports[i]->n_profiles; ++j)
          {
             profile = calloc(1, sizeof(Profile));
             profile->base.name = eina_stringshare_add(info->ports[i]->profiles[j]->name);
             profile->base.description = eina_stringshare_add(info->ports[i]->profiles[j]->description);
             profile->priority = info->ports[i]->profiles[j]->priority;
             if ((info->ports[i]->available == PA_PORT_AVAILABLE_NO)
               && ((strcmp("analog-output-speaker", profile->base.name))
                   || (strcmp("analog-input-microphone-internal", profile->base.name))))
                  profile->base.plugged = EINA_FALSE;
             else
               profile->base.plugged = EINA_TRUE;

             if (info->active_profile)
               {
                  if (info->ports[i]->profiles[j]->name == info->active_profile->name)
                    profile->base.active = EINA_TRUE;
               }
             card->base.profiles =
                eina_list_sorted_insert(card->base.profiles,
                                        (Eina_Compare_Cb)_profile_sort_cb,
                                        profile);
          }
     }

   if (ctx->cb)
     ctx->cb((void *)ctx->userdata, EMIX_CARD_CHANGED_EVENT,
                  (Emix_Card *)card);
}

static void
_card_remove_cb(int index, void *data EINA_UNUSED)
{
   Card *card;
   Eina_List *l;
   EINA_SAFETY_ON_NULL_RETURN(ctx);

   DBG("Removing card: %d", index);

   EINA_LIST_FOREACH(ctx->cards, l, card)
     {
        if (card->idx == index)
          {
             ctx->cards = eina_list_remove_list(ctx->cards, l);
             if (ctx->cb)
               ctx->cb((void *)ctx->userdata,
                       EMIX_CARD_REMOVED_EVENT,
                       (Emix_Card *)card);
             _card_del(card);

             break;
          }
     }
}


static void
_subscribe_cb(pa_context *c, pa_subscription_event_type_t t,
              uint32_t index, void *data)
{
   pa_operation *o;

   switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
    case PA_SUBSCRIPTION_EVENT_SINK:
       if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
           PA_SUBSCRIPTION_EVENT_REMOVE)
          _sink_remove_cb(index, data);
       else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
                PA_SUBSCRIPTION_EVENT_NEW)
         {
            if (!(o = pa_context_get_sink_info_by_index(c, index,
                                                        _sink_cb, data)))
              {
                 ERR("pa_context_get_sink_info_by_index() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       else
         {
            if (!(o = pa_context_get_sink_info_by_index(c, index,
                                                        _sink_changed_cb,
                                                        data)))
              {
                 ERR("pa_context_get_sink_info_by_index() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       break;

    case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
       if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
           PA_SUBSCRIPTION_EVENT_REMOVE)
          _sink_input_remove_cb(index, data);
       else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
                PA_SUBSCRIPTION_EVENT_NEW)
         {
            if (!(o = pa_context_get_sink_input_info(c, index,
                                                     _sink_input_cb, data)))
              {
                 ERR("pa_context_get_sink_input_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       else
         {
            if (!(o = pa_context_get_sink_input_info(c, index,
                                                     _sink_input_changed_cb,
                                                     data)))
              {
                 ERR("pa_context_get_sink_input_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       break;

    case PA_SUBSCRIPTION_EVENT_SOURCE:
       if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
           PA_SUBSCRIPTION_EVENT_REMOVE)
          _source_remove_cb(index, data);
       else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
                PA_SUBSCRIPTION_EVENT_NEW)
         {
            if (!(o = pa_context_get_source_info_by_index(c, index,
                                                          _source_cb, data)))
              {
                 ERR("pa_context_get_source_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       else
         {
            if (!(o = pa_context_get_source_info_by_index(c, index,
                                                          _source_changed_cb,
                                                          data)))
              {
                 ERR("pa_context_get_source_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       break;
    case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT:
       if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
           PA_SUBSCRIPTION_EVENT_REMOVE)
          _source_output_remove_cb(index, data);
       else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
                PA_SUBSCRIPTION_EVENT_NEW)
         {
            if (!(o = pa_context_get_source_output_info(c, index,
                                                        _source_output_cb, data)))
              {
                 ERR("pa_context_get_source_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       else
         {
            if (!(o = pa_context_get_source_output_info(c, index,
                                                        _source_output_changed_cb,
                                                        data)))
              {
                 ERR("pa_context_get_source_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       break;
    case PA_SUBSCRIPTION_EVENT_SERVER:
       if (!(o = pa_context_get_server_info(c, _server_info_cb,
                                            data)))
         {
            ERR("pa_context_get_server_info() failed");
            return;
         }
       pa_operation_unref(o);
       break;

    case PA_SUBSCRIPTION_EVENT_CARD:
       if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
           PA_SUBSCRIPTION_EVENT_REMOVE)
           _card_remove_cb(index, data);
       else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) ==
                PA_SUBSCRIPTION_EVENT_NEW)
         {
            if (!(o = pa_context_get_card_info_by_index(c, index, _card_cb,
                                                        data)))
              {
                 ERR("pa_context_get_card_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       else
         {
            if (!(o = pa_context_get_card_info_by_index(c, index, _card_changed_cb,
                                                        data)))
              {
                 ERR("pa_context_get_card_info() failed");
                 return;
              }
            pa_operation_unref(o);
         }
       break;

    default:
       WRN("Event not handled");
       break;
   }
}

static Eina_Bool _pulse_connect(void *data);
static void _disconnect_cb(void);

static void
_pulse_pa_state_cb(pa_context *context, void *data)
{
   pa_operation *o;

   switch (pa_context_get_state(context))
     {
      case PA_CONTEXT_UNCONNECTED:
      case PA_CONTEXT_CONNECTING:
      case PA_CONTEXT_AUTHORIZING:
      case PA_CONTEXT_SETTING_NAME:
         break;

      case PA_CONTEXT_READY:
        ctx->connect = NULL;
        ctx->connected = EINA_TRUE;
        pa_context_set_subscribe_callback(context, _subscribe_cb, ctx);
        if (!(o = pa_context_subscribe(context, (pa_subscription_mask_t)
                                       (PA_SUBSCRIPTION_MASK_SINK|
                                        PA_SUBSCRIPTION_MASK_SOURCE|
                                        PA_SUBSCRIPTION_MASK_SINK_INPUT|
                                        PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT|
                                        PA_SUBSCRIPTION_MASK_CLIENT|
                                        PA_SUBSCRIPTION_MASK_SERVER|
                                        PA_SUBSCRIPTION_MASK_CARD),
                                       NULL, NULL)))
          {
             ERR("pa_context_subscribe() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_sink_info_list(context, _sink_cb, ctx)))
          {
             ERR("pa_context_get_sink_info_list() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_sink_input_info_list(context,
                                                      _sink_input_cb,
                                                      ctx)))
          {
             ERR("pa_context_get_sink_input_info_list() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_source_info_list(context, _source_cb,
                                                  ctx)))
          {
             ERR("pa_context_get_source_info_list() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_source_output_info_list(context, _source_output_cb,
                                                         ctx)))
          {
             ERR("pa_context_get_source_output_info_list() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_server_info(context, _server_info_cb,
                                             ctx)))
          {
             ERR("pa_context_get_server_info() failed");
             return;
          }
        pa_operation_unref(o);

        if (!(o = pa_context_get_card_info_list(context, _card_cb,
                                             ctx)))
          {
             ERR("pa_context_get_server_info() failed");
             return;
          }
        pa_operation_unref(o);



        break;

      case PA_CONTEXT_FAILED:
         WRN("PA_CONTEXT_FAILED");
         if (!ctx->connect)
           ctx->connect = ecore_timer_loop_add(1, _pulse_connect, data);
         goto err;

      case PA_CONTEXT_TERMINATED:
         ERR("PA_CONTEXT_TERMINATE:");
         EINA_FALLTHROUGH;
        /* no break */

      default:
         if (ctx->connect)
           {
              ecore_timer_del(ctx->connect);
              ctx->connect = NULL;
           }
         goto err;
     }
   return;

err:
   if (ctx->connected)
     {
        _disconnect_cb();
        ctx->connected = EINA_FALSE;
     }
   pa_context_unref(ctx->context);
   ctx->context = NULL;
}

static Eina_Bool
_pulse_connect(void *data)
{
   pa_proplist *proplist;
   Context *c = data;
   Eina_Bool ret = ECORE_CALLBACK_DONE;

   printf("PULSE CONN...\n");
   proplist = pa_proplist_new();
   pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, "Efl Volume Control");
   pa_proplist_sets(proplist, PA_PROP_APPLICATION_ID,
                    "org.enlightenment.volumecontrol");
   pa_proplist_sets(proplist, PA_PROP_APPLICATION_ICON_NAME, "audio-card");
#if !defined(EMIXER_BUILD) && defined(HAVE_WAYLAND) && !defined(HAVE_WAYLAND_ONLY)
   char *display = NULL;

   if (e_comp->comp_type != E_PIXMAP_TYPE_X)
     {
        display = getenv("DISPLAY");
        if (display) display = strdup(display);
        e_env_unset("DISPLAY");
     }
#endif
   c->context = pa_context_new_with_proplist(&(c->api), NULL, proplist);
   if (c->context)
     {
        pa_context_set_state_callback(c->context, _pulse_pa_state_cb, c);
        if (pa_context_connect(c->context, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0)
          {
             ret = EINA_TRUE;
             ERR("Could not connect to pulse");
          }
     }
#if !defined(EMIXER_BUILD) && defined(HAVE_WAYLAND) && !defined(HAVE_WAYLAND_ONLY)
   if (e_comp->comp_type != E_PIXMAP_TYPE_X)
     {
        if (display)
          {
             e_env_set("DISPLAY", display);
             free(display);
          }
     }
#endif

   pa_proplist_free(proplist);
   return ret;
}

static Eina_Bool pulse_started = EINA_FALSE;

static void
_shutdown(void)
{
   if (!ctx)
      return;
   if (pulse_started)
     {
        ecore_exe_run("pulseaudio -k", NULL);
        pulse_started = EINA_FALSE;
     }

   if (ctx->connect)
     {
        ecore_timer_del(ctx->connect);
        ctx->connect = NULL;
     }
   if (ctx->context)
      pa_context_unref(ctx->context);
   if (ctx->connected)
      _disconnect_cb();
   free(ctx);
   ctx = NULL;
}

static Eina_Bool
_init(Emix_Event_Cb cb, const void *data)
{
   if (ctx)
     return EINA_TRUE;

   ctx = calloc(1, sizeof(Context));
   if (!ctx)
     {
        ERR("Could not create Epulse Context");
        return EINA_FALSE;
     }

   ctx->api = functable;
   ctx->api.userdata = ctx;

   if (_pulse_connect(ctx) == EINA_TRUE) // true == failed and try again
     {
        if (!pulse_started)
          ecore_exe_run("pulseaudio --start", NULL);
        pulse_started = EINA_TRUE;
     }

   ctx->cb = cb;
   ctx->userdata = data;

   return EINA_TRUE;
 }

static void
_disconnect_cb()
{
   Source *source;
   Sink *sink;
   Sink_Input *input;
   Card *card;

   if (ctx->cb)
      ctx->cb((void *)ctx->userdata, EMIX_DISCONNECTED_EVENT, NULL);

   EINA_LIST_FREE(ctx->sources, source)
      _source_del(source);
   EINA_LIST_FREE(ctx->sinks, sink)
      _sink_del(sink);
   EINA_LIST_FREE(ctx->inputs, input)
      _sink_input_del(input);
   EINA_LIST_FREE(ctx->cards, card)
      _card_del(card);
}

static void
_source_volume_set(Emix_Source *source, Emix_Volume *volume)
{
   pa_operation* o;
   pa_cvolume vol = _emix_volume_convert(volume);
   Source *s = (Source *)source;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && source != NULL);

   if (!(o = pa_context_set_source_volume_by_index(ctx->context,
                                                   s->idx, &vol,
                                                   NULL, NULL)))
      ERR("pa_context_set_source_volume_by_index() failed");
}

static void
_source_mute_set(Emix_Source *source, Eina_Bool mute)
{
   pa_operation* o;
   Source *s = (Source *)source;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && source != NULL);

   if (!(o = pa_context_set_source_mute_by_index(ctx->context,
                                                 s->idx, mute, NULL, NULL)))
      ERR("pa_context_set_source_mute() failed");
}

static const Eina_List *
_sinks_get(void)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   return ctx->sinks;
}

static const Eina_List *
_sources_get(void)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   return ctx->sources;
}

static void
_sink_volume_set(Emix_Sink *sink, Emix_Volume *volume)
{
   pa_operation* o;
   Sink *s = (Sink *)sink;
   pa_cvolume vol = _emix_volume_convert(volume);
   EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->context && sink != NULL));

   if (!(o = pa_context_set_sink_volume_by_index(ctx->context,
                                                 s->idx, &vol, NULL, NULL)))
      ERR("pa_context_set_sink_volume_by_index() failed");
}

static void
_sink_mute_set(Emix_Sink *sink, Eina_Bool mute)
{
   pa_operation* o;
   Sink *s = (Sink *)sink;
   EINA_SAFETY_ON_FALSE_RETURN((ctx && ctx->context && sink != NULL));

   if (!(o = pa_context_set_sink_mute_by_index(ctx->context,
                                               s->idx, mute, NULL, NULL)))
      ERR("pa_context_set_sink_mute() failed");
}

static const Eina_List *
_sink_inputs_get(void)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   return ctx->inputs;
}

static void
_sink_input_volume_set(Emix_Sink_Input *input, Emix_Volume *volume)
{
   pa_operation* o;
   Sink_Input *sink_input = (Sink_Input *)input;
   pa_cvolume vol = _emix_volume_convert(volume);
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && input != NULL);

   if (!(o = pa_context_set_sink_input_volume(ctx->context,
                                              sink_input->idx, &vol,
                                              NULL, NULL)))
      ERR("pa_context_set_sink_input_volume_by_index() failed");
}

static void
_sink_input_mute_set(Emix_Sink_Input *input, Eina_Bool mute)
{
   pa_operation* o;
   Sink_Input *sink_input = (Sink_Input *)input;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && input != NULL);

   if (!(o = pa_context_set_sink_input_mute(ctx->context,
                                            sink_input->idx, mute,
                                            NULL, NULL)))
      ERR("pa_context_set_sink_input_mute() failed");
}

static void
_sink_input_move(Emix_Sink_Input *input, Emix_Sink *sink)
{
   pa_operation* o;
   Sink *s = (Sink *)sink;
   Sink_Input *i = (Sink_Input *)input;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && input != NULL
                               && sink != NULL);

   if (!(o = pa_context_move_sink_input_by_index(ctx->context,
                                                 i->idx, s->idx, NULL,
                                                 NULL)))
      ERR("pa_context_move_sink_input_by_index() failed");
}

static const Eina_List *
_source_outputs_get(void)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   return ctx->outputs;
}

static void
_source_output_volume_set(Emix_Source_Output *output, Emix_Volume *volume)
{
   pa_operation* o;
   Source_Output *source_output = (Source_Output *)output;
   pa_cvolume vol = _emix_volume_convert(volume);
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && output != NULL);

   if (!(o = pa_context_set_source_output_volume(ctx->context,
                                                 source_output->idx, &vol,
                                                 NULL, NULL)))
      ERR("pa_context_set_source_output_volume_by_index() failed");
}

static void
_source_output_mute_set(Emix_Source_Output *output, Eina_Bool mute)
{
   pa_operation* o;
   Source_Output *source_output = (Source_Output *)output;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && output != NULL);

   if (!(o = pa_context_set_source_output_mute(ctx->context,
                                               source_output->idx, mute,
                                               NULL, NULL)))
      ERR("pa_context_set_source_output_mute() failed");
}

static void
_source_output_move(Emix_Source_Output *output, Emix_Source *source)
{
   pa_operation* o;
   Source *s = (Source *)source;
   Source_Output *i = (Source_Output *)output;
   EINA_SAFETY_ON_FALSE_RETURN(ctx && ctx->context && output != NULL
                               && source != NULL);

   if (!(o = pa_context_move_source_output_by_index(ctx->context,
                                                    i->idx, s->idx, NULL,
                                                    NULL)))
      ERR("pa_context_move_source_output_by_index() failed");
}

static Eina_Bool
_sink_port_set(Emix_Sink *sink, const Emix_Port *port)
{
   pa_operation* o;
   Sink *s = (Sink *)sink;
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ctx && ctx->context &&
                                   sink != NULL && port != NULL, EINA_FALSE);

   if (!(o = pa_context_set_sink_port_by_index(ctx->context,
                                               s->idx, port->name, NULL,
                                               NULL)))
     {
        ERR("pa_context_set_source_port_by_index() failed");
        return EINA_FALSE;
     }
   pa_operation_unref(o);

   return EINA_TRUE;
}

static Eina_Bool
_sink_default_support(void)
{
   return EINA_TRUE;
}

static const Emix_Sink *
_sink_default_get(void)
{
   Sink *s;
   Eina_List *l;

   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   EINA_LIST_FOREACH(ctx->sinks, l, s)
      if (s->base.default_sink)
        return (Emix_Sink *)s;

   return NULL;
}

static void
_sink_default_set(Emix_Sink *sink)
{
  Sink *s = (Sink *)sink;
  pa_operation* o;

  DBG("Set default sink: %s", sink->name);
  if (!(o = pa_context_set_default_sink(ctx->context, s->pulse_name, NULL, NULL))) {
      ERR("pa_context_set_default_sink() failed");
      return;
  }
  pa_operation_unref(o);
}

static Eina_Bool
_source_default_support(void)
{
   return EINA_TRUE;
}

static const Emix_Source *
_source_default_get(void)
{
   Source *s;
   Eina_List *l;

   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   EINA_LIST_FOREACH(ctx->sources, l, s)
      if (s->base.default_source)
        return (Emix_Source *)s;

   return NULL;
}

static void
_source_default_set(Emix_Source *source)
{
  Source *s = (Source *)source;
  pa_operation* o;

  DBG("Set default sink: %s", source->name);
  if (!(o = pa_context_set_default_source(ctx->context, s->pulse_name, NULL, NULL))) {
      ERR("pa_context_set_default_source() failed");
      return;
  }
  pa_operation_unref(o);
}

static Eina_Bool
_sink_change_support(void)
{
   return EINA_TRUE;
}

static int
_max_volume(void)
{
   return 150;
}

static const Eina_List *
_cards_get(void)
{
   EINA_SAFETY_ON_NULL_RETURN_VAL(ctx, NULL);
   return ctx->cards;
}

static Eina_Bool
_card_profile_set(Emix_Card *card, const Emix_Profile *profile)
{
   pa_operation* o;
   Card *c = (Card *)card;
   Profile *p = (Profile *)profile;
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ctx && ctx->context &&
                                   (c != NULL) && (p != NULL), EINA_FALSE);

   if (!(o = pa_context_set_card_profile_by_index(ctx->context,
                                                  c->idx, p->base.name, NULL,
                                                  NULL)))
     {
        ERR("pa_context_set_card_profile_by_index() failed");
        return EINA_FALSE;
     }
   pa_operation_unref(o);

   return EINA_TRUE;
}

static void
_sink_mon_read(pa_stream *stream, size_t bytes EINA_UNUSED, void *data)
{
   Sink *s = data;
   size_t rbytes;
   const void *buf = NULL;

   if (pa_stream_peek(stream, &buf, &rbytes) == 0)
     {
        if ((!buf) && (rbytes))
          {
             pa_stream_drop(stream);
             return;
          }
        s->base.mon_num = (unsigned int)((rbytes / sizeof(float)) / 2);
        s->base.mon_buf = buf;
        if (ctx->cb)
          ctx->cb((void *)ctx->userdata, EMIX_SINK_MONITOR_EVENT, s);
        pa_stream_drop(stream);
     }
}

static void
_sink_monitor_begin(Sink *s)
{
   pa_sample_spec samp;
   pa_buffer_attr attr;

   if (pa_context_get_server_protocol_version(ctx->context) < 13) return;

   pa_sample_spec_init(&samp);
   samp.format = PA_SAMPLE_FLOAT32;
   samp.rate = 44100;
   samp.channels = 2;
   memset(&attr, 0, sizeof(attr));
   attr.fragsize = sizeof(float) * 4096;
   attr.maxlength = (uint32_t) -1;

   s->mon_stream = pa_stream_new(ctx->context, "__e_mon", &samp, NULL);
   pa_stream_set_read_callback(s->mon_stream, _sink_mon_read, s);
   pa_context_set_source_mute_by_name(ctx->context, s->monitor_source_name, 0, NULL, NULL);
   pa_stream_connect_record(s->mon_stream, s->monitor_source_name,
                            &attr,
                            PA_STREAM_NOFLAGS
                            | PA_STREAM_DONT_MOVE
                            | PA_STREAM_ADJUST_LATENCY
                            | PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
                           );
}

static void
_sink_monitor_end(Sink *s)
{
   if (s->mon_stream)
     {
        if (s->mon_stream) pa_stream_disconnect(s->mon_stream);
        s->mon_stream = NULL;
     }
}

static void
_sink_monitor_set(Emix_Sink *sink, Eina_Bool monitor)
{
   Sink *s = (Sink *)sink;
   EINA_SAFETY_ON_NULL_RETURN(ctx);
   if (monitor) s->mon_count++;
   else s->mon_count--;
   if (s->mon_count < 0) s->mon_count = 0;
   if (s->mon_count == 1)
     {
        if (s->running) _sink_monitor_begin(s);
     }
   else if (s->mon_count == 0) _sink_monitor_end(s);
}

static void
_sink_input_mon_read(pa_stream *stream, size_t bytes EINA_UNUSED, void *data)
{
   Sink_Input *i = data;
   size_t rbytes;
   const void *buf = NULL;

   if (pa_stream_peek(stream, &buf, &rbytes) == 0)
     {
        if ((!buf) && (rbytes))
          {
             pa_stream_drop(stream);
             return;
          }
        i->base.mon_num = (unsigned int)((rbytes / sizeof(float)) / 2);
        i->base.mon_buf = buf;
        if (ctx->cb)
          ctx->cb((void *)ctx->userdata, EMIX_SINK_INPUT_MONITOR_EVENT, i);
        pa_stream_drop(stream);
     }
}

static void
_sink_input_monitor_begin(Sink_Input *i)
{
   pa_sample_spec samp;
   pa_buffer_attr attr;
   char buf[16];
   Eina_List *l;
   Sink *s;
   unsigned int mon_idx = 0;

   if (pa_context_get_server_protocol_version(ctx->context) < 13) return;

   pa_sample_spec_init(&samp);
   samp.format = PA_SAMPLE_FLOAT32;
   samp.rate = 44100;
   samp.channels = 2;
   memset(&attr, 0, sizeof(attr));
   attr.fragsize = sizeof(float) * 4096;
   attr.maxlength = (uint32_t) -1;

   i->mon_stream = pa_stream_new(ctx->context, "__e_mon", &samp, NULL);
   pa_stream_set_monitor_stream(i->mon_stream, i->idx);
   pa_stream_set_read_callback(i->mon_stream, _sink_input_mon_read, i);
   EINA_LIST_FOREACH(ctx->sinks, l, s)
     {
        if (i->sink_idx == s->idx)
          {
             mon_idx = s->monitor_idx;
             break;
          }
     }
   if (!l) return;
   snprintf(buf, sizeof(buf), "%i", mon_idx);
   pa_context_set_source_mute_by_name(ctx->context, buf, 0, NULL, NULL);
   pa_stream_connect_record(i->mon_stream, buf,
                            &attr,
                            PA_STREAM_NOFLAGS
                            | PA_STREAM_DONT_MOVE
                            | PA_STREAM_ADJUST_LATENCY
                            | PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
                           );
}

static void
_sink_input_monitor_end(Sink_Input *i)
{
   if (i->mon_stream)
     {
        if (i->mon_stream) pa_stream_disconnect(i->mon_stream);
        i->mon_stream = NULL;
     }
}

static void
_sink_input_monitor_set(Emix_Sink_Input *input, Eina_Bool monitor)
{
   Sink_Input *i = (Sink_Input *)input;
   EINA_SAFETY_ON_NULL_RETURN(ctx);
   if (monitor) i->mon_count++;
   else i->mon_count--;
   if (i->mon_count < 0) i->mon_count = 0;
   if (i->mon_count == 1)
     {
        if (i->running) _sink_input_monitor_begin(i);
     }
   else if (i->mon_count == 0) _sink_input_monitor_end(i);
}

static void
_source_mon_read(pa_stream *stream, size_t bytes EINA_UNUSED, void *data)
{
   Source *s = data;
   size_t rbytes;
   const void *buf = NULL;

   if (pa_stream_peek(stream, &buf, &rbytes) == 0)
     {
        if ((!buf) && (rbytes))
          {
             pa_stream_drop(stream);
             return;
          }
        s->base.mon_num = (unsigned int)((rbytes / sizeof(float)) / 2);
        s->base.mon_buf = buf;
        if (ctx->cb)
          ctx->cb((void *)ctx->userdata, EMIX_SOURCE_MONITOR_EVENT, s);
        pa_stream_drop(stream);
     }
}

static void
_source_monitor_begin(Source *s)
{
   pa_sample_spec samp;
   pa_buffer_attr attr;
   char buf[16];

   if (pa_context_get_server_protocol_version(ctx->context) < 13) return;

   pa_sample_spec_init(&samp);
   samp.format = PA_SAMPLE_FLOAT32;
   samp.rate = 44100;
   samp.channels = 2;
   memset(&attr, 0, sizeof(attr));
   attr.fragsize = sizeof(float) * 4096;
   attr.maxlength = (uint32_t) -1;

   s->mon_stream = pa_stream_new(ctx->context, "__e_mon", &samp, NULL);
   pa_stream_set_read_callback(s->mon_stream, _source_mon_read, s);
   snprintf(buf, sizeof(buf), "%i", s->idx);
   pa_stream_connect_record(s->mon_stream, buf,
                            &attr,
                            PA_STREAM_NOFLAGS
                            | PA_STREAM_DONT_MOVE
                            | PA_STREAM_ADJUST_LATENCY
                           );
}

static void
_source_monitor_end(Source *s)
{
   if (s->mon_stream)
     {
        if (s->mon_stream) pa_stream_disconnect(s->mon_stream);
        s->mon_stream = NULL;
     }
}

static void
_source_monitor_set(Emix_Source *source, Eina_Bool monitor)
{
   Source *s = (Source *)source;
   EINA_SAFETY_ON_NULL_RETURN(ctx);
   if (monitor) s->mon_count++;
   else s->mon_count--;
   if (s->mon_count < 0) s->mon_count = 0;
   if (s->mon_count == 1) _source_monitor_begin(s);
   else if (s->mon_count == 0) _source_monitor_end(s);
}

static Emix_Backend
_pulseaudio_backend =
{
   _init,
   _shutdown,
   _max_volume,
   _sinks_get,
   _sink_default_support,
   _sink_default_get,
   _sink_default_set,
   _sink_mute_set,
   _sink_volume_set,
   _sink_port_set,
   _sink_change_support,
   _sink_inputs_get,
   _sink_input_mute_set,
   _sink_input_volume_set,
   _sink_input_move,
   _sources_get,
   _source_default_support,
   _source_default_get,
   _source_default_set,
   _source_mute_set,
   _source_volume_set,
   _source_outputs_get,
   _source_output_mute_set,
   _source_output_volume_set,
   _source_output_move,
   NULL,
   _cards_get,
   _card_profile_set,
   _sink_monitor_set,
   _sink_input_monitor_set,
   _source_monitor_set
};

E_API Emix_Backend *
emix_backend_pulse_get(void)
{
   return &_pulseaudio_backend;
}

E_API const char *emix_backend_pulse_name = "PULSEAUDIO";