from light9 import networking

from light9.effect.settings import DeviceSettings

from twisted.internet import defer

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPushConnection

import json, time, logging

import treq

from greplin import scales

log = logging.getLogger('coll_client')

_zmqClient = None

stats = scales.collection(

    scales.PmfStat('send', recalcPeriod=1),

)

class TwistedZmqClient(object):

    def __init__(self, service):

        zf = ZmqFactory()

        e = ZmqEndpoint('connect', 'tcp://%s:%s' % (service.host, service.port))

        self.conn = ZmqPushConnection(zf, e)

    def send(self, msg):

        self.conn.push(msg)

def toCollectorJson(client, session, settings) -> str:

    assert isinstance(settings, DeviceSettings)

    return json.dumps({

        'settings': settings.asList(),

        'client': client,

        'clientSession': session,

        'sendTime': time.time(),

    })

from twisted.internet.defer import Deferred, inlineCallbacks

from twisted.internet.inotify import INotify

from twisted.python.filepath import FilePath

import cyclone.sse

import logging, bisect, time

import traceback

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 rdfdb.syncedgraph import SyncedGraph

from standardservice.scalessetup import gatherProcessStats

from greplin import scales

import imp

log = logging.getLogger('sequencer')

gatherProcessStats()

updateStats = scales.collection(

    scales.PmfStat('s0_getMusic', recalcPeriod=1),

    scales.PmfStat('s1_eval', recalcPeriod=1),

    #scales.PmfStat('s3_send_client', recalcPeriod=1),

    scales.PmfStat('s3_send', recalcPeriod=1),

    scales.PmfStat('updateLoopLatency', recalcPeriod=1),

    scales.DoubleStat('updateLoopLatencyGoal'),

    scales.RecentFpsStat('updateFps'),

    scales.DoubleStat('goalFps'),

)

compileStats = scales.collection(

    scales.PmfStat('graph', recalcPeriod=1),

    scales.PmfStat('song', recalcPeriod=1),

)

class Note(object):

    def __init__(self, graph: SyncedGraph, uri: NoteUri, effectevalModule,

                 simpleOutputs):

        g = self.graph = graph

        self.uri = uri

        self.effectEval = effectevalModule.EffectEval(

            graph, g.value(uri, L9['effectClass']), simpleOutputs)

        self.baseEffectSettings: Dict[URIRef, Any] = {}  # {effectAttr: value}

        for s in g.objects(uri, L9['setting']):

            settingValues = dict(g.predicate_objects(s))

            ea = settingValues[L9['effectAttr']]

            self.baseEffectSettings[ea] = settingValues[L9['value']]

        def floatVal(s, p):

            return float(g.value(s, p).toPython())

        originTime = floatVal(uri, L9['originTime'])

        self.points: List[Tuple[float, float]] = []

            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 = []

            songNotes = sorted(self.notes.get(song, []),

                               key=lambda n: n.uri)

            noteReports = []

            for note in songNotes:

                noteReports.append(report)

                settings.append(s)

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

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

        with updateStats.s3_send.time(): # our measurement

            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)