from lib.cycloneerr import PrettyErrorHandler

from light9.collector.output import EnttecDmx, Udmx

from light9.collector.collector import Collector

from light9.namespaces import L9

from light9 import networking

from light9.rdfdb.syncedgraph import SyncedGraph

from light9.greplin_cyclone import StatsForCyclone

def parseJsonMessage(msg):

    body = json.loads(msg)

    settings = []

    for device, attr, value in body['settings']:

    return body['client'], body['clientSession'], settings, body['sendTime']

def startZmq(port, collector):

    stats = scales.collection('/zmqServer',

                              scales.PmfStat('setAttr'))

    zf = ZmqFactory()

    addr = 'tcp://*:%s' % port

    log.info('creating zmq endpoint at %r', addr)

    e = ZmqEndpoint('bind', addr)

    s = ZmqPullConnection(zf, e)

    def onPull(message):

    def fine16Attr(attr, scale=1.0):

        x = floatAttr(attr) * scale

        hi = _8bit(x)

        lo = _8bit((x * 255) % 1.0)

        return hi, lo

    def choiceAttr(attr):

        # todo

        if deviceAttrSettings.get(attr) == L9['g1']:

            return 3

        if deviceAttrSettings.get(attr) == L9['g2']:

            return 10

    if deviceType == L9['ChauvetColorStrip']:

        r, g, b = rgbAttr(L9['color'])

        return {

            L9['mode']: 215,

            L9['red']: r,

            L9['green']: g,

            L9['blue']: b

            }

    elif deviceType == L9['SimpleDimmer']:

        return {L9['level']: _8bit(floatAttr(L9['brightness']))}

    elif deviceType == L9['Mini15']:

    return hit if hit != undefined

    ret = parseFloat(N3.Util.getLiteralValue(@_singleValue(s, p)))

    @cachedFloatValues.set(key, ret)

    return ret

  stringValue: (s, p) ->

    N3.Util.getLiteralValue(@_singleValue(s, p))

  uriValue: (s, p) ->

    @_singleValue(s, p)

  objects: (s, p) ->

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

    quads = @graph.findByIRI(s, p)

    return (q.object for q in quads)

  subjects: (p, o) ->

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

    quads = @graph.findByIRI(null, p, o)

    return (q.subject for q in quads)

  items: (list) ->

    out = []

                        content-type="application/json"

                        immediate-value="{{immediateSlider}}"></paper-slider>

        </template>

        <template is="dom-if" if="{{deviceAttr.useColor}}">

          <input type="color"

                 id="col"

                 on-input="onPickedColor"

                 value="{{pickedColor}}">

          <button on-click="goWhite">white</button>

          <button on-click="goBlack">black</button>

        </template>

        <template is="dom-if" if="{{deviceAttr.useChoice}}">

            <template is="dom-repeat" items="{{deviceAttr.choices}}">

            </template>

          </select>

        </template>

      </template>

    </dom-module>

    <dom-module id="light9-live-device-control">

      <template>

        <style>

         .device {

log = console.log

Polymer

  is: 'light9-live-control'

  properties:

    device: { type: String }

    deviceAttr: { type: Object }

    max: { type: Number, value: 1 }

    value: { type: Object, notify: true }

    immediateSlider: { notify: true, observer: 'onSlider' }

    pickedColor: { observer: 'onPickedColor' }

  observers: [

    'onChange(value)'

    ]

  ready: ->

  onPickedColor: (ev) -> @value = ev.target.value

  onSlider: -> @value = @immediateSlider

  goWhite: -> @value = "#ffffff"

  goBlack: -> @value = "#000000"

  onChange: (value) ->

    @lastSent = [[@device, @deviceAttr.uri, value]]

    @resend()

  resend: ->

    window.gather(@lastSent)

  clear: ->

    if @deviceAttr.useColor

      @value = '#000000'

    else

      @value = @immediateSlider = 0

Polymer

  is: "light9-live-device-control"

  properties:

    graph: { type: Object, notify: true }

    uri: { type: String, notify: true }

    deviceClass: { type: String, notify: true }

    deviceAttrs: { type: Array, notify: true }

  observers: [

    'onGraph(graph)'

    ]

  onGraph: ->

    @graph.runHandler(@update.bind(@), "#{@uri} update")

  update: ->

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

    @deviceClass = @graph.uriValue(@uri, U('rdf:type'))

    @deviceAttrs = []

    for da in _.unique(_.sortBy(@graph.objects(@deviceClass, U(':deviceAttr'))))

      dataType = @graph.uriValue(da, U(':dataType'))

      daRow = {

        uri: da

        dataType: dataType

        showColorPicker: dataType == U(':color')

        }

      if dataType == 'http://light9.bigasterisk.com/color'

        daRow.useColor = true

      else if dataType == U(':choice')

        daRow.useChoice = true

      else

        daRow.useSlider = true

        daRow.max = 1

        if dataType == U(':angle')

          # varies

          daRow.max = 1

      @push('deviceAttrs', daRow)

Polymer

  is: "light9-live-controls"

  properties:

        <div class="buttons">

          <paper-button dialog-dismiss>Cancel</paper-button>

          <paper-button dialog-confirm>OK</paper-button>

        </div>

      </paper-dialog>

    </template>

  </template>

  <script>

   Polymer({

       is: "resource-display",

       properties: {

           label: { type: String },

           rename: { type: Boolean },

           renameTo: { type: String, notify: true },

       },

       ready: function() {

           this.graph.runHandler(this.setLabel.bind(this), `label ${this.uri}`);

       },

       setLabel: function() {

           if (!this.label) {

           }

       },

       onRename: function() {

           this.renameTo = this.label;

           this.querySelector("#renameDialog").open();

           this.querySelector("#renameTo").setSelectionRange(0, -1);

       },

       onRenameKey: function(ev) {

           if (ev.key == 'Enter') {

               this.querySelector("[dialog-confirm]").click();

           }

           if (ev.key == 'Escape') {