"""
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.effect_function_library import EffectFunctionLibrary
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('sse_starlette.sse').setLevel(logging.INFO)
 
    logging.getLogger('autodepgraphapi').setLevel(logging.INFO)
    logging.getLogger('syncedgraph').setLevel(logging.INFO)
 
    logging.getLogger('effecteval').setLevel(logging.INFO)
    logging.getLogger('seq.fader').setLevel(logging.INFO)

    # seq = Sequencer(graph, send)  # per-song timed notes
    lib = EffectFunctionLibrary(graph)
    faders = FaderEval(graph, lib)  # 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)

    faders_loop = loop_forever(func=update, metric_prefix='faders', sleep_period=1 / RATE)

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