gi.require_version('Gtk', '3.0')

from light9.ascoltami.player import Player

from light9.ascoltami.playlist import Playlist, NoSuchSong

from light9.ascoltami.webapp import makeWebApp, songUri, songLocation

from light9 import networking, showconfig

from standardservice.scalessetup import gatherProcessStats

from gi.repository import GObject, Gst

gatherProcessStats()

class App(object):

    def __init__(self, graph, show):

        self.graph = graph

        self.player = Player(onEOS=self.onEOS)

        self.show = show

        self.playlist = Playlist.fromShow(graph, show)

    def onEOS(self, song):

        self.player.pause()

        self.player.seek(0)

from greplin.scales.cyclonehandler import StatsHandler

from light9.namespaces import L9

from rdfdb.patch import Patch

from rdfdb.syncedgraph import SyncedGraph

from greplin import scales

from standardservice.scalessetup import gatherProcessStats

from cycloneerr import PrettyErrorHandler

from light9.coffee import StaticCoffee

gatherProcessStats()

class EffectEdit(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        self.set_header('Content-Type', 'text/html')

        self.write(open("light9/effecteval/effect.html").read())

    def delete(self):

        graph = self.settings.graph

        uri = URIRef(self.get_argument('uri'))

        with graph.currentState(tripleFilter=(None, L9['effect'], uri)) as g:

            song = ctx = list(g.subjects(L9['effect'], uri))[0]

        self.settings.graph.patch(

        pendingOut: Dict[OutputUri, Tuple[OutputInstance, bytearray]] = {}

        for out in self.outputs:

            pendingOut[OutputUri(out.uri)] = (out, bytearray(512))

        for device, attrs in outputAttrs.items():

            for outputAttr, value in attrs.items():

                output, _index = self.outputMap[(device, outputAttr)]

                outputUri = OutputUri(output.uri)

                index = DmxMessageIndex(_index)

                _, outArray = pendingOut[outputUri]

                if outArray[index] != 0:

                    raise ValueError(f"someone already wrote to index {index}")

                outArray[index] = value

        dt1 = 1000 * (time.time() - now)

        for uri, (out, buf) in pendingOut.items():

            out.update(bytes(buf))

        dt2 = 1000 * (time.time() - now)

        if dt1 > 30:

            log.warn(

                "slow setAttrs: %.1fms -> flush -> %.1fms. lr %s da %s oa %s" %

                (dt1, dt2, len(

                    self.lastRequest), len(deviceAttrs), len(outputAttrs)))

# DMX Controller

# See <TBD>

# Copyright (C) Jonathan Brogdon <jlbrogdon@gmail.com>

# This program is published under a GPLv2 license

#

# This code implements a DMX controller with UI provided

# by LCDproc

#

#######################################################

from pyftdi import ftdi

#FTDI device info

#####################

# DMX USB controller

#####################

class OpenDmxUsb():

    def __init__(self):

        self.baud_rate = 250000

        self.data_bits = 8

        self.stop_bits = 2

        self.parity = 'N'

        self.flow_ctrl = ''

        self.rts_state = 0

        self._init_dmx()

    #Initialize the controller

    def _init_dmx(self):

        self.ftdi.set_baudrate(self.baud_rate)

        self.ftdi.set_flowctrl(self.flow_ctrl)

        self.ftdi.purge_rx_buffer()

        self.ftdi.purge_tx_buffer()

        self.ftdi.set_rts(self.rts_state)

    #Send DMX data

        assert self.ftdi.write_data(channelVals) == 513

        # Need to generate two bits for break

            channelVals[x] = 255

        dmxUsb.send_dmx(channelVals)

    This base class doesn't ever call _write. Subclasses below have

    strategies for that.

    """

    uri: URIRef

    def __init__(self, uri: URIRef):

        self.uri = uri

        self.statPath = '/output%s' % self.shortId()

        scales.init(self, self.statPath)

        self._writeStats = scales.collection(

            scales.RecentFpsStat('fps'))

        self._currentBuffer = b''

        if log.isEnabledFor(logging.DEBUG):

            self._lastLoggedMsg = ''

            task.LoopingCall(self._periodicLog).start(1)

    def reconnect(self):

        pass

    def shortId(self) -> str:

        """short string to distinguish outputs"""

        return self.uri.rstrip('/').rsplit('/')[-1]

    def update(self, buf: bytes) -> None:

        """caller asks for the output to be this buffer"""

        self._currentBuffer = buf

    def _periodicLog(self):

        msg = '%s: %s' % (self.shortId(), ' '.join(map(str,

                                                       self._currentBuffer)))

        if msg != self._lastLoggedMsg:

            log.debug(msg)

            self._lastLoggedMsg = msg

    def _write(self, buf: bytes) -> None:

        """

        write buffer to output hardware (may be throttled if updates are

        too fast, or repeated if they are too slow)

        """

        pass

    def crash(self):

        log.error('unrecoverable- exiting')

        reactor.crash()

class DummyOutput(Output):

    def __init__(self, uri, **kw):

        super().__init__(uri)

class BackgroundLoopOutput(Output):

    """Call _write forever at 20hz in background threads"""

    rate: float

    def __init__(self, uri, rate=22):

            self._writeStats.succeed += 1

            reactor.callLater(max(0, start + 1 / self.rate - time.time()),

                              self._loop)

        def err(e):

            self._writeStats.fail += 1

            log.error(e)

            reactor.callLater(.2, self._loop)

        d = threads.deferToThread(self._write, sendingBuffer)

        d.addCallbacks(done, err)

class FtdiDmx(BackgroundLoopOutput):

    def __init__(self, uri, lastDmxChannel, rate=22):

        super().__init__(uri)

        self.lastDmxChannel = lastDmxChannel

        from .dmx_controller_output import OpenDmxUsb

        self.dmx = OpenDmxUsb()

    def _write(self, buf):

        self._writeStats.fps.mark()

        with self._writeStats.call.time():

            if not buf:

                return

            # ok to truncate the last channels if they just went

            # to 0? No it is not. DMX receivers don't add implicit

            # zeros there.

            buf = bytes([0]) + buf[:self.lastDmxChannel]

            if logAllDmx.isEnabledFor(logging.DEBUG):

                # for testing fps, smooth fades, etc

            self.dmx.send_dmx(buf)

class ArtnetDmx(BackgroundLoopOutput):

    # adapted from https://github.com/spacemanspiff2007/PyArtNet/blob/master/pyartnet/artnet_node.py (gpl3)

    def __init__(self, uri, host, port, rate):

        """sends UDP messages to the given host/port"""

        super().__init__(uri, rate)

        packet = bytearray()

        packet.extend(map(ord, "Art-Net"))

        packet.append(0x00)  # Null terminate Art-Net

class Udmx(BackgroundLoopOutput):

    _reconnections = scales.IntStat('reconnections')

    _connected = scales.IntStat('connected')

    def __init__(self, uri, bus, address, lastDmxChannel, rate=22):

        self.bus = bus

        self.address = address

        self.lastDmxChannel = lastDmxChannel

        self.dev = None

        super().__init__(uri, rate=rate)

        self._errStats = scales.collection(self.statPath + '/write',

        self.reconnect()

    def shortId(self) -> str:

        return super().shortId() + f'_bus={self.bus}'

    def reconnect(self):

        self._connected = 0

        from pyudmx import pyudmx

        self.dev = pyudmx.uDMXDevice()

        if not self.dev.open(bus=self.bus, address=self.address):

            raise ValueError("dmx open failed")

        log.info(f'opened {self.dev}')

        self._connected = 1

        self._reconnections += 1

    #def update(self, buf:bytes):

    #    self._write(buf)

    #def _loop(self):

    #    pass

    def _write(self, buf):

        if not self.dev:

            log.info('%s: trying to connect', self.shortId())

            raise ValueError()

        self._writeStats.fps.mark()

        with self._writeStats.call.time():

            try:

                if not buf:

                    return

                # ok to truncate the last channels if they just went

                # to 0? No it is not. DMX receivers don't add implicit

                # zeros there.

                buf = buf[:self.lastDmxChannel]

                if logAllDmx.isEnabledFor(logging.DEBUG):

                    # for testing fps, smooth fades, etc

                    logAllDmx.debug(

                        '%s: %s...' %

                        (self.shortId(), ' '.join(map(str, buf[:32]))))

                sent = self.dev.send_multi_value(1, buf)

                if sent != len(buf):

                    raise ValueError("incomplete send")

            except ValueError:

                self.reconnect()

                raise

            except usb.core.USBError as e:

                # not in main thread

                if e.errno == 75:

                    self._errStats.overflow += 1

                    return

                    self._errStats.ioError += 1

                    return

                    self._errStats.pipeError += 1

                    return

                msg = 'usb: sending %s bytes to %r; error %r' % (len(buf),

                                                                 self.uri, e)

                log.warn(msg)

                if e.errno == 13:  # permissions

                    return self.crash()

                if e.errno == 19:  # no such dev; usb hw restarted

                    self.reconnect()

                    return

                raise

        L9['device/backlight4'], L9['device/backlight5'], L9['device/down2'],

        L9['device/down3'], L9['device/down4'], L9['device/hexLow3'],

        L9['device/hexLow5'], L9['device/postL1'], L9['device/postR1']

    ]

    out = {}

    col = rgb_to_hex([int(255 * strength)] * 3)

    for i, dev in enumerate(devs):

        n = noise(songTime * 8 + i * 6.543)

        if n > .4:

            out[(dev, L9['color'])] = col

    return out

def sample(img, x, y, repeat=False):

    if 0 <= x < img.width:

        return img.getpixel((x, y))

    elif not repeat:

        return (0, 0, 0)

    else:

        return img.getpixel((x % img.width, y))

def effect_image(effectSettings, strength, songTime, noteTime):

    out = {}

    imgPath = f'cur/anim/{effectSettings[L9["image"]]}'

    t_offset = effectSettings.get(L9['tOffset'], 0)

    pxPerSec = effectSettings.get(L9['pxPerSec'], 30)

    img = Image.open(imgPath)

    x = (noteTime * pxPerSec)

    scl = effectSettings.get(L9['strength'], 1)

    for dev, y in [(L9['theater/skyline/device/strip1'], 0),

                   (L9['theater/skyline/device/strip2'], 1),

                   (L9['theater/skyline/device/strip3'], 2)]:

    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(

        effectSettings[L9['strength']] = self.evalCurve(t)

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

        report['nonZero'] = cast(float, effectSettings[L9['strength']]) > 0

        out, evalReport = self.effectEval.outputFromEffect(

        self.notes: Dict[Song, List[Note]] = {}  # song: [notes]

        self.simpleOutputs = SimpleOutputs(self.graph)

        self.graph.addHandler(self.compileGraph)

        self.lastLoopSucceeded = False

        self.codeWatcher = CodeWatcher(onChange=self.onCodeChange)

        self.updateLoop()

    def onCodeChange(self):

        log.debug('seq.onCodeChange')

        self.graph.addHandler(self.compileGraph)

        #self.updateLoop()

    @compileStats.graph.time()

    def compileGraph(self) -> None:

        """rebuild our data from the graph"""

        for song in self.graph.subjects(RDF.type, L9['Song']):

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

                self.compileSong(song)

            self.graph.addHandler(compileSong)

    @compileStats.song.time()

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

        anyErrors = False

        self.notes[song] = []

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

            try:

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

        try:

        except Exception as e:

            self.lastLoopSucceeded = False

            traceback.print_exc()

            log.warn('updateLoop: %r', e)

            reactor.callLater(1, self.updateLoop)

        else:

            took = time.time() - frameStart

            updateStats.updateLoopLatency = took

            if not self.lastLoopSucceeded:

                log.info('Sequencer.update is working')

                self.lastLoopSucceeded = True

            delay = max(0, 1 / self.fps - took)

            reactor.callLater(delay, self.updateLoop)

    @updateStats.updateFps.rate()

    @inlineCallbacks

    def update(self) -> Deferred:

        with updateStats.s0_getMusic.time():

            musicState = self.music.getLatest()

            if not musicState.get('song') or not isinstance(

                    musicState.get('t'), float):

                return defer.succeed(0.0)

            song = Song(URIRef(musicState['song']))

            dispatcher.send('state',

                            update={

                                'song': str(song),

                                't': musicState['t']

                            })

        with updateStats.s1_eval.time():

            settings = []

            noteReports = []

            for note in songNotes:

                try:

                    s, report = note.outputSettings(musicState['t'])

                except Exception:

                    traceback.print_exc()

                    raise

                noteReports.append(report)

                settings.append(s)

            devSettings = DeviceSettings.fromList(self.graph, settings)

        dispatcher.send('state', update={'songNotes': noteReports})

            sendSecs = yield self.sendToCollector(devSettings)

        # sendToCollector's own measurement.

        # (sometimes it's None, not sure why, and neither is mypy)

        #if isinstance(sendSecs, float):

        #    updateStats.s3_send_client = sendSecs

class Updates(cyclone.sse.SSEHandler):

    def __init__(self, application, request, **kwargs) -> None:

        cyclone.sse.SSEHandler.__init__(self, application, request, **kwargs)

        self.state: Dict = {}

        dispatcher.connect(self.updateState, 'state')

        self.numConnected = 0

    def updateState(self, update: Dict):

        self.state.update(update)

    def bind(self) -> None:

from twisted.internet.defer import Deferred

import traceback

import time

import logging

from rdflib import URIRef

from rdfdb.syncedgraph import SyncedGraph

log = logging.getLogger()

class SubClient:

    graph: SyncedGraph

    session: URIRef

    def __init__(self):

        """assumed that your init saves self.graph"""

        pass  # we may later need init code for network setup

    def get_levels_as_sub(self):

        """Subclasses must implement this method and return a Submaster

        object."""

    def send_levels(self):

        self._send_sub()

    def send_levels_loop(self, delay=1000) -> None: