import logging

import time

from typing import Dict, List, Set, Tuple, cast

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import Literal

from light9.collector.device import resolve, toOutputAttrs

from light9.collector.output import Output as OutputInstance

from light9.collector.weblisteners import WebListeners

from light9.namespaces import L9, RDF

log = logging.getLogger('collector')

def makeDmxMessageIndex(base: DmxIndex, offset: DmxIndex) -> DmxMessageIndex:

    return DmxMessageIndex(base + offset - 1)

def outputMap(graph: SyncedGraph, outputs: List[OutputInstance]) -> Dict[Tuple[DeviceUri, OutputAttr], Tuple[OutputInstance, DmxMessageIndex]]:

    """From rdf config graph, compute a map of

       (device, outputattr) : (output, index)

    that explains which output index to set for any device update.

    def __init__(self, graph: SyncedGraph, outputs: List[OutputInstance], listeners: WebListeners, clientTimeoutSec: float = 10):

        self.graph = graph

        self.outputs = outputs

        self.listeners = listeners

        self.clientTimeoutSec = clientTimeoutSec

        self.initTime = time.time()

        self.allDevices: Set[DeviceUri] = set()

        self.graph.addHandler(self.rebuildOutputMap)

        # client : (session, time, {(dev,devattr): latestValue})

        # (dev, devAttr): value to use instead of 0

    def rebuildOutputMap(self):

        self.outputMap = outputMap(self.graph, self.outputs)

        self.deviceType: Dict[DeviceUri, DeviceClass] = {}

        self.remapOut: Dict[Tuple[DeviceUri, OutputAttr], OutputRange] = {}

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

            dc = cast(DeviceClass, dc)

            for dev in self.graph.subjects(RDF.type, dc):

                dev = cast(DeviceUri, dev)

                self.allDevices.add(dev)

                self.deviceType[dev] = dc

    def _forgetStaleClients(self, now):

        # type: (float) -> None

        staleClientSessions = []

        for c, (t, _) in self.lastRequest.items():

            if t < now - self.clientTimeoutSec:

                staleClientSessions.append(c)

        for c in staleClientSessions:

            log.info('forgetting stale client %r', c)

            del self.lastRequest[c]

    # todo: move to settings.py

        for d, da, v in settingsList:

            if (d, da) in out:

                out[(d, da)] = resolve(d, da, [out[(d, da)], v])

            else:

                out[(d, da)] = v

        return out

    def _warnOnLateRequests(self, client, now, sendTime):

        requestLag = now - sendTime

        if requestLag > .1 and now > self.initTime + 10 and getattr(self, '_lastWarnTime', 0) < now - 3:

            self._lastWarnTime = now

            log.warn('collector.setAttrs from %s is running %.1fms after the request was made', client, requestLag * 1000)

    def _merge(self, lastRequests):

        for _, lastSettings in lastRequests:

            for (device, deviceAttr), value in lastSettings.items():

                if (device, deviceAttr) in self.remapOut:

                    start, end = self.remapOut[(device, deviceAttr)]

                attrs = deviceAttrs.setdefault(device, {})

                if deviceAttr in attrs:

                    value = resolve(device, deviceAttr, [attrs[deviceAttr], value])

                attrs[deviceAttr] = value

                # list should come from the graph. these are attrs

                # that should default to holding the last position,

                # not going to 0.

                if deviceAttr in [L9['rx'], L9['ry'], L9['zoom'], L9['focus']]:

                    self.stickyAttrs[(device, deviceAttr)] = cast(float, value)

        # e.g. don't let an unspecified rotation go to 0

        for (d, da), v in self.stickyAttrs.items():

            daDict = deviceAttrs.setdefault(d, {})

            if da not in daDict:

                daDict[da] = v

        return deviceAttrs

        """

        settings is a list of (device, attr, value). These attrs are

        device attrs. We resolve conflicting values, process them into

        output attrs, and call Output.update to send the new outputs.

        client is a string naming the type of client. (client,

        clientSession) is a unique client instance.

        Each client session's last settings will be forgotten after

        clientTimeoutSec.

        """

        now = UnixTime(time.time())

        for d in self.allDevices:

            try:

                devType = self.deviceType[d]

            except KeyError:

                log.warn("request for output to unconfigured device %s" % d)

                continue

            try:

                outputAttrs[d] = toOutputAttrs(devType, deviceAttrs.get(d, {}))

                self.listeners.outputAttrsSet(d, outputAttrs[d], self.outputMap)

            except Exception as e:

                log.error('failing toOutputAttrs on %s: %r', d, e)

        for out in self.outputs:

            pendingOut[OutputUri(out.uri)] = (out, bytearray(512))

        for device, attrs in outputAttrs.items():

            for outputAttr, value in attrs.items():

                output, _index = self.outputMap[(device, outputAttr)]

                outputUri = OutputUri(output.uri)

                index = DmxMessageIndex(_index)

                _, outArray = pendingOut[outputUri]

                if outArray[index] != 0:

                    log.warn(f'conflict: {output} output array was already nonzero at 0-based index {index}')

                    raise ValueError(f"someone already wrote to index {index}")

import unittest

import datetime, time

from freezegun import freeze_time

from rdflib import Namespace

from light9.namespaces import L9, DEV

from light9.collector.collector import Collector, outputMap

UDMX = Namespace('http://light9.bigasterisk.com/output/udmx/')

DMX0 = Namespace('http://light9.bigasterisk.com/output/dmx0/')

PREFIX = '''

   @prefix : <http://light9.bigasterisk.com/> .

        @prefix dev: <http://light9.bigasterisk.com/device/> .

        @prefix udmx: <http://light9.bigasterisk.com/output/udmx/> .

        @prefix dmx0: <http://light9.bigasterisk.com/output/dmx0/> .

'''

THEATER = '''

            [ :outputAttr :level; :dmxOffset 0 ] .

        :ChauvetColorStrip a :DeviceClass;

          :deviceAttr :color;

          :attr

            [ :outputAttr :mode;  :dmxOffset 0 ],

            [ :outputAttr :red;   :dmxOffset 1 ],

            [ :outputAttr :green; :dmxOffset 2 ],

            [ :outputAttr :blue;  :dmxOffset 3 ] .

'''

    def __init__(self, uri, connections):

        self.connections = connections

        self.updates = []

        self.uri = uri

        self.numChannels = 4

    def update(self, values):

class TestCollector(unittest.TestCase):

    def setUp(self):

        self.config = MockSyncedGraph(PREFIX + THEATER + '''

        dev:colorStrip a :Device, :ChauvetColorStrip;

          :dmxUniverse udmx:; :dmxBase 1;

          :red dev:colorStripRed;

          :green dev:colorStripGreen;

          :blue dev:colorStripBlue;

          :mode dev:colorStripMode .

        dev:inst1 a :Device, :SimpleDimmer;

          :dmxUniverse dmx0:; :dmxBase 1;

          :level dev:inst1Brightness .

        ''')

    def testRoutesColorOutput(self):

    def testOutputMaxOfTwoClients(self):

    def testClientOnSameOutputIsRememberedOverCalls(self):

    def testClientsOnDifferentOutputs(self):

        # ok that udmx is flushed twice- it can screen out its own duplicates

    def testNewSessionReplacesPreviousOutput(self):

        # ..as opposed to getting max'd with it

    def testNewSessionDropsPreviousSettingsOfOtherAttrs(self):

        c = Collector(MockSyncedGraph(PREFIX + THEATER + '''

        dev:colorStrip a :Device, :ChauvetColorStrip;

          :dmxUniverse udmx:; :dmxBase 1;

          :red dev:colorStripRed;

          :green dev:colorStripGreen;

          :blue dev:colorStripBlue;

          :mode dev:colorStripMode .

        dev:inst1 a :Device, :SimpleDimmer;

          :dmxUniverse dmx0:; :dmxBase 0;

          :level dev:inst1Brightness .

        '''),

    def testClientIsForgottenAfterAWhile(self):

        with freeze_time(datetime.datetime.now()) as ft:

            ft.tick(delta=datetime.timedelta(seconds=1))

            # this max's with cli1's value so we still see .5

            ft.tick(delta=datetime.timedelta(seconds=9.1))

            # now cli1 is forgotten, so our value appears

    def testClientUpdatesAreNotMerged(self):

        # second call to setAttrs forgets the first

    def testRepeatedAttributesInOneRequestGetResolved(self):

        ], t0)

        ], t0)

import logging

from typing import Dict, List, Any, TypeVar, cast

from light9.namespaces import L9

from rdflib import Literal, URIRef

from webcolors import hex_to_rgb, rgb_to_hex

from colormath.color_objects import sRGBColor, CMYColor

import colormath.color_conversions

log = logging.getLogger('device')

class Device(object):

    pass

class ChauvetColorStrip(Device):

    """

     device attrs:

       color

