#!bin/python

from __future__ import division, nested_scopes

from run_local import log

import cgi, time, logging

from optparse import OptionParser

import webcolors, colorsys

from louie import dispatcher

from twisted.internet import reactor, tksupport

from twisted.web import resource

from rdflib import URIRef, Literal

import Tix as tk

from light9.Fadable import Fadable

from light9.subclient import SubClient

from light9 import showconfig, networking, prof

from light9.uihelpers import toplevelat

from light9.namespaces import L9, RDF

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.rdfdb import clientsession

from light9.rdfdb.syncedgraph import SyncedGraph

from light9.effect.sequencer import CodeWatcher

import light9.effect.effecteval

from bcf2000 import BCF2000

nudge_keys = {

    'up'   : list('qwertyui'),

    'down' : list('asdfghjk')

}

class DummySliders:

    def valueOut(self, name, value):

        pass

    def close(self):

        pass

    def reopen(self):

        pass

class SubScale(tk.Scale, Fadable):

    def __init__(self, master, *args, **kw):

        self.scale_var = kw.get('variable') or tk.DoubleVar()

        kw.update({'variable' : self.scale_var,

                   'from' : 1, 'to' : 0, 'showvalue' : 0,

                   'sliderlength' : 15, 'res' : 0.01,

                   'width' : 40, 'troughcolor' : 'black', 'bg' : 'grey40',

                   'highlightthickness' : 1, 'bd' : 1,

                   'highlightcolor' : 'red', 'highlightbackground' : 'black',

                   'activebackground' : 'red'})

        tk.Scale.__init__(self, master, *args, **kw)

        Fadable.__init__(self, var=self.scale_var, wheel_step=0.05)

        self.draw_indicator_colors()

    def draw_indicator_colors(self):

        if self.scale_var.get() == 0:

            self['troughcolor'] = 'black'

        else:

            self['troughcolor'] = 'blue'

class SubmasterBox(tk.Frame):

    """

    this object owns the level of the submaster (the rdf graph is the

    real authority)

    """

    def __init__(self, master, graph, sub, session, col, row):

        self.graph = graph

        self.sub = sub

        self.session = session

        self.col, self.row = col, row

        bg = self.graph.value(sub, L9.color, default='#000000')

        rgb = webcolors.hex_to_rgb(bg)

        hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])

            hsv[0], hsv[1], .2)]))

        tk.Frame.__init__(self, master, bd=1, relief='raised', bg=bg)

        self.name = self.graph.label(sub)

        self.slider_var = tk.DoubleVar()

        self.pauseTrace = False

        self.scale = SubScale(self, variable=self.slider_var, width=20)

        self.namelabel = tk.Label(self, font="Arial 7", bg=darkBg,

            fg='white', pady=0)

        self.graph.addHandler(self.updateName)

        self.namelabel.pack(side=tk.TOP)

        levellabel = tk.Label(self, textvariable=self.slider_var, font="Arial 6",

            bg='black', fg='white', pady=0)

        levellabel.pack(side=tk.TOP)

        self.scale.pack(side=tk.BOTTOM, expand=1, fill=tk.BOTH)

        for w in [self, self.namelabel, levellabel]:

            dragSourceRegister(w, 'copy', 'text/uri-list', sub)

        self._slider_var_trace = self.slider_var.trace('w', self.slider_changed)

        self.graph.addHandler(self.updateLevelFromGraph)

        group = row.subGroup

        self.graph.patchObject(

            context=self.session,

            subject=sub, predicate=L9['group'], newObject=group)

    def highlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'red'

    def unhighlight_row(self, row):

        row = self.rows[row]

        row['bg'] = 'black'

    def get_levels(self):

        return dict([(uri, box.slider_var.get())

            for uri, box in self.subbox.items()])

    def get_output_settings(self):

        outputSettings = []

        for setting in graph.objects(self.session, L9['subSetting']):

            effect = graph.value(setting, L9['sub'])

            strength = graph.value(setting, L9['level'])

            if strength:

                now = time.time()

                    self.effectEval[effect].outputFromEffect(

                        [(L9['strength'], strength)],

                        songTime=now,

                        # should be counting from when you bumped up from 0

                        noteTime=now))

    def save_current_stage(self, subname):

        raise NotImplementedError

        log.info("saving current levels as %s", subname)

        with self.graph.currentState() as current:

            sub = self.get_levels_as_sub(graph=current)

        log.debug("new sub for reference: %r", sub)

        newUri = showconfig.showUri() + "/sub/%s" % subname

        ps = PersistentSubmaster(self.graph, newUri)

        ps.changeName(subname)

        for chanName, v in sub.get_levels().items():

            chan = get_channel_uri(str(chanName))

            ps.editLevel(chan, v)

        self.sub_name.delete(0, tk.END)

    def send_frequent_updates(self):

        """called when we get a fade -- send events as quickly as possible"""

        if time.time() <= self.stop_frequent_update_time:

            self.send_levels()

            self.after(10, self.send_frequent_updates)

from __future__ import division

from rdflib import URIRef, Literal

from light9.namespaces import L9, RDF, DEV

from webcolors import rgb_to_hex, hex_to_rgb

from colorsys import hsv_to_rgb

from decimal import Decimal

import math

from noise import pnoise1

import logging

import time

from light9.effect.settings import DeviceSettings

log = logging.getLogger('effecteval')

def literalColor(rnorm, gnorm, bnorm):

    return Literal(rgb_to_hex([rnorm * 255, gnorm * 255, bnorm * 255]))

def literalColorHsv(h, s, v):

    return literalColor(*hsv_to_rgb(h, s, v))

def nsin(x): return (math.sin(x * (2 * math.pi)) + 1) / 2

def ncos(x): return (math.cos(x * (2 * math.pi)) + 1) / 2

def nsquare(t, on=.5):

    return (t % 1.0) < on

def lerp(a, b, t):

    return a + (b - a) * t

def noise(t):

    return pnoise1(t % 1000.0, 2)

def scale(value, strength):

    elif isinstance(value, (int, float)):

        return value * strength

    raise NotImplementedError("%r,%r" % (value, strength))

class EffectEval(object):

    """

    runs one effect's code to turn effect attr settings into output

    device settings. No state; suitable for reload().

    """

    def __init__(self, graph, effect, sharedEffectOutputs):

        self.graph = graph

        self.effect = effect 

        # effect : [(dev, attr, value, isScaled)]

        self.effectOutputs = sharedEffectOutputs

        if not self.effectOutputs:

            self.graph.addHandler(self.updateEffectsFromGraph)

    def updateEffectsFromGraph(self):

        for effect in self.graph.subjects(RDF.type, L9['Effect']):

            settings = []

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

                settings.append((d, a, v if v is not None else sv, bool(sv)))

            if settings:

                self.effectOutputs[effect] = settings

            # also have to read eff :effectAttr [ :tint x; :tintStrength y ]

    def outputFromEffect(self, effectSettings, songTime, noteTime):

        """

        From effect attr settings, like strength=0.75, to output device

        settings like light1/bright=0.72;light2/bright=0.78. This runs

        the effect code.

        """

        # both callers need to apply note overrides

        effectSettings = dict(effectSettings) # we should make everything into nice float and Color objects too

        strength = float(effectSettings[L9['strength']])

        if strength <= 0:

            return DeviceSettings(self.graph, [])

        out = {} # (dev, attr): value

        out.update(self.simpleOutput(strength,

                                     effectSettings.get(L9['colorScale'], None)))