from light9.zmqtransport import parseJsonMessage, startZmq

from rdfdb.syncedgraph import SyncedGraph

from light9.collector.output import EnttecDmx, Udmx, DummyOutput  # noqa

class Updates(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        log.info('socket connect %s', self)

        self.settings.listeners.addClient(self)

# Completely not sure where the effect background loop should

# go. Another process could own it, and get this request repeatedly:

class SongEffectsEval(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        song = URIRef(self.get_argument('song'))

        raise NotImplementedError

        # return dmx dict for all effects in the song, already combined

class App(object):

    def __init__(self, show, outputWhere):

        self.namelabel.config(

            text=self.graph.label(self.sub) or shortUri(self.sub))

class KeyboardComposer(tk.Frame, SubClient):

        tk.Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.subbox: Dict[URIRef, SubmasterBox] = {}  # sub uri : SubmasterBox

        self.rows: List[tk.Frame] = []  # this holds Tk Frames for each row

        self.current_row = 0  # should come from session graph

        self.use_hw_sliders = hw_sliders

        self.connect_to_hw(hw_sliders)

log = logging.getLogger('coll_client')

_zmqClient = None

class TwistedZmqClient(object):

    def __init__(self, service):

        zf = ZmqFactory()

        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))

        self.conn = ZmqPushConnection(zf, e)

    def send(self, msg):

import logging, traceback, time, json

log = logging.getLogger('weblisteners')

class WebListeners(object):

    def __init__(self):

        self.clients = []

        self.pendingMessageForDev = {}  # dev: (attrs, outputmap)

        self.lastFlush = 0

        self.points: List[Tuple[float, float]] = []

        for curve in g.objects(uri, L9['curve']):

            self.points.extend(

                self.getCurvePoints(curve, L9['strength'], originTime))

        self.points.sort()

        points = []

        po = list(self.graph.predicate_objects(curve))

        if dict(po).get(L9['attr'], None) != attr:

            return []

        for point in [row[1] for row in po if row[0] == L9['point']]:

            po2 = dict(self.graph.predicate_objects(point))

        # in case we got an event at the start of the write

        reactor.callLater(.1, go)

class Sequencer(object):

                 fps=40):

        self.graph = graph

        self.fps = fps

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

from light9.namespaces import RDF, L9

import logging

log = logging.getLogger('settings')

from light9.collector.device import resolve

from typing import Sequence, Dict, Union, List

def parseHex(h):

    if h[0] != '#': raise ValueError(h)

    return [int(h[i:i + 2], 16) for i in (1, 3, 5)]

def parseHexNorm(h):

    return [x / 255 for x in parseHex(h)]

def toHex(rgbFloat: Sequence[float]) -> str:

    assert len(rgbFloat) == 3

    scaled = (max(0, min(255, int(v * 255))) for v in rgbFloat)

def getVal(graph, subj):

    lit = graph.value(subj, L9['value']) or graph.value(subj, L9['scaledValue'])

    ret = lit.toPython()

    if isinstance(ret, decimal.Decimal):

    default values are 0 or '#000000'. Internal rep must not store zeros or some

    comparisons will break.

    """

    def __init__(self, graph, settingsList):

        self.graph = graph  # for looking up all possible attrs

        for row in settingsList:

            self._compiled.setdefault(row[0], {})[row[1]] = row[2]

        # self._compiled may not be final yet- see _fromCompiled

        self._delZeros()

    @classmethod

import traceback

from light9.namespaces import L9, RDF

from light9.effect.scale import scale

from typing import Dict, List, Tuple, Any

from rdflib import URIRef

class SimpleOutputs(object):

    def __init__(self, graph):

        self.graph = graph

        # effect : [(dev, attr, value, isScaled)]

        self.graph.addHandler(self.updateEffectsFromGraph)

    def updateEffectsFromGraph(self):

        for effect in self.graph.subjects(RDF.type, L9['Effect']):

            settings = []

    def sendTime(self, t):

        """request that the player go to this time"""

        fetch(

            method=b'POST',

            url=networking.musicPlayer.path('time'),

            headers={b"content-type": [b"application/json"]},

        )