from rdflib import URIRef, Literal

sys.path.append('/usr/lib/pymodules/python2.7/') # for numpy, on rpi

sys.path.append('/usr/lib/python2.7/dist-packages') # For numpy

from light9 import networking, showconfig, Submaster, dmxclient

from light9.curvecalc import musicaccess

from light9.curvecalc.curve import CurveResource

from light9.effecteval.effect import EffectNode

from light9.effecteval.effectloop import makeEffectLoop

from light9.greplin_cyclone import StatsForCyclone

from light9.namespaces import L9, RDF, RDFS

from light9.rdfdb.patch import Patch

from light9.rdfdb.syncedgraph import SyncedGraph

from greplin import scales

from lib.cycloneerr import PrettyErrorHandler

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

    def get(self):

        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(Patch(delQuads=[

            (song, L9['effect'], uri, ctx),

            ]))

def clamp(x, lo, hi):

    return max(lo, min(hi, x))

@inlineCallbacks

def getMusicStatus():

    returnValue(json.loads((yield cyclone.httpclient.fetch(

        networking.musicPlayer.path('time'), timeout=.5)).body))

@inlineCallbacks

def newEnvelopeCurve(graph, ctx, uri, label):

    """this does its own patch to the graph"""

    cr = CurveResource(graph, uri)

    cr.newCurve(ctx, label=Literal(label))

    yield insertEnvelopePoints(cr.curve)

    cr.saveCurve()

@inlineCallbacks

def insertEnvelopePoints(curve):

    musicStatus = yield getMusicStatus()

    songTime=musicStatus['t']

    songDuration=musicStatus['duration']

    fade = 2

    t1 = clamp(songTime - fade, .1, songDuration - .1 * 2) + fade

    t2 = clamp(songTime + 20, t1 + .1, songDuration)

    curve.insert_pt((t1 - fade, 0))

    curve.insert_pt((t1, 1))

    curve.insert_pt((t2, 1))

    curve.insert_pt((t2 + fade, 0))

def newEffect(graph, song, ctx):

    effect = graph.sequentialUri(song + "/effect-")

    quads = [

        (song, L9['effect'], effect, ctx),

        (effect, RDF.type, L9['Effect'], ctx),

    ]

    print "newEffect", effect, quads

    return effect, quads

def musicCurveForSong(uri):

    return URIRef(uri + 'music')

def maybeAddMusicLine(quads, effect, song, ctx):

    """

    add a line getting the current music into 'music' if any code might

    be mentioning that var

    """

    for spoc in quads:

        if spoc[1] == L9['code'] and 'music' in spoc[2]:

            quads.extend([

                (effect, L9['code'],

                 Literal('music = %s' % musicCurveForSong(song).n3()), ctx)

                ])

            break

@inlineCallbacks

def currentSong():

    s = (yield getMusicStatus())['song']

    if s is None:

        raise ValueError("no current song")

    returnValue(URIRef(s))

def songHasEffect(graph, song, uri):

                out[localVar] = CouldNotConvert(uri)

        return out

