#

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

coffeeElementSetup(class EditChoice extends Polymer.Element

)

class AutoDependencies

  constructor: () ->

    @handlerStack = [@handlers] # currently running

  runHandler: (func, label) ->

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

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

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

  _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

      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

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

  nextNumberedResource: (base) ->

  contextsWithPattern: (s, p, o) ->

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

      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

      graph.runHandler(hand, 'run')

      graph.applyAndSendPatch({

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

    describe 'works with nested handlers', ->

          values = []

          successes = 0

          hand = ->

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

            catch

              # graph goes empty between clearGraph and 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', ->

      cb())

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

parseJsonPatch = (jsonPatch, cb) ->

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

  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

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

    @_patchesToSend.push(patch)

    @_updateStatus()

  _newConnection: ->

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

    # the dragging cases.

    sendOne = (patch, cb) =>

      )

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

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

    return '' if @config.emptyBox

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

    if @config.getDisplayValue?

    defaultFormat

  getSuggestedCenter: () ->

  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.

  continueDrag: (pos) ->

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

    @targetDraggedTo = pos.add(@initialTarget)

  endDrag: () ->

    # override

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

  _getValue: () ->

    @config.observable()

  continueDrag: (pos) ->

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

    super(pos)

    @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

  getTarget: () ->

    @config.getTargetPosForValue(@_getValue())

  subscribe: (onChange) ->

    # only works on one subscription at a time

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

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

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

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

    if @currentDrag

      @currentDrag.cur = pos

  onUp: (ev) ->

    return unless @currentDrag

    @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

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

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

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

    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

  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)

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

      addQuads: curveQuads.concat(pointQuads)

      }

    @graph.applyAndSendPatch(patch)

  getCurvePoints: (curve, xOffset) ->

    worldPts = []

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

    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:

    super()

    @viewState = new ViewState()

    window.viewState = @viewState

  ready: ->

    super.ready()

    @addEventListener 'mousedown', (ev) => @$.adjustersCanvas.onDown(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()

    Polymer.RenderStatus.afterNextRender this, =>

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

  _onIronResize: ->

    @viewState.setWidth(@offsetWidth)

    @viewState.coveredByDiagramTop(@$.coveredByDiagram.offsetTop)

    if @$.zoomed?.$?.time?

      @viewState.zoomedTimeY(@$.zoomed.$.time.offsetTop)

      @viewState.zoomedTimeH(@$.zoomed.$.time.offsetHeight)

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

    @show = 'http://light9.bigasterisk.com/show/dance2017'

  _onSetAdjuster: () ->

    @makeZoomAdjs()

  updateDebugSummary: ->

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

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

    # shouldn't need this- deps should get it

    @$.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)

  makeZoomAdjs: ->

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

    valForPos = (pos) =>

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

      observable: @viewState.zoomSpec.t1,

      getTarget: () =>

    }))

    panObs = ko.pureComputed({

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

      observable: panObs

      getTarget: () => $V([@viewState.fullZoomX(panObs()), yMid()])

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

      getValueForPos: valForPos

)

    @notes = []

    @stage = new PIXI.Container()

    @stage.interactive=true

    @renderer = PIXI.autoDetectRenderer({

    })

  ready: ->

    super.ready()

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

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

    @$.rows.appendChild(@renderer.view)

    # This works for display, but pixi hit events didn't correctly

    # move with the objects, so as a workaround, I extended the top of

    # the canvas in _onResize.

    #ko.computed =>

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

  _onResize: ->

    @$.rows.firstChild.style.position = 'relative'

    @$.rows.firstChild.style.top = -@viewState.rowsY() + 'px'

    @renderer.resize(@clientWidth, @clientHeight + @viewState.rowsY())

    @renderer.render(@stage)

  _onGraph: (graph, setAdjuster, song, viewState, project)->

    return unless @song # polymer will call again

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

    return unless @song?

    songNotes = @graph.objects(U(@song), U(':note'))

    @stage.removeChildren()

    n.destroy() for n in @notes

    @notes = []

    noteNum = 0

    for uri in _.sortBy(songNotes, 'id')

      con = new PIXI.Container()

      con.interactive=true

      @stage.addChild(con)

      row = noteNum % 6

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

      note = new Note(@, con, @project, @graph, @selection, uri, @setAdjuster, U(@song), @viewState, rowTop, rowTop + 140)

      @notes.push(note)

      noteNum = noteNum + 1

    @renderer.render(@stage)

  onDrop: (effect, pos) ->

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

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

    [pointUris, worldPts] = @getCurvePoints(@uri, U(':strength'))

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

    yForV = (v) => @rowBotY + (@rowTopY - @rowBotY) * v

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

    screenPts = (new PIXI.Point(@viewState.zoomInX(pt.e(1)), yForV(pt.e(2))) for pt in worldPts)