import cyclone.sse

import logging, bisect, time

import traceback

from decimal import Decimal

from typing import Any, Callable, Dict, List, Tuple, cast, Union

from light9.ascoltami.musictime_client import MusicTime

from light9.effect import effecteval

from light9.effect.settings import DeviceSettings

from light9.effect.simple_outputs import SimpleOutputs

from light9.namespaces import L9, RDF

from light9.newtypes import DeviceUri, DeviceAttr, NoteUri, Curve, Song

from light9.metrics import metrics

import imp

log = logging.getLogger('sequencer')

def pyType(n):

    ret = n.toPython()

    if isinstance(ret, Decimal):

        return float(ret)

    return ret

    def outputSettings(

            self,

            t: float) -> Tuple[List[Tuple[DeviceUri, DeviceAttr, float]], Dict]:

        """

        list of (device, attr, value), and a report for web

        """

        report = {

            'note': str(self.uri),

            'effectClass': self.effectEval.effect,

        }

        effectSettings: Dict[DeviceAttr, Union[float, str]] = dict(

            (DeviceAttr(da), v) for da, v in self.baseEffectSettings.items())

        def prettyFormat(x: Union[float, str]):

            if isinstance(x, float):

                return round(x, 4)

            return x

        report['effectSettings'] = dict(

            (str(k), prettyFormat(v))

            for k, v in sorted(effectSettings.items()))

        out, evalReport = self.effectEval.outputFromEffect(

            list(effectSettings.items()),

            songTime=t,

            # note: not using origin here since it's going away

            noteTime=t - self.points[0][0])

        report['devicesAffected'] = len(out.devices())

        return out, report

class CodeWatcher(object):

    def __init__(self, onChange):

            def compileSong(song: Song = cast(Song, song)) -> None:

                self.compileSong(song)

            self.graph.addHandler(compileSong)

    @metrics('compile_song').time()

    def compileSong(self, song: Song) -> None:

        anyErrors = False

        self.notes[song] = []

        for note in self.graph.objects(song, L9['note']):

            try:

                         self.simpleOutputs)

            except Exception:

                log.warn(f"failed to build Note {note} - skipping")

                anyErrors = True

                continue

            self.notes[song].append(n)

        if not anyErrors:

            log.info('built all notes')

    @inlineCallbacks

    def updateLoop(self) -> None:

        frameStart = time.time()

"""

plays back effect notes from the timeline

"""

from twisted.internet import reactor

from light9.metrics import metrics, metricsRoute

from light9 import networking, showconfig

import optparse, sys, logging

import cyclone.web

from rdflib import URIRef

from light9.collector.collector_client import sendToCollector

from light9 import clientsession

class App(object):

    def __init__(self, show, session):

        self.show = show

        self.session = session

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

import { defineConfig } from "vite";

const servicePort = 8213;

export default defineConfig({

  root: "./light9/effect/sequencer/web",

  publicDir: "../web",

  server: {

    host: "0.0.0.0",

    strictPort: true,

    port: servicePort + 100,

    hmr: {

      port: servicePort + 200,

    },

  },

  clearScreen: false,

  define: {