#
# EventEmitter -- emit event for event-driven programming
#
# All classes which emit event will extend the EventEmitter class
#
class EventEmitter
  # private _listeners
  #
  # All listeners is stored to _listeners.
  # Listener is composed of env and func.
  #
  #     { env: [Object], func: [Function] }
  #
  # Listeners are composed of some events (each event has Listener array)
  #
  #     { eventName:
  #         [ { env: [Object], func: [Function] },
  #           { env: [Object], func: [Function] } ],
  #       eventName2:
  #         [ { ... }, { ... } ] }
  #
  @_listeners

  # static listen_once_suffix = '-once'
  #
  # the listener which is invoked only once is stored in
  # eventName + listen_once_suffix
  @listen_once_suffix: '-once'

  constructor: () ->
    @_listeners = {}

  # add event listener
  #
  # @param event    : event name
  # @param env      : to bind enviroment. otherwise "this" variable
  # @param listener : a function which is passed some arguments or no
  #
  addListener: (event, env, listener) ->
    unless @_listeners[event]?
      @_listeners[event] = []

    @_listeners[event].push(env: env, func: listener)

  # on event
  # alias for addListener
  on: (event, env, listener) ->
    this.addListener(
      event,
      env,
      listener
    )

  # do listener once on event
  #
  # @param event    : event name
  # @param env      : to bind enviroment. otherwise "this" variable
  # @param listener : a function which is passed some arguments or no
  #
  once: (event, env, listener) ->
    this.addListener(
      event + EventEmitter.listen_once_suffix,
      env,
      listener
    )

  # remove specified listener from event
  #
  # @param event    : event name
  # @param env      : binded enviroment
  # @param listener : a function which is passed some arguments or no
  #
  removeListener: (event, env, listener) ->
    # event
    if @_listeners[event]?
      @_listeners[event] = @_listeners[event].filter (listeners) ->
        listeners.env != env || listeners.func != listener

    # event-once
    event_once = event + EventEmitter.listen_once_suffix
    if @_listeners[event_once]?
      @_listeners[event_once] = @_listeners[event_once].filter (listeners) ->
        listeners.env != env || listeners.func != listener

  # remove all listener from event
  #
  # @param event : event name
  #
  removeAllListener: (event) ->
    # event
    if @_listeners[event]?
      delete @_listeners[event]

    # event-once
    event_once = event + EventEmitter.listen_once_suffix
    if @_listeners[event_once]
      delete @_listeners[event_once]

  # get listeners
  #
  # @return specified event listeners
  #
  listeners: (event) ->
    @_listeners[event]

  # get all listeners (for debug)
  allListeners: () ->
    @_listeners

  # issue the event
  #
  # @param event : event name
  # @param args : pass to listeners
  #
  emit: (event, args...) ->
    # event
    if @_listeners[event]?
      for listener in @_listeners[event]
        listener.func.apply(listener.env, args)

    # event-once
    if @_listeners[event + EventEmitter.listen_once_suffix]?
      for listener in @_listeners[event + EventEmitter.listen_once_suffix]
        listener.func.apply(listener.env, args)
      # the listeners invoked are deleted
      delete @_listeners[event + EventEmitter.listen_once_suffix]


# test main object
class Object3D extends EventEmitter
  constructor: (@name) ->
    super

  collide: () ->
    this.emit('collision', 'Object3D')

  addCollisionListener: (env, func) ->
    this.on('collision', env, func)


# test other object
class AnotherObject3D
  constructor: (@objName) ->

  collideNotice: (data) ->
    console.log "#{@objName} is collided by #{data}"


mainObj = new Object3D('testObject')
otherObj1 = new AnotherObject3D('another1')
otherObj2 = new AnotherObject3D('another2')
otherObj3 = new AnotherObject3D('another3')
mainObj.addCollisionListener(otherObj1, otherObj1.collideNotice)
mainObj.addCollisionListener(otherObj2, otherObj2.collideNotice)
mainObj.addCollisionListener(otherObj3, otherObj3.collideNotice)
mainObj.collide()
mainObj.removeListener('collision', otherObj2, otherObj2.collideNotice)
mainObj.collide()


# ee = new EventEmitter()
#
# ee.once 'hoge', this, (data) ->
#   console.log "hello! #{data}"
#
# hello2 = (err, data) ->
#   console.log "hello2! #{data}"
# ee.on 'hoge', this, hello2
# ee.removeListener('hoge', this, hello2)
#
# ee.on 'hoge', this, (data) ->
#   console.log "world!"
#
# # ee.removeAllListener('hoge')
#
# ee.on 'hoge', (deta) ->
#   console.log "another world!"
#
# ee.emit('hoge')
# ee.emit('hoge')
#
# console.log ee.allListeners()