[DllImport ("gstreamer-0.10.dll") ]
static extern bool gst_bin_add (IntPtr raw, IntPtr element);

[DllImport ("libgobject-2.0-0.dll") ]
static extern IntPtr g_object_ref (IntPtr raw);

public bool Add (Gst.Element element) {
  bool raw_ret = gst_bin_add (Handle, element == null ? IntPtr.Zero : element.Handle);
  if (raw_ret) {
    // Incrmenting the refcount of the element.
    g_object_ref (element.Handle);
  }
  bool ret = raw_ret;
  return ret;
}

public bool Add (params Element[] elements) {
  if (elements == null) {
    return false;
  }

  foreach (Element element in elements) {
    if (element == null || !Add (element)) {
      return false;
    }
  }

  return true;
}

public bool Remove (params Element[] elements) {
  if (elements == null) {
    return false;
  }

  foreach (Element element in elements) {
    if (element == null || !Remove (element)) {
      return false;
    }
  }

  return true;
}

public Gst.Element GetByInterface (System.Type type) {
  if (!type.IsSubclassOf (typeof (GLib.GInterfaceAdapter)))
    return null;

  GLib.GType t = (GLib.GType) type;

  return GetByInterface (t);
}

[DllImport ("gstreamer-0.10.dll") ]
static extern int gst_iterator_next (IntPtr iterator, out IntPtr elem);
[DllImport ("gstreamer-0.10.dll") ]
static extern void gst_iterator_resync (IntPtr iterator);
[DllImport ("gstreamer-0.10.dll") ]
static extern void gst_iterator_free (IntPtr iterator);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_elements (IntPtr bin);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_recurse (IntPtr bin);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_sinks (IntPtr bin);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_sorted (IntPtr bin);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_sources (IntPtr bin);
[DllImport ("gstreamer-0.10.dll") ]
static extern IntPtr gst_bin_iterate_all_by_interface (IntPtr bin, IntPtr gtype);

private class ElementEnumerable : IEnumerable {
  private class ElementEnumerator : IEnumerator {
    Hashtable seen = new Hashtable ();
    IntPtr iterator;

    private object current = null;
    public object Current {
      get {
        return current;
      }
    }

    public bool MoveNext () {
      IntPtr raw_ret;
      bool retry = false;

      if (iterator == IntPtr.Zero)
        return false;

      do {
        int ret = gst_iterator_next (iterator, out raw_ret);
        switch (ret) {
          case 0:
            return false;
          case 1:
            if (seen.Contains (raw_ret)) {
              retry = true;
              break;
            }

            seen.Add (raw_ret, null);
            current = GLib.Object.GetObject (raw_ret, true);
            return true;
          case 2:
            gst_iterator_resync (iterator);
            break;
          default:
          case 3:
            throw new Exception ("Error while iterating bin");
        }
      } while (retry);

      return false;
    }

    public void Reset () {
      seen.Clear ();
      if (iterator != IntPtr.Zero)
        gst_iterator_resync (iterator);
    }

    public ElementEnumerator (IntPtr iterator) {
      this.iterator = iterator;
    }
  }

  private IntPtr iterator;
  private ElementEnumerator enumerator;

  public ElementEnumerable (IntPtr iterator) {
    this.iterator = iterator;
    this.enumerator = new ElementEnumerator (iterator);
  }

  public IEnumerator GetEnumerator () {
    return enumerator;
  }

  ~ElementEnumerable () {
    if (iterator != IntPtr.Zero)
      gst_iterator_free (iterator);
  }
}

public IEnumerable Elements {
  get {
    return new ElementEnumerable (gst_bin_iterate_elements (Handle));
  }
}

public IEnumerable ElementsRecurse {
  get {
    return new ElementEnumerable (gst_bin_iterate_recurse (Handle));
  }
}

public IEnumerable ElementsSorted {
  get {
    return new ElementEnumerable (gst_bin_iterate_sorted (Handle));
  }
}

public IEnumerable SinkElements {
  get {
    return new ElementEnumerable (gst_bin_iterate_sinks (Handle));
  }
}

public IEnumerable SourceElements {
  get {
    return new ElementEnumerable (gst_bin_iterate_sources (Handle));
  }
}

public IEnumerable GetAllByInterface (GLib.GType type) {
  return new ElementEnumerable (gst_bin_iterate_all_by_interface (Handle, type.Val));
}

public IEnumerable GetAllByInterface (System.Type type) {
  if (!type.IsSubclassOf (typeof (GLib.GInterfaceAdapter)))
    return null;

  GLib.GType t = (GLib.GType) type;

  return GetAllByInterface (t);
}