def clamp255(x):

    return min(255, max(0, x))

def _8bit(f):

    if not isinstance(f, (int, float)):

        raise TypeError(repr(f))

    return clamp255(int(f * 255))

    rgbs = [hex_to_rgb(v) for v in values]

    maxes = [max(component) for component in zip(*rgbs)]

def resolve(

        deviceType: DeviceUri,  # should be DeviceClass?

        deviceAttr: DeviceAttr,

    """

    return one value to use for this attr, given a set of them that

    have come in simultaneously. len(values) >= 1.

    bug: some callers are passing a device instance for 1st arg

    """

    if len(values) == 1:

        return values[0]

    if deviceAttr == DeviceAttr(L9['color']):

    # incomplete. how-to-resolve should be on the DeviceAttr defs in the graph.

    if deviceAttr in map(DeviceAttr, [L9['rx'], L9['ry'], L9['zoom'], L9['focus'], L9['iris']]):

        floatVals = []

        for v in values:

            if isinstance(v, Literal):

                floatVals.append(float(v.toPython()))

            elif isinstance(v, (int, float)):

                floatVals.append(float(v))

            else:

                raise TypeError(repr(v))

        # averaging with zeros? not so good

    return max(values)

def toOutputAttrs(deviceType, deviceAttrSettings) -> Dict[OutputAttr, OutputValue]:

    return dict((OutputAttr(u), OutputValue(v)) for u, v in untype_toOutputAttrs(deviceType, deviceAttrSettings).items())

def untype_toOutputAttrs(deviceType, deviceAttrSettings) -> Dict[URIRef, int]:

    """

    Given device attr settings like {L9['color']: Literal('#ff0000')},

    return a similar dict where the keys are output attrs (like

    L9['red']) and the values are suitable for Collector.setAttr

import unittest

from rdflib import Literal

from rdfdb.patch import Patch

from light9.namespaces import L9, DEV

from light9.effect.settings import DeviceSettings

class TestDeviceSettings(unittest.TestCase):

    def setUp(self):

        self.graph = LocalSyncedGraph(

            files=['test/cam/lightConfig.n3', 'test/cam/bg.n3'])

    def testToVectorZero(self):

        ds = DeviceSettings(self.graph, [])

        self.assertEqual(

            DeviceSettings(self.graph, [

                (DEV['aura1'], L9['rx'], 0.5),

                (DEV['aura1'], L9['color'], '#00ff00'),

            ]), s)

    def testAsList(self):

        sets = [

            (L9['light1'], L9['attr2'], 0.3),

            (L9['light1'], L9['attr1'], 0.5),

        ]

    def testDevices(self):

        s = DeviceSettings(self.graph, [

            (DEV['aura1'], L9['rx'], 0),

            (DEV['aura2'], L9['rx'], 0.1),

        ])

        # aura1 is all defaults (zeros), so it doesn't get listed

    def testAddStatements(self):

        s = DeviceSettings(self.graph, [

            (DEV['aura2'], L9['rx'], 0.1),

        ])

        stmts = s.statements(L9['foo'], L9['ctx1'], L9['s_'], set())

        self.maxDiff = None

        ], stmts)

    def testDistanceTo(self):

        s1 = DeviceSettings(self.graph, [

            (DEV['aura1'], L9['rx'], 0.1),

            (DEV['aura1'], L9['ry'], 0.6),

        ])

        s2 = DeviceSettings(self.graph, [

            (DEV['aura1'], L9['rx'], 0.3),

            (DEV['aura1'], L9['ry'], 0.3),

        ])

        self.assertEqual(0.36055512754639896, s1.distanceTo(s2))

from rdflib import URIRef

from rdflib.term import Node

ClientType = NewType('ClientType', str)

ClientSessionType = NewType('ClientSessionType', str)

Curve = NewType('Curve', URIRef)

OutputUri = NewType('OutputUri', URIRef)  # e.g. dmxA

DeviceUri = NewType('DeviceUri', URIRef)  # e.g. :aura2

DeviceClass = NewType('DeviceClass', URIRef)  # e.g. :Aura

DmxIndex = NewType('DmxIndex', int)  # 1..512

DmxMessageIndex = NewType('DmxMessageIndex', int)  # 0..511

DeviceAttr = NewType('DeviceAttr', URIRef)  # e.g. :rx

NoteUri = NewType('NoteUri', URIRef)

OutputAttr = NewType('OutputAttr', URIRef)  # e.g. :xFine

OutputValue = NewType('OutputValue', int)  # byte in dmx message

Song = NewType('Song', URIRef)

UnixTime = NewType('UnixTime', float)

# Alternate output range for a device. Instead of outputting 0.0 to

# 1.0, you can map that range into, say, 0.2 to 0.7

OutputRange = NewType('OutputRange', Tuple[float, float])

_ObjType = TypeVar('_ObjType')

def _isSubclass2(t1: Type, t2: Type) -> bool:

    """same as issubclass but t1 can be a NewType"""

    if hasattr(t1, '__supertype__'):

        t1 = t1.__supertype__

    return issubclass(t1, t2)