#!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

from rdflib import URIRef, Literal

sys.path.append(".")

from light9 import networking, showconfig, Submaster, dmxclient

from light9.curvecalc.curve import CurveResource

from light9.effecteval.effect import EffectNode

    def post(self):

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

        dropped = URIRef(self.get_argument('drop'))

        ctx = song

        graph = self.settings.graph

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

        with graph.currentState(

class SongEffectsUpdates(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        self.graph = self.settings.graph

        self.graph.addHandler(self.updateClient)

        self.graph = self.settings.graph

        self.graph.addHandler(self.updateClient)

    def updateClient(self):

        # todo: if client has dropped, abort and don't get any more

        # graph updates

    def connectionLost(self, reason):

        log.info("websocket closed")

    def messageReceived(self, message):

        log.info("got message %s" % message)

        # write a patch back to the graph

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

    def put(self):

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

        with self.settings.graph.currentState(

                tripleFilter=(None, L9['effect'], effect)) as g:

            song = g.subjects(L9['effect'], effect).next()

        # right here we could tell if the code has a python error and return it

        self.send_error(202)

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

    @inlineCallbacks

    def get(self):

from __future__ import division

import logging, colorsys

import light9.Submaster as Submaster

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

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:

        names = names[:]

        r.shuffle(names)

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

    lev = {}

    for uri, value in chase_vals.items():

                   uri))

            continue

        lev[dmx] = value

    return Submaster.Submaster(name="chase" ,levels=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)

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...

    """

            lev[dmx] = 1

        else:

            break

    return Submaster.Submaster(name="stack", levels=lev)

def configExprGlobals():

    graph = showconfig.getGraph()

    ret = {}

    for chaseUri in graph.subjects(RDF.type, L9['Chase']):

        shortName = chaseUri.rsplit('/')[-1]

        chans = graph.value(chaseUri, L9['channels'])

        ret[shortName] = list(graph.items(chans))

        print "%r is a chase" % shortName

    return ret

class Expr(object):

    """singleton, provides functions for use in subterm expressions,

    e.g. chases"""

    def __init__(self):

        self.effectGlobals = light9.Effects.configExprGlobals()

    def exprGlobals(self, startDict, t):

        """globals dict for use by expressions"""

        glo = startDict.copy()

        # add in functions from Effects

        glo.update(self.effectGlobals)

        glo['within'] = lambda a, b: a < t < b

        glo['bef'] = lambda x: t < x

        def aft(t, x, smooth=0):

            left = x - smooth / 2

            right = x + smooth / 2

            if left < t < right:

            return t > x

        glo['aft'] = lambda x, smooth=0: aft(t, x, smooth)

        return glo

exprglo = Expr()

class Subterm(object):

qs = new QueryString()

model =

socket = reconnectingWebSocket "ws://localhost:8070/effectUpdates" + window.location.search, (msg) ->

  console.log('effectData ' + JSON.stringify(msg))

  $.ajax

    type: 'PUT'

    url: 'code'

ko.applyBindings(model)

    <title>effect</title>

    <meta charset="utf-8" />

    <link rel="stylesheet" href="static/style.css">

  </head>

  <body>

    <script src="static/jquery-2.1.1.min.js"></script>

    <script src="static/knockout-3.1.0.js"></script>

    <script src="static/websocket.js"></script>

    <script src="static/QueryString.js"></script>

    <script src="effect.js"></script>

import re, logging

from rdflib import URIRef

from light9.namespaces import L9, RDF

from light9.curvecalc.curve import CurveResource

log = logging.getLogger('effect')

def uriFromCode(s):

    # i thought this was something a graph could do with its namespace manager

    if s.startswith('sub:'):

        return URIRef('http://light9.bigasterisk.com/show/dance2014/sub/' + s[4:])

class CodeLine(object):

    """code string is immutable"""

    def __init__(self, graph, code):

        self.graph, self.code = graph, code

        self.outName, self.expr, self.resources = self._asPython()

    def _asPython(self):

        """

        out = sub(<uri1>, intensity=<curveuri2>)

        becomes

          'out',

        return lname, outExpr, resources

    def _uriIsCurve(self, uri):

        # this result could vary with graph changes (rare)

        return self.graph.contains((uri, RDF.type, L9['Curve']))

        """

        mapping of the local names for uris in the code to high-level

        objects (Submaster, Curve)

        """

        out = {}

        subs = Submaster.get_global_submasters(self.graph)

            for rdfClass in self.graph.objects(uri, RDF.type):

                if rdfClass == L9['Curve']:

                    cr = CurveResource(self.graph, uri)

                    cr.loadCurve()

                    out[localVar] = cr.curve

                elif rdfClass == L9['Submaster']:

                    out[localVar] = subs.get_sub_by_uri(uri)

                else:

                    out[localVar] = uri

        return out

    def eval(self, songTime):

        ns = {'t': songTime}

        ns.update(dict(

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

            ))

        # loop over lines in order, merging in outputs 

        # merge in named outputs from previous lines

                        outSubs.append(e.eval(songTime))

                    except Exception as exc:

                        now = time.time()

                        if now > self.lastErrorLog + 5:

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

                            log.error("  expr: %s", e.code.expr)

                            self.lastErrorLog = now

                out = Submaster.sub_maxes(*outSubs)

                self.logLevels(t1, out)

                dmx = out.get_dmx_list()

                with self.stats.writeDmx.time():

class Model

  constructor: ->

    @chases = ko.observable([])

    @moreExprs = [

      {label: "rainbow", expr: "hsv(t*1,1,1)"},

      {label: "pulserainbow", expr: "hsv(t*1,1,1)*nsin(t*2)"},

      {label: "stacrainbow", expr: "hsv(t*1,1,1)*(nsin(t*2)>.7)"},

      {label: "alternatergb", expr: "hsv(t*1,1,1, light='left')*nsin(t*3) + hsv(t*1,1,1,light='right')*(1-nsin(t*3))"},

  subtermExprs: (chase) =>

    [

      'chase(t, names=LABEL, ontime=0.5, offset=0.2)'.replace(/LABEL/g, chase.label)

    ]

model = new Model()

reconnectingWebSocket "ws://localhost:8052/effectsUpdates", (msg) ->

  model.chases(msg.chases) if msg.chases?

# this sort of works to stop clicks in <input> from following the

# submaster hyperlink, but it may make certain clicks act wrong

$(document).on('click', 'a', (ev) ->

  return false if ev.target.tagName == 'INPUT'

)

      div.resource.chase

        | Chase

        a(data-bind="attr: {href: uri}, text: label")

        ul(data-bind="foreach: $parent.subtermExprs($data)")

          li: a.resource(data-bind="attr: {href: $root.subtermLink($parent.label, $data)}, text: $data")

    #status

    script(src="static/jquery-2.1.1.min.js")

    script(src="static/knockout-3.1.0.js")

    script(src="static/websocket.js")

    script(src="effects.js")