SESS = Summary('coll_client_new_session', 'aiohttp.ClientSession')

def toCollectorJson(client, session, settings: DeviceSettings) -> str:

    assert isinstance(settings, DeviceSettings)

    return json.dumps({

        'settings': settings.asList(),

        'client': client,

        'clientSession': session,

        'sendTime': time.time(),

    })

class _Sender:

    def __init__(self):

        self.context = zmq.asyncio.Context()

        self.socket = self.context.socket(zmq.PUB)

        self.socket.connect('tcp://127.0.0.1:9203')  #todo: tie to :collectorZmq in graph

        # old version used: 'tcp://%s:%s' % (service.host, service.port)

    async def send(self, client: str, session: str, settings: DeviceSettings):

        msg = toCollectorJson(client, session, settings).encode('utf8')

        await self.socket.send_multipart([b'setAttr', msg])

_sender = _Sender()

sendToCollector = _sender.send

async def PutAttrs(collector: Collector, request):

    with STAT_SETATTR.time():

        try:

            body = await request.body()

        except ClientDisconnect:

            log.warning("PUT /attrs request disconnected- ignoring")

            return Response('', status_code=400)

        client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, body)

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

        return Response('', status_code=202)

async def zmqListener(collector):

    try:

        ctx = zmq.asyncio.Context()

        sock = ctx.socket(zmq.SUB)

        sock.bind('tcp://127.0.0.1:9203')

        sock.subscribe(b'setAttr')

        while True:

            [topic, msg] = await sock.recv_multipart()

            if topic != b'setAttr':

                raise ValueError(topic)

            client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, msg)

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

    except:

        traceback.print_exc()

        raise

def main():

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

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

    logging.getLogger('output.allDmx').setLevel(logging.WARNING)

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

            #sudo chmod a+rw /dev/bus/usb/003/021

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

"""

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 lib.background_loop import loop_forever

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.run_local import log

RATE = 20

async def changes():

    state = {}

    q = asyncio.Queue()

    def onBroadcast(update):

        state.update(update)

        q.put_nowait(None)

    dispatcher.connect(onBroadcast, StateUpdate)

    lastSend = 0

    while True:

        await q.get()

        now = time.time()

        if now > lastSend + .2:

            lastSend = now

            yield json.dumps(state)

async def send_page_updates(request):

    return EventSourceResponse(changes())

def main():

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

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

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

    logging.getLogger('sse_starlette.sse').setLevel(logging.INFO)

    # seq = Sequencer(graph, send)  # per-song timed notes

    faders = FaderEval(graph)  # bin/fade's untimed effects

    #@metrics('computeAndSend').time() # needs rework with async

    async def update(first_run):

        ds = faders.computeOutput()

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

    app = Starlette(

        debug=True,

        routes=[

            Route('/updates', endpoint=send_page_updates),

        ],

    )

    app.add_middleware(PrometheusMiddleware)

    app.add_route("/metrics", handle_metrics)

    return app

app = main()