# partial port of autodepgraphapi.py

class GraphWatchers # throw this one away; use AutoDependencies

  constructor: ->

    @handlersSp = {} # {s: {p: [handlers]}}

  subscribe: (s, p, o, onChange) -> # return subscription handle

    if o? then throw Error('not implemented')

    if not @handlersSp[s]

      @handlersSp[s] = {}

    if not @handlersSp[s][p]

      @handlersSp[s][p] = []

    @handlersSp[s][p].push(onChange)

    handle = {s: s, p: p, func: onChange}

    return handle

  unsubscribe: (subscription) ->

    spList = @handlersSp[subscription.s][subscription.p]

    i = spList.indexOf(subscription.func)

    if i == -1

      throw new Error('subscription not found')

    spList.splice(i, 1)

  matchingHandlers: (quad) ->

    matches = []

    for subjDict in [@handlersSp[quad.subject] || {}, @handlersSp[null] || {}]

      for subjPredMatches in [subjDict[quad.predicate] || [], subjDict[null] || []]

        matches = matches.concat(subjPredMatches)

    return matches

  graphChanged: (patch) ->

    for quad in patch.delQuads

      for cb in @matchingHandlers(quad)

        # currently calls multiple times, which is ok, but we might

        # group things into fewer patches

        cb({delQuads: [quad], addQuads: []})

    for quad in patch.addQuads

      for cb in @matchingHandlers(quad)

        cb({delQuads: [], addQuads: [quad]})

    @_watchers = new GraphWatchers() # old

    @_watchers.graphChanged(patch)

  subscribe: (s, p, o, onChange) -> # return subscription handle

    throw

    # onChange is called with a patch that's limited to the quads

    # that match your request.

    # We call you immediately on existing triples.

    handle = @_watchers.subscribe(s, p, o, onChange)

    immediatePatch = {delQuads: [], addQuads: @graph.findByIRI(s, p, o)}

    if immediatePatch.addQuads.length

      onChange(immediatePatch)

    return handle

  unsubscribe: (subscription) ->

    @_watchers.unsubscribe(subscription)