_clearGraphOnNewConnection: -> # must not send a patch to the server!

    log('graph: clearGraphOnNewConnection')

    @clearGraph()

    log('graph: clearGraphOnNewConnection done')

  _addPrefixes: (prefixes) ->

    for k in (prefixes or {})

      @prefixes[k] = prefixes[k]

    @prefixFuncs = N3.Util.prefixes(@prefixes)

  Uri: (curie) ->

    if curie.match(/^http/)

      return N3.DataFactory.namedNode(curie)

    part = curie.split(':')

    return @prefixFuncs(part[0])(part[1])

  Literal: (jsValue) ->

    N3.DataFactory.literal(jsValue)

  LiteralRoundedFloat: (f) ->

    N3.DataFactory.literal(d3.format(".3f")(f),

  Quad: (s, p, o, g) -> N3.DataFactory.quad(s, p, o, g)

  toJs: (literal) ->

    # incomplete

    parseFloat(literal.value)

  loadTrig: (trig, cb) -> # for debugging

    patch = {delQuads: [], addQuads: []}

    parser = N3.Parser()

    parser.parse trig, (error, quad, prefixes) =>

                  if error

    @_validatePatch(patch)

    @_applyPatch(patch)

    @_client.sendPatch(patch) if @_client

    console.timeEnd('applyAndSendPatch')

  _validatePatch: (patch) ->

    for qs in [patch.addQuads, patch.delQuads]

      for q in qs

        if not q.equals

          throw new Error("doesn't look like a proper Quad")

          throw new Error("corrupt patch: #{JSON.stringify(q)}")

  _applyPatch: (patch) ->

    # In most cases you want applyAndSendPatch.

    # 

    # This is the only method that writes to @graph!

    @cachedFloatValues.clear()

    for quad in patch.delQuads

      #log("remove #{JSON.stringify(quad)}")      

      did = @graph.removeQuad(quad)

      #log("removed: #{did}")

    for quad in patch.addQuads

      if rests.length != 1

        throw new Error("list node #{current} has #{rests.length} rdf:rest edges")

      current = rests[0].object

    return out

  contains: (s, p, o) ->

    @_autoDeps.askedFor(s, p, o, null)

    return @graph.getQuads(s, p, o).length > 0

  nextNumberedResources: (base, howMany) ->

    results = []

    # we could cache [base,lastSerial]

    for serial in [0..1000]

      uri = @Uri("#{base}#{serial}")

      if not @contains(uri, null, null)

        results.push(uri)

        if results.length >= howMany

          return results

    throw new Error("can't make sequential uri with base #{base}")

  nextNumberedResource: (base) ->

    @nextNumberedResources(base, 1)[0]       

      }

      svg {

          width: 100%;

          height: 30px;

      }

    </style>

    <svg id="timeAxis" xmlns="http://www.w3.org/2000/svg">

      <g id="axis" transform="translate(0,30)"></g>    

    </svg>

  </template>

</dom-module>

<!-- All the adjusters you can edit or select. Tells a light9-adjusters-canvas how to draw them. Probabaly doesn't need to be an element.

     This element manages their layout and suppresion.

     Owns the selection.

     Maybe includes selecting things that don't even have adjusters.

     Maybe manages the layout of other labels and text too, to avoid overlaps.

   -->

<dom-module id="light9-timeline-adjusters">

  <template>

    <style>

     :host {

         pointer-events: none; /* restored on the individual adjusters */

     }

    </style>

  </template>

</dom-module>

<script src="/lib/async/dist/async.js"></script>

<script src="/lib/knockout/dist/knockout.js"></script>

<script src="/lib/shortcut/index.js"></script>

<script src="/lib/sylvester/sylvester.js"></script>

<script src="/lib/underscore/underscore-min.js"></script>

<script src="/node_modules/d3/dist/d3.min.js"></script>

<script src="/node_modules/n3/n3-browser.js"></script> 

      try

        quads.push(quad(ts, U(':value'), @graph.uriValue(fs, U(':value'))))

      catch

        quads.push(quad(ts, U(':scaledValue'), @graph.uriValue(fs, U(':scaledValue'))))

    @graph.applyAndSendPatch({delQuads: [], addQuads: quads})

    return effect

  makeNewNote: (effect, dropTime, desiredWidthT) ->

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

    quad = (s, p, o) => {subject: s, predicate: p, object: o, graph: @song}

    curveQuads = [

        quad(@song, U(':note'), newNote)

        quad(newNote, RDF + 'type', U(':Note'))

        quad(newNote, U(':originTime'), @graph.LiteralRoundedFloat(dropTime))

        quad(newNote, U(':effectClass'), effect)

        quad(newNote, U(':curve'), newCurve)

        quad(newCurve, RDF + 'type', U(':Curve'))

        quad(newCurve, U(':attr'), U(':strength'))

      ]        

    pointQuads = []

