import asyncio

import logging

import traceback

log = logging.getLogger()

@dataclass

class Event:

    dev: str

    type: str

    control: int

    value: int

    def __repr__(self):

        return f"<Event {self.dev}/{self.type}/{self.control}->{self.value}>"

class EventQueue:

    """midi events come in fast; graph consumes them slower"""

    def __init__(self, MAX_SEND_RATE: float, onMessage) -> None:

        self.MAX_SEND_RATE = MAX_SEND_RATE

        self.onMessage = onMessage

        self.newEvents: asyncio.Queue[Event] = asyncio.Queue()

    def callbackFor(self, dev):

        mainThreadLoop = asyncio.get_running_loop()

        def cb(message):

            # this is running in mido's thread

            d = message.dict()

            ev = Event(dev, d['type'], d['control'], d['value'])

            log.info(f'enqueue {ev} {"*" * ev.value}')

            mainThreadLoop.call_soon_threadsafe(

                self.newEvents.put_nowait,

                ev,

            )

"""

Read midi events, write fade levels to graph

Device troubleshooting:

    amidi -l

"""

import asyncio

from functools import partial

import mido

from light9 import networking

from light9.effect.edit import clamp

from light9.midifade.eventqueue import Event, EventQueue

from light9.midifade.mididevs import connectToMidiOutput, listenToMidiInputs

from light9.midifade.pages import Pages

from light9.namespaces import L9

from light9.newtypes import decimalLiteral

from light9.run_local import log

from light9.showconfig import showUri

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import URIRef

# inline of patchObject to make it async, not just create_task

async def asyncPatchObject(graph, context: URIRef, subject, predicate: URIRef, newObject):

    p = graph.getObjectPatch(context, subject, predicate, newObject)

    # if not p.isEmpty():

    #     log.debug("patchObject %r" % p.jsonRepr)

    await graph.patch(p)

async def writeHwValueToGraph(graph: SyncedGraph, ctx, fader: URIRef, strength: float):

import asyncio

import logging

from dataclasses import dataclass

from typing import cast

import mido

from light9.midifade.pages import Pages

from light9.namespaces import L9

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import Literal

log = logging.getLogger()

@dataclass

class WriteBackFaders:

    graph: SyncedGraph

    pages: Pages

    bcf_out: mido.ports.BaseOutput

    _lastSet: dict[int, int]

    def getCurrentValue(self, f):

        return self._lastSet.get(f, 0)

    def update(self):

        try:

            asyncio.create_task(self._update())

        except ValueError as e:

            log.warning(repr(e))

    async def _update(self):

        # to make this work again:

        #  - track the goal of all sliders

        #  - in a debounced handler, sendToBcf