# Polymer seems to need static getters for 'observers' and

# 'properties', not just static attributes, though I don't know how it

# can even tell the difference.

#

# This workaround is to use names like '@getter_properties' in the

# class then register with this function that fixes them.

# Also see http://coffeescript.org/#unsupported-get-set

window.coffeeElementSetup = (cls) ->

  for attr in ['properties', 'observers']

    val = cls['getter_' + attr]

    if val?

      do (val) ->

  customElements.define(cls.is, cls)

      console.log(e)

    unhighlight()

coffeeElementSetup(class EditChoice extends Polymer.Element

)

  constructor: (@func, @label) ->

    @patterns = [] # s,p,o,g quads that should trigger the next run

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

class AutoDependencies

  constructor: () ->

    @handlerStack = [@handlers] # currently running

  runHandler: (func, label) ->

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

    if not label?

    #  console.trace('read outside runHandler')

class window.SyncedGraph

  # Main graph object for a browser to use. Syncs both ways with

  # rdfdb. Meant to hide the choice of RDF lib, so we can change it

  # later.

  # Note that _applyPatch is the only method to write to the graph, so

  # it can fire subscriptions.

  constructor: (@patchSenderUrl, @prefixes, @setStatus) ->

    # patchSenderUrl is the /syncedGraph path of an rdfdb server.

    # prefixes can be used in Uri(curie) calls.

    if @graph?

      @_applyPatch({addQuads: [], delQuads: @graph.getQuads()})

    # if we had a Store already, this lets N3.Store free all its indices/etc

    @graph = N3.Store()

    @_addPrefixes(@prefixes)

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

    log('graph: clearGraphOnNewConnection')

    @clearGraph()

    log('graph: clearGraphOnNewConnection done')

    parseFloat(literal.value)

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

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

    parser = N3.Parser()

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

  quads: () -> # for debugging

    [q.subject, q.predicate, q.object, q.graph] for q in @graph.getQuads()

  applyAndSendPatch: (patch) ->

    console.time('applyAndSendPatch')

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

        if not q.subject.id or not q.graph.id? or not q.predicate.id?

          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

      did = @graph.removeQuad(quad)

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

    for quad in patch.addQuads

      @graph.addQuad(quad)

    #log('applied patch locally', patchSizeSummary(patch))

    @_autoDeps.graphChanged(patch)

      @_autoDeps.askedFor(current, null, null, null) # a little loose

      firsts = @graph.getQuads(current, RDF + 'first', null)

      rests = @graph.getQuads(current, RDF + 'rest', null)

      if firsts.length != 1

      out.push(firsts[0].object)

      if rests.length != 1

      current = rests[0].object

    return out

  contains: (s, p, o) ->

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

        results.push(uri)

        if results.length >= howMany

          return results

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

  nextNumberedResource: (base) ->

  contextsWithPattern: (s, p, o) ->

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

    ctxs = []

    for q in @graph.getQuads(s, p, o)

      ctxs.push(q.graph)

      hand = ->

        called++

        graph.uriValue(A1, A2)

      graph.runHandler(hand, 'run')

      graph.applyAndSendPatch({

        delQuads: [quad(A1, A2, A3)], addQuads: [quad(A1, A2, A4)]})

    it 'notices new queries a handler makes upon rerun', ->

      called = 0

      objsFound = []

      hand = ->

        called++

        called++

        graph.uriValue(A1, A2)

        throw new Error('this test handler throws an error')

      graph.runHandler(hand, 'run')

      graph.applyAndSendPatch({

        delQuads: [quad(A1, A2, A3)], addQuads: [quad(A1, A2, A4)]})

    describe 'works with nested handlers', ->

      innerResults = []

      inner = ->

        console.log('\nninnerfetch')

      describe 'items', ->

        it 'when the list order changes', (done) ->

          values = []

          successes = 0

          hand = ->

              head = graph.uriValue(U('x'), U('y'))

            catch

              # graph goes empty between clearGraph and loadTrig

              return

            values.push(graph.items(head))

            successes++

          graph.clearGraph()

          graph.loadTrig "

            @prefix : <http://example.com/> .

            :ctx { :x :y (:a1 :a2 :a3) } .

          ", () ->

              @prefix : <http://example.com/> .

              :ctx { :x :y (:a1 :a3 :a2) } .

            ", () ->

      describe 'contains', ->

        it 'when a new triple is added', ->

          values = []

          hand = -> values.push(graph.contains(A1, A1, A1))

          graph.runHandler(hand, 'run')

    writer.addQuads(jsPatch.addQuads)

    writer.end((err, result) ->

      out.patch.adds = result

      cb())

  async.parallel([writeDels, writeAdds], (err) ->

parseJsonPatch = (jsonPatch, cb) ->

  # note response cb doesn't have an error arg.

  input = JSON.parse(jsonPatch)

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

  parseAdds = (cb) =>

    parser = N3.Parser()

    parser.parse input.patch.adds, (error, quad, prefixes) =>

  parseDels = (cb) =>

    parser = N3.Parser()

    parser.parse input.patch.deletes, (error, quad, prefixes) =>

  async.parallel([parseAdds, parseDels], ((err) => cb(patch)))

class window.RdfDbClient

  # Send and receive patches from rdfdb

    @_patchesToSend = []

    @_lastPingMs = -1

    @_patchesReceived = 0

    @_patchesSent = 0

    @_reconnectionTimeout = null

      #{ping}ms")

  sendPatch: (patch) ->

    console.log('rdfdbclient: queue patch to server ', patchSizeSummary(patch))

    @_patchesToSend.push(patch)

    @_updateStatus()

  _newConnection: ->

    wsOrWss = window.location.protocol.replace('http', 'ws')

    fullUrl = wsOrWss + '//' + window.location.host + @patchSenderUrl

    @ws.close() if @ws?

    @ws = new WebSocket(fullUrl)

      return

    # we could call this less often and coalesce patches together to optimize

    # the dragging cases.

    sendOne = (patch, cb) =>

      )

    async.eachSeries(@_patchesToSend, sendOne, () =>

  ctor2: () ->

    # config has:

    #   getTarget -> vec2 of current target position

    #   getSuggestedTargetOffset -> vec2 pixel offset from target

    #   emptyBox -> true if you want no value display

    # updated later by layout algoritm

    @centerOffset = $V([0, 0])

  getDisplayValue: () ->

    return '' if @config.emptyBox

    defaultFormat = d3.format(".4g")(@_getValue())

    if @config.getDisplayValue?

    defaultFormat

  getSuggestedCenter: () ->

    @getTarget().add(@config.getSuggestedTargetOffset())

  getCenter: () -> # vec2 of pixels

    @getTarget().add(@centerOffset)

  getTarget: () -> # vec2 of pixels

    @config.getTarget()

  subscribe: (onChange) ->

    # change could be displayValue or center or target. This likely

    # calls onChange right away if there's any data yet.

    throw new Error('not implemented')

  startDrag: () ->

    @initialTarget = @getTarget()

  continueDrag: (pos) ->

    ## pos is vec2 of pixels relative to the drag start

    @targetDraggedTo = pos.add(@initialTarget)

  endDrag: () ->

    # override

  _editorCoordinates: () -> # vec2 of mouse relative to <l9-t-editor>

    return @targetDraggedTo

    ev = d3.event.sourceEvent

      rootElem = ev.target

    else

      rootElem = ev.target.closest('light9-timeline-editor')

    if ev.touches?.length

      ev = ev.touches[0]

    # storing root on the object to remember it across calls in case

    # you drag outside the editor.

    @root = rootElem.getBoundingClientRect() if rootElem

    offsetParentPos = $V([ev.pageX - @root.left, ev.pageY - @root.top])

class window.AdjustableFloatObservable extends Adjustable

  constructor: (@config) ->

    # config also has:

    #   observable -> ko.observable we will read and write

    #   getValueForPos(pos) -> what should we set to if the user

    #                          moves target to this coord?

    super()

    @ctor2()

  _getValue: () ->

    @config.observable()

  continueDrag: (pos) ->

    # pos is vec2 of pixels relative to the drag start.

    super(pos)

    epos = @_editorCoordinates()

    newValue = @config.getValueForPos(epos)

    @config.observable(newValue)

    #   getTargetPosForValue(value) -> getTarget result for value

    #   getValueForPos

    super()

    @ctor2()

    if not @config.ctx?

      throw new Error("missing ctx")

  _syncValue: () ->

    @_currentValue = @config.graph.floatValue(@config.subj, @config.pred)

    @_onChange() if @_onChange

  _getValue: () ->

    # this is a big speedup- callers use _getValue about 4x as much as

    # the graph changes and graph.floatValue is slow

    @_currentValue

  getTarget: () ->

    @config.getTargetPosForValue(@_getValue())

  subscribe: (onChange) ->

    # only works on one subscription at a time

    throw new Error('multi subscribe not implemented') if @_onChange

    @_onChange = onChange

  continueDrag: (pos) ->

    # pos is vec2 of pixels relative to the drag start

    super(pos)

    newValue = @config.getValueForPos(@_editorCoordinates())

    @config.graph.patchObject(@config.subj, @config.pred,

                              @config.graph.LiteralRoundedFloat(newValue),

                              @config.ctx)

class window.AdjustableFade extends Adjustable

  constructor: (@yForV, @i0, @i1, @note, offset, ctx) ->

    super()

    @config = {

      getSuggestedTargetOffset: -> offset

      getTarget: @getTarget.bind(@)

    $V([@note.zoomInX(mid.e(1)), @yForV(mid.e(2))])

  _getValue: ->

    mid = @note.worldPts[@i0].x(.5).add(@note.worldPts[@i1].x(.5))

    mid.e(1)

    # pos is vec2 of pixels relative to the drag start

    super(pos)

    graph = @note.graph

    goalCenterSec = @note.zoomInX.invert(@initialTarget.e(1) + pos.e(1))

    diamSec = @note.worldPts[@i1].e(1) - @note.worldPts[@i0].e(1)

    newSec0 = goalCenterSec - diamSec / 2

    newSec1 = goalCenterSec + diamSec / 2

        adj.startDrag()

  onMove: (ev) ->

    pos = $V([ev.x, ev.y])

    if @currentDrag

      @currentDrag.cur = pos

  onUp: (ev) ->

    return unless @currentDrag

    @currentDrag.adj.endDrag()

    @currentDrag = null

    @ctx.font = "12px sans"

    @ctx.fillStyle = '#000'

    @ctx.fillText(label, x1 + 5, y2 - 5, x2 - x1 - 10)

    # coords from a center that's passed in

    # l/r arrows

    # mouse arrow cursor upon hover, and accent the hovered adjuster

    # connector

)

window.Drawing.line = (ctx, p1, p2) ->

  ctx.moveTo(p1.e(1), p1.e(2))

  ctx.lineTo(p2.e(1), p2.e(2))

# http://stackoverflow.com/a/4959890

window.Drawing.roundRect = (ctx, sx,sy,ex,ey,r) ->

  constructor: (@graph) ->

  makeEffect: (uri) ->

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

    effect = U(uri.value + '/effect')

    quad = (s, p, o) => @graph.Quad(s, p, o, effect)

    quads = [

      quad(effect, U('rdf:type'), U(':Effect')),

      quad(effect, U(':copiedFrom'), uri),

      quad(effect, U('rdfs:label'), @graph.Literal(uri.replace(/.*capture\//, ''))),

      quad(effect, U(':publishAttr'), U(':strength')),

      ]

    fromSettings = @graph.objects(uri, U(':setting'))

    toSettings = @graph.nextNumberedResources(effect + '_set', fromSettings.length)

    for fs in fromSettings

      ts = toSettings.pop()

      # full copies of these since I may have to delete captures

      quads.push(quad(effect, U(':setting'), ts))

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

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

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

    return effect

  makeNewNote: (song, effect, dropTime, desiredWidthT) ->

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

    quad = (s, p, o) => @graph.Quad(s, p, o, song)

    newNote = @graph.nextNumberedResource("#{song.value}/n")

    newCurve = @graph.nextNumberedResource("#{newNote.value}c")

    points = @graph.nextNumberedResources("#{newCurve.value}p", 4)

    curveQuads = [

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

        quad(newNote, U('rdf:type'), U(':Note'))

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

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

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

        quad(newCurve, U('rdf:type'), U(':Curve'))

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

    pointQuads = []

    for i in [0...4]

      pt = points[i]

      pointQuads.push(quad(newCurve, U(':point'), pt))

      pointQuads.push(quad(pt, U(':time'), @graph.LiteralRoundedFloat(i/3 * desiredWidthT)))

      pointQuads.push(quad(pt, U(':value'), @graph.LiteralRoundedFloat(i == 1 or i == 2)))

    patch = {

      delQuads: []

      addQuads: curveQuads.concat(pointQuads)

      }

    @graph.applyAndSendPatch(patch)

  getCurvePoints: (curve, xOffset) ->

    worldPts = []

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

    for pt in uris

      tm = @graph.floatValue(pt, @graph.Uri(':time'))

      val = @graph.floatValue(pt, @graph.Uri(':value'))

    return [uris, worldPts]

  curveWidth: (worldPts) ->

    tMin = @graph.floatValue(worldPts[0].uri, @graph.Uri(':time'))

    tMax = @graph.floatValue(worldPts[3].uri, @graph.Uri(':time'))

    tMax - tMin

  deleteNote: (song, note, selection) ->

    patch = {delQuads: [@graph.Quad(song, graph.Uri(':note'), note, song)], addQuads: []}

    @graph.applyAndSendPatch(patch)

    if note in selection.selected()

      selection.selected(_.without(selection.selected(), note))

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}

    '_onSetAdjuster(setAdjuster)',

  ]

  constructor: ->

    super()

    @viewState = new ViewState()

    window.viewState = @viewState

  ready: ->

    super.ready()

    @addEventListener 'mousedown', (ev) => @$.adjustersCanvas.onDown(ev)

    @addEventListener 'mousemove', (ev) => @$.adjustersCanvas.onMove(ev)

    @addEventListener 'mouseup', (ev) => @$.adjustersCanvas.onUp(ev)

    ko.options.deferUpdates = true

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

    window.debug_zoomOrLayoutChangedCount = 0

    window.debug_adjUpdateDisplay = 0

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

    @trackMouse()

    @bindKeys()

    @bindWheelZoom(@)

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

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

    Polymer.RenderStatus.afterNextRender this, =>

      setupDrop(@$.zoomed.$.rows, @$.zoomed.$.rows, @, @$.zoomed.onDrop.bind(@$.zoomed))