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

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

            ]))

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

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

        quads = [

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

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

        ]

        with graph.currentState(

                tripleFilter=(dropped, None, None)) as g:

            droppedLabel = g.label(dropped)

        if L9['EffectClass'] in droppedTypes:

            quads.extend([

                (effect, RDFS.label, droppedLabel, ctx),

                (effect, RDF.type, dropped, ctx),

                ] + [(effect, L9['code'], c, ctx) for c in droppedCodes])

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

            cr = CurveResource(graph, curve)

            cr.newCurve(ctx, label=Literal('sub %s' % droppedLabel))

            cr.saveCurve()

            quads.extend([

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

                (effect, L9['code'],

                 Literal('out = %s * %s' % (dropped.n3(), curve.n3())),

                 ctx),

                ])

        else:

            raise NotImplementedError(

                "don't know how to add an effect from %r (types=%r)" %

                (dropped, droppedTypes))

        graph.patch(Patch(addQuads=quads))

class SongEffectsUpdates(cyclone.websocket.WebSocketHandler):

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

        self.graph = self.settings.graph

        self.graph.addHandler(self.updateClient)

    def updateClient(self):

        # todo: abort if client is gone

        playlist = self.graph.value(showconfig.showUri(), L9['playList'])

        songs = list(self.graph.items(playlist))

        out = []

        for s in songs:

            out.append({'uri': s, 'label': self.graph.label(s)})

            out[-1]['effects'] = [{'uri': uri} for uri in sorted(self.graph.objects(s, L9['effect']))]

        self.sendMessage({'songs': out})

class EffectUpdates(cyclone.websocket.WebSocketHandler):

    """

    stays alive for the life of the effect page

    """

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

        log.info("websocket opened")

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

        self.sendMessage({'hello': repr(self)})

        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