# 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)

      else

        null

    try

      onDrop(uri, pos)

    catch e

      console.log(e)

    unhighlight()

coffeeElementSetup(class EditChoice extends Polymer.Element

)

# (sloppily shared to rdfdbclient.coffee too)

window.patchSizeSummary = patchSizeSummary

class Handler

  # a function and the quad patterns it cared about

  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?

      throw new Error("missing label")

    h = new Handler(func, label)

    tailChildren = @handlerStack[@handlerStack.length - 1].innerHandlers

    matchingLabel = _.filter(tailChildren, ((c) -> c.label == label)).length

    # ohno, something depends on some handlers getting run twice :(

    # quads in the given pattern.

    current = @handlerStack[@handlerStack.length - 1]

    if current? and current != @handlers

      current.patterns.push([s, p, o, g])

      #log('push', s,p,o,g)

    #else

    #  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.

    @_autoDeps = new AutoDependencies() # replaces GraphWatchers

    @clearGraph()

    if @patchSenderUrl

      @_client = new RdfDbClient(@patchSenderUrl,

                                 @_clearGraphOnNewConnection.bind(@),

                                 @_applyPatch.bind(@),

                                 @setStatus)

  clearGraph: ->

    # just deletes the statements; watchers are unaffected.

    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')

  _addPrefixes: (prefixes) ->

    for k in (prefixes or {})

      @prefixes[k] = prefixes[k]

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

  Uri: (curie) ->

                          @Uri("http://www.w3.org/2001/XMLSchema#double"))

  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) =>

  quads: () -> # for debugging

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

  applyAndSendPatch: (patch) ->

    console.time('applyAndSendPatch')

    if !Array.isArray(patch.addQuads) || !Array.isArray(patch.delQuads)

      console.timeEnd('applyAndSendPatch')

      log('corrupt patch')

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

    @_validatePatch(patch)

    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")

        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)

  getObjectPatch: (s, p, newObject, g) ->

    # make a patch which removes existing values for (s,p,*,c) and

    # adds (s,p,newObject,c). Values in other graphs are not affected.

    existing = @graph.getQuads(s, p, null, g)

    return {

  items: (list) ->

    out = []

    current = list

    while true

      if current == RDF + 'nil'

        break

      @_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)

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

  nextNumberedResources: (base, howMany) ->

    # base is NamedNode or string

    base = base.id if base.id

    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) ->

  contextsWithPattern: (s, p, o) ->

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

    ctxs = []

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

      ctxs.push(q.graph)

    return _.unique(ctxs)

        called++

      graph.runHandler(hand, 'run')

      assert.equal(1, called)

    it 'calls a handler a 2nd time if the graph is patched with relevant data', ->

      called = 0

      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++

        graph.uriValue(A1, A2)

        if called > 1

          objsFound.push(graph.objects(A1, A3))

      graph.runHandler(hand, 'run')

      # first run looked up A1,A2,*

      graph.applyAndSendPatch({

      assert.equal(3, called)

      assert.deepEqual([[], [A4]], objsFound)

    it 'calls a handler again even if the handler throws an error', ->

      called = 0

      hand = ->

        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')

        innerResults.push(graph.uriValue(A1, A2))

        console.log("innerResults #{JSON.stringify(innerResults)}\n")

      outerResults = []

      doRunInner = true

      outer = ->

        hand = -> values.push(graph.subjects(rdfType, U('Type1')))

        graph.runHandler(hand, 'run')

        graph.applyAndSendPatch(

          {delQuads: [], addQuads: [quad(A4, rdfType, U('Type1'))]})

        expect(values[0]).to.deep.have.members([A2, A3])

        expect(values[1]).to.deep.have.members([A2, A3, A4])

      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')

          graph.applyAndSendPatch(

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

          assert.deepEqual([false, true], values)

        it 'when a relevant triple is removed', ->

          values = []

    writer.end((err, result) ->

      out.patch.deletes = result

      cb())

  writeAdds = (cb) ->

    writer = N3.Writer({ format: 'N-Quads' })

    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

    @_newConnection()

  _updateStatus: ->

    ws = (if not @ws? then 'no' else switch @ws.readyState

      when @ws.CONNECTING then 'connecting'

      when @ws.OPEN then 'open'

    ping = if @_lastPingMs > 0 then @_lastPingMs else '...'

    @setStatus("#{ws};

      #{@_patchesReceived} recv;

      #{@_patchesSent} sent;

      #{@_patchesToSend.length} pending;

      #{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)

    @ws.onopen = =>

      log('rdfdbclient: connected to', fullUrl)

      @_updateStatus()

      @clearGraphOnNewConnection()

      @_pingLoop()

    @_patchesReceived++

    @_updateStatus()

  _continueSending: ->

    if @ws.readyState != @ws.OPEN

      setTimeout(@_continueSending.bind(@), 500)

      return

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

    # the dragging cases.

    sendOne = (patch, cb) =>

      )

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

  # widget*, wherever it is, but your drag is moving the *target*. The

  # adj will travel around too, but it may do extra moves to not bump

  # into stuff or to get out from under your finger.

  constructor: (@config) ->

    @ctor2()

  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

    if ev.target.tagName == "LIGHT9-TIMELINE-EDITOR"

      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)

  subscribe: (onChange) ->

    log('AdjustableFloatObservable subscribe', @config)

    ko.computed =>

      @config.observable()

      onChange()

  constructor: (@config) ->

    # config also has:

    #   graph

    #   subj

    #   pred

    #   ctx

    #   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(@)

      ctx: ctx

    }

    @ctor2()

  getTarget: ->

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

    $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

    originSec = graph.floatValue(@note.uri, U(':originTime'))

    p0 = @_makePatch(graph, @i0, newSec0, originSec, @config.ctx)

    p1 = @_makePatch(graph, @i1, newSec1, originSec, @config.ctx)

    if ev.buttons == 1

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

      adj = @_adjAtPoint(start)

      if adj

        ev.stopPropagation()

        @currentDrag = {start: start, adj: adj}

        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

  _setAdjuster: (adjId, makeAdjustable) ->

    # callers register/unregister the Adjustables they want us to make

    # adjuster elements for. Caller invents adjId.  makeAdjustable is

    # a function returning the Adjustable or it is null to clear any

    # adjusters with this id.

    if not @adjs[adjId] or not makeAdjustable?