#!bin/python

from __future__ import division

from run_local import log

from twisted.internet import reactor

from twisted.internet.defer import inlineCallbacks, returnValue

import cyclone.web, cyclone.websocket, cyclone.httpclient

import sys, optparse, logging, subprocess, json, time, traceback, itertools

from rdflib import URIRef, Literal

from light9 import networking, showconfig, Submaster, dmxclient

from light9.curvecalc.curve import CurveResource

from light9.effecteval.effect import EffectNode

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

        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.PmfStat('writeDmx'),

                                       scales.IntStat('errors'),

                                       )

    def launch(self, *args):

        SFH = cyclone.web.StaticFileHandler

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

            (r'/()', SFH,

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

            (r'/effect', EffectEdit),

            (r'/(websocket\.js)', SFH, {'path': 'light9/rdfdb/web/'}),

            (r'/effect\.js', StaticCoffee, {'src': 'light9/effecteval/effect.coffee'}),

            (r'/index\.js', StaticCoffee, {'src': 'light9/effecteval/index.coffee'}),

            (r'/effectUpdates', EffectUpdates),

            (r'/code', Code),

            (r'/songEffectsUpdates', SongEffectsUpdates),

            '/usr/bin/coffee', '--compile', '--print', self.src]))

if __name__ == "__main__":

    parser = optparse.OptionParser()

    parser.add_option('--show',

        help='show URI, like http://light9.bigasterisk.com/show/dance2008',

                      default=showconfig.showUri())

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    parser.add_option("--twistedlog", action="store_true",

                      help="twisted logging")

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    if not options.show:

        raise ValueError("missing --show http://...")

    if options.twistedlog:

        from twisted.python import log as twlog

        twlog.startLogging(sys.stderr)

    reactor.run()

from chase import chase as chase_logic

import showconfig

from rdflib import RDF

from light9 import Patch

from light9.namespaces import L9

log = logging.getLogger()

registered = []

def register(f):

    registered.append(f)

    return f

@register

def chase(t, ontime=0.5, offset=0.2, onval=1.0, 

          offval=0.0, names=None, combiner=max, random=False):

    """names is list of URIs. returns a submaster that chases through

    the inputs"""

    if random:

        r = random_mod.Random(random)

        names = names[:]

        r.shuffle(names)

    chase_vals = chase_logic(t, ontime, offset, onval, offval, names, combiner)

    lev = {}

def hsv(h, s, v, light='all', centerScale=.5):

    r,g,b = colorsys.hsv_to_rgb(h % 1.0, s, v)

    lev = {}

    if light in ['left', 'all']:

        lev[73], lev[74], lev[75] = r,g,b

    if light in ['right', 'all']:

        lev[80], lev[81], lev[82] = r,g,b

    if light in ['center', 'all']:

        lev[88], lev[89], lev[90] = r*centerScale,g*centerScale,b*centerScale

    return Submaster.Submaster(name='hsv', levels=lev)

@register

def stack(t, names=None, fade=0):

    """names is list of URIs. returns a submaster that stacks the the inputs

    fade=0 makes steps, fade=1 means each one gets its full fraction

    of the time to fade in. Fades never...

    """

    frac = 1.0 / len(names)

    lev = {}

    for i, uri in enumerate(names):

        if t >= (i + 1) * frac:

            try:

from __future__ import division

import time, json, logging, traceback

from twisted.internet import reactor

from rdflib import URIRef, Literal

import cyclone.httpclient

from light9.namespaces import L9, RDF, RDFS

from light9.effecteval.effect import EffectNode

from light9 import networking

from light9 import Submaster

from light9 import dmxclient

log = logging.getLogger('effectloop')

class EffectLoop(object):

    """maintains a collection of the current EffectNodes, gets time from

    music player, sends dmx"""

    def __init__(self, graph, stats):

        self.graph, self.stats = graph, stats

        self.currentSong = None

        self.currentEffects = []

        self.lastLogTime = 0

        self.lastLogMsg = ""

        self.lastErrorLog = 0

        self.graph.addHandler(self.setEffects)

        self.period = 1 / 30

        self.coastSecs = .3 # main reason to keep this low is to notice play/pause

        self.songTimeFromRequest = 0

        self.requestTime = 0 # unix sec for when we fetched songTime

        reactor.callLater(self.period, self.sendLevels)

    def setEffects(self):

        self.currentEffects = []

        if self.currentSong is None:

            return

        for effectUri in self.graph.objects(self.currentSong, L9['effect']):

            self.currentEffects.append(EffectNode(self.graph, effectUri))

    @inlineCallbacks

    def getSongTime(self):

                if song != self.currentSong:

                    self.currentSong = song

                    # this may be piling on the handlers

                    self.graph.addHandler(self.setEffects)

                if song is None:

                    return

                outputs = self.allEffectOutputs(songTime)

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

        out = Submaster.sub_maxes(*outputs)

        return out

    @inlineCallbacks

    def sendOutput(self, combined):

        dmx = combined.get_dmx_list()

        with self.stats.writeDmx.time():

            yield dmxclient.outputlevels(dmx, twisted=True)

    def allEffectOutputs(self, songTime):

        outputs = []

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