# return dmx dict for all effects in the song, already combined

class App(object):

    def __init__(self, show, outputWhere):

        self.show = show

        self.outputWhere = outputWhere

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

        self.graph.initiallySynced.addCallback(self.launch)

        self.stats = scales.collection('/',

                                       scales.PmfStat('sendLevels'),

                                       scales.PmfStat('getMusic'),

                                       scales.IntStat('errors'),

                                       )

    def launch(self, *args):

        self.loop = makeEffectLoop(self.graph, self.stats, self.outputWhere)

        self.loop.startLoop()

        SFH = cyclone.web.StaticFileHandler

        self.cycloneApp = cyclone.web.Application(handlers=[

            (r'/()', SFH,

             {'path': 'light9/effecteval', 'default_filename': 'index.html'}),

            (r'/effect', EffectEdit),

            with self.stats.sendLevels.time():

                with self.stats.getMusic.time():

                    songTime, song = yield self.getSongTime()

                if song != self.currentSong:

                    self.currentSong = song

                    # this may be piling on the handlers

                    self.graph.addHandler(self.setEffects)

                if song is None:

                    return

                combined = self.combineOutputs(outputs)

                self.logLevels(t1, combined)

                elapsed = time.time() - t1

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

        except Exception:

            self.stats.errors += 1

            traceback.print_exc()

            dt = 1

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

        log.info('outputs %r', outputs)

        out = Submaster.sub_maxes(*outputs)

        return out

    @inlineCallbacks

    def sendOutput(self, combined):

        dmx = combined.get_dmx_list()

    def allEffectOutputs(self, songTime):

        outputs = []

        for e in self.currentEffects:

            try:

                outputs.append(e.eval(songTime))

            except Exception as exc:

                now = time.time()

                if now > self.lastErrorLog + 5:

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

                    self.lastErrorLog = now

        return outputs