Polymer

  is: 'light9-cursor-canvas'

  behaviors: [ Polymer.IronResizableBehavior ]

  listeners: 'iron-resize': 'update'

  ready: ->

    @mouseX = 0

    @mouseY = 0

    @cursorPath = null

    @ctx = @$.canvas.getContext('2d')

  update: (ev) ->

    @$.canvas.width = ev.target.offsetWidth

    @$.canvas.height = ev.target.offsetHeight

    @redraw()

    @cursorPath = {

      bot1: $V([xZoomedIn, @offsetParent.offsetHeight])

    }

    @redraw()

  redraw: ->

    @ctx.clearRect(0, 0, @$.canvas.width, @$.canvas.height)

    @ctx.strokeStyle = '#fff'

    @ctx.lineWidth = 0.5

    @ctx.beginPath()

    Drawing.line(@ctx, $V([0, @mouseY]), $V([@$.canvas.width, @mouseY]))

                                   show="{{show}}"

                                   view-state="{{viewState}}">

      </light9-timeline-time-zoomed>

      <light9-timeline-diagram-layer id="dia" selection="{{selection}}"></light9-timeline-diagram-layer>

      <light9-adjusters-canvas id="adjustersCanvas" set-adjuster="{{setAdjuster}}">

      </light9-adjusters-canvas>

    </div>

  </template>

</dom-module>

<!-- the whole section that pans/zooms in time (most of the editor) -->

    if note in selection.selected()

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

class ViewState

  constructor: () ->

    # caller updates all these observables

    @zoomSpec =

      duration: ko.observable(100) # current song duration

      t1: ko.observable(0)

      t2: ko.observable(100)

    @cursor =

      t: ko.observable(20) # songTime

    @mouse =

      pos: ko.observable($V([0,0]))

    @fullZoomX = d3.scaleLinear()

    @zoomInX = d3.scaleLinear()

  setWidth: (w) ->

    @width(w)

    # not for cursor updates

    if @zoomSpec.t1() < 0

      @zoomSpec.t1(0)

    if @zoomSpec.duration() and @zoomSpec.t2() > @zoomSpec.duration()

      @zoomSpec.t2(@zoomSpec.duration())

    @fullZoomX.domain([0, @zoomSpec.duration()])

    @fullZoomX.range([0, @width()])

    @zoomInX.domain([@zoomSpec.t1(), @zoomSpec.t2()])

    @zoomInX.range([0, @width()])

  latestMouseTime: ->

    @zoomInX.invert(@mouse.pos().e(1))

  onMouseWheel: (deltaY) ->

    zs = @zoomSpec

    scale = Math.pow(1.005, deltaY)

    zs.t1(center - left * scale)

    zs.t2(center + right * scale)

    log('view to', ko.toJSON(@))

  animatedZoom: (newT1, newT2, secs) ->

    fps = 30

    oldT1 = @zoomSpec.t1()

    oldT2 = @zoomSpec.t2()

    lastTime = 0

    for step in [0..secs * fps]

    @setAdjuster = (adjId, makeAdjustable) =>

      ac = @$.adjustersCanvas

      setTimeout((()=>ac.setAdjuster(adjId, makeAdjustable)),10)

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

    setTimeout =>

      @trackMouse()

      @bindKeys()

      @bindWheelZoom(@dia)

      setTimeout => # depends on child node being ready

          @forwardMouseEventsToAdjustersCanvas()

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

      setInterval(@updateDebugSummary.bind(@), 100)

    , 500

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

    #if anchor == loadtest

    #  add note and delete it repeatedly

    #  disconnect the graph, make many notes, drag a point over many steps, measure lag somewhere

  _onIronResize: ->

    @viewState.setWidth(@offsetWidth)

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

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

     #{window.debug_adjsCount} adjuster items registered,

     #{window.debug_adjUpdateDisplay} adjuster updateDisplay calls,

    "

  zoomOrLayoutChanged: ->

    vs = @viewState

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

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

      vs.zoomSpec.t1()

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

        if ev.touches?.length

          ev = ev.touches[0]

        root = @$.cursorCanvas.getBoundingClientRect()

        @viewState.mouse.pos($V([ev.pageX - root.left, ev.pageY - root.top]))

        # should be controlled by a checkbox next to follow-player-song-choice

        @sendMouseToVidref() unless window.location.hash.match(/novidref/)

  sendMouseToVidref: ->

    now = Date.now()

    if (!@$.vidrefLastSent? || @$.vidrefLastSent < now - 200) && !@songPlaying

      @$.vidrefTime.body = {t: @latestMouseTime(), source: 'timeline'}

      @$.vidrefTime.generateRequest()

      @$.vidrefLastSent = now

  bindWheelZoom: (elem) ->

    elem.addEventListener 'mousewheel', (ev) =>

      @viewState.onMouseWheel(ev.deltaY)

  forwardMouseEventsToAdjustersCanvas: ->

    ac = @$.adjustersCanvas

    @addEventListener('mousemove', ac.onMove.bind(ac))

    @addEventListener('mouseup', ac.onUp.bind(ac))

  bindKeys: ->

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

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

    shortcut.add "L", =>

      @$.adjustersCanvas.updateAllCoords()

    shortcut.add 'Delete', =>

      for note in @selection.selected()

        @project.deleteNote(@song, note, @selection)

  makeZoomAdjs: ->

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

    valForPos = (pos) =>

        x = pos.e(1)

        t = @fullZoomX.invert(x)

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

      observable: @viewState.zoomSpec.t1,