coffeeElementSetup(class TimelineEditor extends Polymer.mixinBehaviors([Polymer.IronResizableBehavior], Polymer.Element)

  @is: 'light9-timeline-editor'

  @getter_properties:

    viewState: { type: Object }

    debug: {type: String}

    graph: {type: Object, notify: true}

    project: {type: Object}

    setAdjuster: {type: Function, notify: true}

    playerSong: {type: String, notify: true}

    followPlayerSong: {type: Boolean, notify: true, value: true}

    song: {type: String, notify: true}

    songTime: {type: Number, notify: true}

    songDuration: {type: Number, notify: true}

    songPlaying: {type: Boolean, notify: true}

    selection: {type: Object, notify: true}

  @getter_observers: [

    '_onSong(playerSong, followPlayerSong)',

    '_onGraph(graph)',

    '_onSongDuration(songDuration, viewState)',

    '_onSongTime(songTime, viewState)',

    '_onSetAdjuster(setAdjuster)',

  ]

  constructor: ->

    super()

    @viewState = new ViewState()

    window.viewState = @viewState

  ready: ->

    super.ready()

    @selection = {hover: ko.observable(null), selected: ko.observable([])}

    window.debug_zoomOrLayoutChangedCount = 0

    window.debug_adjUpdateDisplay = 0

    ko.computed(@zoomOrLayoutChanged.bind(@))

    @trackMouse()

    @bindKeys()

    @bindWheelZoom(@$.adjustersCanvas)

  _onSongTime: (t) ->

    @viewState.cursor.t(t)

  _onSongDuration: (d) ->

    d = 700 if d < 1 # bug is that asco isn't giving duration, but 0 makes the scale corrupt

    @viewState.zoomSpec.duration(d)

  _onSong: (s) ->

    @song = @playerSong if @followPlayerSong

  _onGraph: (graph) ->

    @project = new Project(graph)

  _onSetAdjuster: () ->

    @makeZoomAdjs()

  updateDebugSummary: ->

    elemCount = (tag) -> document.getElementsByTagName(tag).length

    @debug = "#{window.debug_zoomOrLayoutChangedCount} layout change,

     #{elemCount('light9-timeline-note')} notes,

     #{@selection.selected().length} selected

     #{elemCount('light9-timeline-graph-row')} rows,

     #{window.debug_adjsCount} adjuster items registered,

     #{window.debug_adjUpdateDisplay} adjuster updateDisplay calls,

    "

  zoomOrLayoutChanged: ->

    vs = @viewState

    dependOn = [vs.zoomSpec.t1(), vs.zoomSpec.t2(), vs.width()]

    @$.zoomed.gatherNotes() if @$.zoomed?.gatherNotes?

    # todo: these run a lot of work purely for a time change

    if @$.zoomed?.$?.audio?

      #@dia.setTimeAxis(vs.width(), @$.zoomed.$.audio.offsetTop, vs.zoomInX)

      @$.adjustersCanvas.updateAllCoords()

  trackMouse: ->

    # not just for show- we use the mouse pos sometimes

    for evName in ['mousemove', 'touchmove']

      @addEventListener evName, (ev) =>

        ev.preventDefault()

      @viewState.onMouseWheel(ev.deltaY)

  bindKeys: ->

    shortcut.add "Ctrl+P", (ev) =>

      @$.music.seekPlayOrPause(@viewState.latestMouseTime())

    shortcut.add "Ctrl+Escape", => @viewState.frameAll()

    shortcut.add "Shift+Escape", => @viewState.frameToEnd()

    shortcut.add "Escape", => @viewState.frameCursor()

    shortcut.add "L", =>

      @$.adjustersCanvas.updateAllCoords()

    shortcut.add 'Delete', =>

      for note in @selection.selected()

  makeZoomAdjs: ->

    yMid = => @$.audio.offsetTop + @$.audio.offsetHeight / 2

    valForPos = (pos) =>

        x = pos.e(1)

        t = @viewState.fullZoomX.invert(x)

    @setAdjuster('zoom-left', => new AdjustableFloatObservable({

      observable: @viewState.zoomSpec.t1,

      getTarget: () =>

        $V([@viewState.fullZoomX(@viewState.zoomSpec.t1()), yMid()])

      getSuggestedTargetOffset: () => $V([50, 0])

    @renderer = PIXI.autoDetectRenderer({

         backgroundColor: 0x606060,

        antialias: true,

        forceCanvas: true,

    })

  ready: ->

    super.ready()

    @addEventListener('iron-resize', @_onResize.bind(@))

    Polymer.RenderStatus.afterNextRender(this, @_onResize.bind(@))

    ko.computed =>

      @stage.setTransform(0, -(@viewState.rowsY()), 1, 1, 0, 0, 0, 0, 0)

  _onResize: ->

    @renderer.resize(@clientWidth, @clientHeight)

    @renderer.render(@stage)

  _onGraph: ->

    @graph.runHandler(@gatherNotes.bind(@), 'zoom notes')

  gatherNotes: ->

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

    @stage.removeChildren()

    n.destroy() for n in @notes

    @notes = []

    noteNum = 0

      con = new PIXI.Container()

      @stage.addChild(con)

      row = noteNum % 6

      rowTop = @viewState.rowsY() + 20 + 150 * row

      @notes.push(note)

      noteNum = noteNum + 1

    @renderer.render(@stage)

  onDrop: (effect, pos) ->

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

    return unless effect and effect.match(/^http/)

    # we could probably accept some initial overrides right on the

    # effect uri, maybe as query params

      dependOn = [@viewState.zoomSpec.t1(), @viewState.zoomSpec.t2()]

      pxPerTick = 50

      axis = d3.axisTop(@viewState.zoomInX).ticks(@viewState.width() / pxPerTick)

      d3.select(@$.axis).call(axis)

)

# Maintains a pixi object and some adjusters corresponding to a note

# in the graph.

class Note

  constructor: (@container, @project, @graph, @selection, @uri, @setAdjuster, @song, @viewState, @rowTopY, @rowBotY) ->

    @adjusterIds = {} # id : true

  destroy: ->

    log('destroy', @uri.value)

    @isDetached = true

    @clearAdjusters()

  clearAdjusters: ->

    for i in Object.keys(@adjusterIds)

      @setAdjuster(i, null)

  getCurvePoints: (subj, curveAttr) ->

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