class EffectNode(object):

    def __init__(self, graph, uri):

        self.graph, self.uri = graph, uri

        # this is not expiring at the right time, when an effect goes away

        self.graph.addHandler(self.prepare)

    @prof.logTime

    def prepare(self):

        log.info("prepare effect %s", self.uri)

        # maybe there can be multiple lines of code as multiple

        # objects here, and we sort them by dependencies

        codeStrs = list(self.graph.objects(self.uri, L9['code']))

        if not codeStrs:

            raise ValueError("effect %s has no code" % self.uri)

        self.codes = [CodeLine(self.graph, s) for s in codeStrs]

        self.sortCodes()

        #reload(Effects)

        self.otherFuncs = prof.logTime(Effects.configExprGlobals)()

    def sortCodes(self):

        """put self.codes in a working evaluation order"""

        codeFromOutput = dict((c.outName, c) for c in self.codes)

        deps = {}

        for c in self.codes:

            outName = c.outName

            inNames = c.possibleVars.intersection(codeFromOutput.keys())

            inNames.discard(outName)

            deps[outName] = inNames

        self.codes = [codeFromOutput[n] for n in toposort.toposort_flatten(deps)]

    def eval(self, songTime):

        ns = {'t': songTime}

        ns.update(self.otherFuncs)

        ns.update(dict(

            curve=lambda c, t: c.eval(t),

            ))

        for c in self.codes:

            codeNs = ns.copy()

            codeNs.update(c.pyResources)

            ns[c.outName] = lineOut

        if 'out' not in ns:

            log.error("ran code for %s, didn't make an 'out' value", self.uri)

        return ns['out']

    @inlineCallbacks

    def sendLevels(self):

        t1 = time.time()

        log.debug("time since last call: %.1f ms" % (1000 * (t1 - self.lastSendLevelsTime)))

        self.lastSendLevelsTime = t1

        try:

            with self.stats.sendLevels.time():

                if self.currentSong is not None:

                    with self.stats.evals.time():

                        outputs = self.allEffectOutputs(self.estimatedSongTime())

                    combined = self.combineOutputs(outputs)

                    self.logLevels(t1, combined)

                    with self.stats.sendOutput.time():

                        yield self.sendOutput(combined)

                elapsed = time.time() - t1

                dt = max(0, self.period - elapsed)

        except Exception:

            self.stats.errors += 1

            traceback.print_exc()

            dt = .5

        reactor.callLater(dt, self.sendLevels)

    def combineOutputs(self, outputs):

        """pick usable effect outputs and reduce them into one for sendOutput"""

        outputs = [x for x in outputs if isinstance(x, Submaster.Submaster)]

        out = Submaster.sub_maxes(*outputs)

        return out

    @inlineCallbacks

    def sendOutput(self, combined):

        dmx = combined.get_dmx_list()

        yield dmxclient.outputlevels(dmx, twisted=True)

    def allEffectOutputs(self, songTime):

        outputs = []

        for e in self.currentEffects:

            try:

                out = e.eval(songTime)

                if isinstance(out, (list, tuple)):

                    outputs.extend(out)

                else:

                    outputs.append(out)

            except Exception as exc:

                now = time.time()

                if now > self.lastErrorLog + 5:

                    log.error("effect %s: %s" % (e.uri, exc))

                    self.lastErrorLog = now

        log.debug('eval %s effects, got %s outputs', len(self.currentEffects), len(outputs))

        return outputs

    def logLevels(self, now, out):

        # this would look nice on the top of the effecteval web pages too

        if log.isEnabledFor(logging.DEBUG):

            log.debug(self.logMessage(out))

        else:

            if now > self.lastLogTime + 5:

                msg = self.logMessage(out)

                if msg != self.lastLogMsg:

                    log.info(msg)

                    self.lastLogMsg = msg

                self.lastLogTime = now

    def logMessage(self, out):

        return ("send dmx: {%s}" %

                ", ".join("%r: %.3g" % (str(k), v)

                          for k,v in out.get_levels().items()))

Z = numpy.zeros((50, 3), dtype=numpy.uint8)

class LedLoop(EffectLoop):

    def initOutput(self):

        kw = dict(baudrate=115200)

        self.boards = {

            'L': serial.Serial('/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A7027JI6-if00-port0', **kw),

            'R': serial.Serial('/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A7027NYX-if00-port0', **kw),

        }

        self.lastSentBacklight = None

    def combineOutputs(self, outputs):

        combined = {'L': Z, 'R': Z, 'blacklight': 0}

        for out in outputs:

            if isinstance(out, Effects.Blacklight):

                combined['blacklight'] = max(combined['blacklight'], int(out * 255))

            elif isinstance(out, Effects.Strip):

                pixels = numpy.array(out.pixels, dtype=numpy.float16)

                px255 = (numpy.clip(pixels, 0, 1) * 255).astype(numpy.uint8)

                for w in out.which:

                    combined[w] = numpy.maximum(combined[w], px255)

        return combined