{Deferred} = require('./promise')
EventEmitter = require('events').EventEmitter

###*
# @module rtc.internal
###
###*
# Helper handling the mapping of streams for RemotePeer
# @class rtc.internal.StreamCollection
#
# @constructor
###
class exports.StreamCollection extends EventEmitter

  ###*
  # A new stream was added to the collection
  # @event steam_added
  # @param {String} name The user defined name of the stream
  # @param {Promise -> rtc.Stream} stream Promise to the stream
  ###

  constructor: () ->
    ###*
    # Contains the promises which will resolve to the streams
    # @property {Object} streams
    ###
    @streams = {}

    @_defers = {}
    @_waiting = {}
    @_pending = {}

    @wait_d = new Deferred()
    @wait_p = @wait_d.promise


  ###*
  # Set stream description and generate promises
  # @method update
  # @param data {Object} An object mapping the stream ids to stream names
  ###
  update: (data) ->
    members = []
    @_waiting = {}

    # remove old streams

    for name, stream_p in @streams
      if not data[name]?
        # remove

        delete @streams[name]
        @emit('stream_removed', name)

        # close/fail

        # TODO: this does not work anymore ...
        if stream_p.isFullfilled()
          stream_p.then (stream) ->
            stream.close()
        else if stream_p.isPending()
          stream_p.reject(new Error("Stream removed before being established"))

    # update mappings

    for name, id of data
      # does stream exist?

      if not @streams[name]?
        # create stream promise

        defer = new Deferred()

        @streams[name] = defer.promise
        @_defers[name] = defer

        @emit('stream_added', name, defer.promise)

      # do we adjust stream initialization?

      if @_defers[name]?
        if @_pending[id]?
          # got it!

          stream = @_pending[id]
          delete @_pending[id]

          @_defers[name].resolve(stream)
          delete @_defers[name]

        else
          # add waiting mapping

          @_waiting[id] = name

    @wait_d.resolve()


  ###*
  # Add stream to the collection and resolve promises waiting for it
  # @method resolve
  # @param {rtc.Stream} stream
  ###
  resolve: (stream) ->
    id = stream.id()

    # streams from Chrome to Firefox are coming in with id set to 'default' ...
    if id == 'default'
      if Object.keys(@streams).length == 1 and Object.keys(@_waiting).length == 1
        console.log("Working around incompatibility between Firefox and Chrome concerning stream identification")
        id = Object.keys(@_waiting)[0]
      else
        console.log("Unable to work around incompatibility between Firefox and Chrome concerning stream identification")

    if @_waiting[id]?
      # stream is expected

      name = @_waiting[id]
      delete @_waiting[id]

      @_defers[name].resolve(stream)
      delete @_defers[name]

    else
      # lets hope someone wants this later ...

      @_pending[id] = stream


  ###*
  # Gets a promise for a stream with the given name. Might be rejected after `update()`
  #
  # @method get
  # @param {String} name
  # @return {Promise} The promise for the `rtc.Stream`
  ###
  get: (name) ->
    @wait_p.then () =>
      if @streams[name]?
        return @streams[name]
      else
        throw new Error("Stream not offered")