from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from starlette.applications import Starlette

from starlette.endpoints import WebSocketEndpoint

from starlette.requests import ClientDisconnect

from starlette.responses import Response

from starlette.routing import Route, WebSocketRoute

from starlette.types import Receive, Scope, Send

from starlette.websockets import WebSocket

from starlette_exporter import PrometheusMiddleware, handle_metrics

STAT_SETATTR = Summary('set_attr', 'setAttr calls')

class Updates(WebSocketEndpoint, UiListener):

    def __init__(self, listeners, scope: Scope, receive: Receive, send: Send) -> None:

        super().__init__(scope, receive, send)

        self.listeners = listeners

    async def on_connect(self, websocket: WebSocket):

        await websocket.accept()

        log.info('socket connect %s', self.scope['client'])

        self.websocket = websocket

        self.listeners.addClient(self)

    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

        ]

    except Exception:

        log.error("setting up outputs:")

        traceback.print_exc()

        raise

    listeners = WebListeners()

    c = Collector(graph, outputs, listeners)

    app = Starlette(

        debug=True,

        routes=[

            # Route('/recentRequests', lambda req: get_recentRequests(req, db)),

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.metrics import metrics

from light9.run_local import log

async def changes():

    state = {}

    q = asyncio.Queue()

    def onBroadcast(update):

        state.update(update)

        q.put_nowait(None)

    dispatcher.connect(onBroadcast, StateUpdate)