import logging

import time

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

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

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

from light9.newtypes import (ClientSessionType, ClientType, DeviceAttr, DeviceClass, DeviceSetting, DeviceUri, DmxIndex, DmxMessageIndex, OutputAttr,

                             OutputRange, OutputUri, OutputValue, UnixTime, VTUnion, typedValue)

log = logging.getLogger('collector')

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

    return DmxMessageIndex(base + offset - 1)

def _outputMap(graph: SyncedGraph, outputs: Set[OutputUri]) -> Dict[Tuple[DeviceUri, OutputAttr], Tuple[OutputUri, DmxMessageIndex]]:

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

       (device, outputattr) : (output, index)

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

    """

    ret = cast(Dict[Tuple[DeviceUri, OutputAttr], Tuple[OutputUri, DmxMessageIndex]], {})

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

        log.info('mapping DeviceClass %s', dc)

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

            dev = cast(DeviceUri, dev)

            universe = typedValue(OutputUri, graph, dev, L9['dmxUniverse'])

            if universe not in outputs:

                raise ValueError(f'{dev=} is configured to be in {universe=}, but we have no Output for that universe')

            try:

                dmxBase = typedValue(DmxIndex, graph, dev, L9['dmxBase'])

            except ValueError:

                raise ValueError('no :dmxBase for %s' % dev)

                outputAttr = typedValue(OutputAttr, graph, row, L9['outputAttr'])

                offset = typedValue(DmxIndex, graph, row, L9['dmxOffset'])

                index = makeDmxMessageIndex(dmxBase, offset)

                ret[(dev, outputAttr)] = (universe, index)

    return ret

class Collector:

    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._outputByUri: Dict[OutputUri, OutputInstance] = {}

        self.graph.addHandler(self._rebuildOutputMap)

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

        """

        # todo: cleanup session code if we really don't want to be able to run multiple sessions of one client

from typing import cast

from rdflib import URIRef

import socket

import struct

import time

import usb.core

import logging

from twisted.internet import threads, reactor, task

from twisted.internet.interfaces import IReactorCore, IReactorTime

from light9.metrics import metrics

log = logging.getLogger('output')

class BackgroundLoopOutput(Output):

    """Call _write forever at 20hz in background threads"""

    rate: float

    def __init__(self, uri, rate=22):

        super().__init__(uri)

        self.rate = rate

        self._currentBuffer = b''

        start = time.time()

        sendingBuffer = self._currentBuffer

class FtdiDmx(BackgroundLoopOutput):

    def __init__(self, uri, lastDmxChannel, rate=22):

        super().__init__(uri)

        self.lastDmxChannel = lastDmxChannel

        from .dmx_controller_output import OpenDmxUsb

        self.dmx = OpenDmxUsb()

    def _write(self, buf):

        with metrics('write', output=self.shortId()).time():

async def PutAttrs(collector: Collector, request):

    with STAT_SETATTR.time():

        client, clientSession, settings, sendTime = parseJsonMessage(await request.body())

        collector.setAttrs(client, clientSession, settings, sendTime)

        return Response('', status_code=202)

def main():

    logging.getLogger('autodepgraphapi').setLevel(logging.INFO)

    logging.getLogger('syncedgraph').setLevel(logging.INFO)

    graph = SyncedGraph(networking.rdfdb.url, "collector")

    try:

        # todo: drive outputs with config files

        rate = 30

        outputs: List[Output] = [

            # ArtnetDmx(L9['output/dmxA/'],

            #           host='127.0.0.1',

            #           port=6445,

            #           rate=rate),

            Udmx(L9['output/dmxA/'], bus=3, address=21, lastDmxChannel=100),

        ]

    except Exception:

        log.error("setting up outputs:")

        traceback.print_exc()

        raise

    listeners = WebListeners()

    c = Collector(graph, outputs, listeners)

    app = Starlette(

        debug=True,

        routes=[

"""

plays back effect notes from the timeline (and an untimed note from the faders)

"""

import asyncio

import json

import logging

import time

from louie import dispatcher

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from sse_starlette.sse import EventSourceResponse

from starlette.applications import Starlette

from starlette.routing import Route

from starlette_exporter import PrometheusMiddleware, handle_metrics

from light9 import networking

from light9.collector.collector_client_asyncio import sendToCollector

from light9.effect.sequencer.eval_faders import FaderEval

from light9.effect.sequencer.sequencer import Sequencer, StateUpdate

from light9.effect.settings import DeviceSettings

    return EventSourceResponse(changes())

###################################################################

async def _send_one(faders: FaderEval):

    ds = faders.computeOutput()

    await sendToCollector('effectSequencer', session='0', settings=ds)

async def _forever(faders):

    while True:

        await asyncio.sleep(0.1)

def send_updates_forever(faders):

    asyncio.create_task(_forever(faders))

####################################################################

def main():

    session = 'effectSequencer'