@innerHandlers = [] # Handlers requested while this one was running

class AutoDependencies

  constructor: () ->

    @handlers = new Handler(null) # tree of all known Handlers (at least those with non-empty patterns). Top node is not a handler.

    @handlerStack = [@handlers] # currently running

  runHandler: (func, label) ->

    # what if we have this func already? duplicate is safe?

    h = new Handler(func, label)

    @handlerStack[@handlerStack.length - 1].innerHandlers.push(h)

    @_rerunHandler(h, null)

  _rerunHandler: (handler, patch) ->

    handler.patterns = []

    @handlerStack.push(handler)

    try

      handler.func(patch)

    catch e

      log('error running handler: ', e)

      # assuming here it didn't get to do all its queries, we could

      # add a *,*,*,* handler to call for sure the next time?

    finally

      #log('done. got: ', handler.patterns)

    song:  { type: String, notify: true }

    zoomInX: { type: Object, notify: true }

    noteUris: { type: Array, notify: true }

    rowIndex: { type: Object, notify: true }

  observers: [

    'onGraph(graph, dia, setAdjuster, song, zoomInX)'

    'update(song, rowIndex)'

    'onZoom(zoomInX)'

    ]

  onGraph: ->

    @graph.runHandler(@update.bind(@), "row notes #{@rowIndex}")

  update: (patch) ->

    U = (x) -> @graph.Uri(x)

    notesForThisRow = []

    i = 0

    for n in _.sortBy(@graph.objects(@song, U(':note')))

      if (i % ROW_COUNT) == @rowIndex

        notesForThisRow.push(n)

      i++

    updateChildren @, notesForThisRow, (newUri) =>

      child = document.createElement('light9-timeline-note')

      child.graph = @graph

      child.dia = @dia

      child.uri = newUri

      child.setAdjuster = @setAdjuster

      child.song = @song # could change, but all the notes will be rebuilt

      child.zoomInX = @zoomInX # missing binding; see onZoom

      return child      

  onZoom: ->

    for e in @children

      e.zoomInX = @zoomInX

getCurvePoints = (graph, curve, xOffset) ->

  worldPts = []

  uris = graph.objects(curve, graph.Uri(':point'))

  for pt in uris

    v = $V([xOffset + graph.floatValue(pt, graph.Uri(':time')),

            graph.floatValue(pt, graph.Uri(':value'))])

      setting = @graph.nextNumberedResource(@uri + 'set')

      patch = {delQuads: [], addQuads: [

        quad(@uri, U(':setting'), setting)

        quad(setting, U(':effectAttr'), U(':colorScale'))

        quad(setting, U(':value'), settingValue)

        ]}

      @graph.applyAndSendPatch(patch)

  addHandler: ->

    @graph.runHandler(@update.bind(@))

  update: ->

    U = (x) -> @graph.Uri(x)

    @effect = @graph.uriValue(@uri, U(':effectClass'))

    @effectLabel = @effect.replace(/.*\//, '')

    @noteLabel = @uri.replace(/.*\//, '')

    @existingColorScaleSetting = null

    for setting in @graph.objects(@uri, U(':setting'))

      ea = @graph.uriValue(setting, U(':effectAttr'))

      value = @graph.stringValue(setting, U(':value'))

      if ea == U(':colorScale')

        @colorScaleFromGraph = value

        @colorScale = value

        @existingColorScaleSetting = setting

    if @existingColorScaleSetting == null

      @colorScaleFromGraph = '#ffffff'

      @colorScale = '#ffffff'

  onDel: ->

    patch = {delQuads: [{subject: @song, predicate: @graph.Uri(':note'), object: @uri, graph: @song}], addQuads: []}

    @graph.applyAndSendPatch(patch)

class deleteme

  go: ->

    visible: { type: Boolean, notify: true }

    displayValue: { type: String }