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

import light9.effect.effecteval

from bcf2000 import BCF2000

nudge_keys = {

    'up'   : list('qwertyui'),

    'down' : list('asdfghjk')

}

class DummySliders:

    def valueOut(self, name, value):

        pass

        self.slider_table = {} # coords : SubmasterBox

        self.rows = [] # this holds Tk Frames for each row

        self.current_row = 0 # should come from session graph

        self.use_hw_sliders = hw_sliders

        self.connect_to_hw(hw_sliders)

        self.make_key_hints()

        self.make_buttons()

        self.graph.addHandler(self.redraw_sliders)

        self.graph.addHandler(self.rowFromGraph)

    def make_buttons(self):

        self.buttonframe = tk.Frame(self, bg='black')

        self.buttonframe.pack(side=tk.BOTTOM)

        self.sliders_status_var = tk.IntVar()

        self.sliders_status_var.set(self.use_hw_sliders)

        self.sliders_checkbutton = tk.Checkbutton(self.buttonframe,

            text="Sliders", variable=self.sliders_status_var,

            command=lambda: self.toggle_slider_connectedness(),

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

def resolve(deviceType, deviceAttr, values):

    """

    return one value to use for this attr, given a set of them that

    have come in simultaneously. len(values) >= 1.

    """

    if len(values) == 1:

        return values[0]

    if deviceAttr == L9['color']:

        rgbs = [hex_to_rgb(v) for v in values]

        return rgb_to_hex([max(*component) for component in zip(*rgbs)])

    # angles should perhaps use average; gobo choice use the most-open one

    return max(values)

def toOutputAttrs(deviceType, deviceAttrSettings):

    """

    Given device attr settings like {L9['color']: Literal('#ff0000')},

    return a similar dict where the keys are output attrs (like

    L9['red']) and the values are suitable for Collector.setAttr

    :outputAttrRange happens before we get here.

    """

    def floatAttr(attr, default=0):

        out = deviceAttrSettings.get(attr)

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

        return value * strength

    else:

        raise NotImplementedError(repr(value))

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

        self.graph = graph

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

        self.effectOutputs = {}

        #for ds in g.objects(g.value(uri, L9['effectClass']), L9['deviceSetting']):

        #    self.setting = (g.value(ds, L9['device']), g.value(ds, L9['attr']))

        self.graph.addHandler(self.updateEffectsFromGraph)

    def updateEffectsFromGraph(self):

        self.effectOutputs = {}

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

        p1, p2 = self.points[i], self.points[i + 1]

        frac = (t - p1[0]) / (p2[0] - p1[0])

        y = p1[1] + (p2[1] - p1[1]) * frac

        return y

    def outputSettings(self, t):

        """

        list of (device, attr, value)

        """

        effectSettings = [(L9['strength'], self.evalCurve(t))]

        return self.effectEval.outputFromEffect(effectSettings, t)

class Sequencer(object):

    def __init__(self, graph, sendToCollector):

        self.graph = graph

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

        self.recentUpdateTimes = []

        self.lastStatLog = 0

        self.notes = {} # song: [notes]

        self.graph.addHandler(self.compileGraph)

        self.update()

    def compileGraph(self):

        """rebuild our data from the graph"""

        g = self.graph

        for song in g.subjects(RDF.type, L9['Song']):

            self.notes[song] = []

            for note in g.objects(song, L9['note']):

                self.notes[song].append(Note(g, note, effecteval))

    @stats.update.time()

    def update(self):

        now = time.time()

        self.recentUpdateTimes = self.recentUpdateTimes[-20:] + [now]

        stats.recentFps = len(self.recentUpdateTimes) / (self.recentUpdateTimes[-1] - self.recentUpdateTimes[0] + .0001)

        if now > self.lastStatLog + 10:

            log.info("%.2f fps", stats.recentFps)