#!bin/python

from __future__ import division, nested_scopes
from run_local import log
import cgi, os, sys, time, subprocess, logging, random
from optparse import OptionParser
import webcolors, colorsys
from louie import dispatcher
from twisted.internet import reactor, tksupport
from twisted.web import xmlrpc, server, resource
from rdflib import URIRef, Literal, RDF
from Tix import *
import Tix as tk
import pickle

from light9.Fadable import Fadable
from light9.Submaster import Submasters, sub_maxes, PersistentSubmaster
from light9.Patch import get_channel_uri
from light9.subclient import SubClient
from light9 import dmxclient, showconfig, networking, prof
from light9.uihelpers import toplevelat, bindkeys
from light9.namespaces import L9
from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister
from light9.rdfdb import clientsession
from light9.rdfdb.syncedgraph import SyncedGraph
from light9.rdfdb.patch import Patch

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(Scale, Fadable):
    def __init__(self, master, *args, **kw):
        self.scale_var = kw.get('variable') or 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'})
        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(Frame):
    """
    this object owns the level of the submaster (the rdf graph is the
    real authority)
    """
    def __init__(self, master, sub, session, col, row):
        self.sub = sub
        self.session = session
        self.col, self.row = col, row
        bg = sub.graph.value(sub.uri, L9.color, default='#000000')
        rgb = webcolors.hex_to_rgb(bg)
        hsv = colorsys.rgb_to_hsv(*[x/255 for x in rgb])
        darkBg = webcolors.rgb_to_hex(tuple([x * 255 for x in colorsys.hsv_to_rgb(
            hsv[0], hsv[1], .3)]))
        Frame.__init__(self, master, bd=1, relief='raised', bg=bg)
        self.name = sub.name
        self.slider_var = DoubleVar()
        self.pauseTrace = False
        self.scale = SubScale(self, variable=self.slider_var, width=20)

        self.namelabel = Label(self, font="Arial 7", bg=darkBg,
            fg='white', pady=0)
        self.sub.graph.addHandler(self.updateName)

        self.namelabel.pack(side=TOP)
        levellabel = Label(self, textvariable=self.slider_var, font="Arial 7",
            bg='black', fg='white', pady=0)
        levellabel.pack(side=TOP)
        self.scale.pack(side=BOTTOM, expand=1, fill=BOTH)

        for w in [self, self.namelabel, levellabel]:
            dragSourceRegister(w, 'copy', 'text/uri-list', sub.uri)

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

        sub.graph.addHandler(self.updateLevelFromGraph)

        # initial position
        # stil need? dispatcher.send("send_to_hw", sub=sub.uri, hwCol=col + 1)

    def cleanup(self):
        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):
        self.scale.draw_indicator_colors()

        if self.pauseTrace:
            return
        self.updateGraphWithLevel(self.sub.uri, self.slider_var.get())

        # needs fixing: plan is to use dispatcher or a method call to tell a hardware-mapping object who changed, and then it can make io if that's a current hw slider
        dispatcher.send("send_to_hw", sub=self.sub.uri, hwCol=self.col + 1,
                        boxRow=self.row)

    def updateGraphWithLevel(self, uri, level):
        """in our per-session graph, we maintain SubSetting objects like this:

           ?session :subSetting [a :SubSetting; :sub ?s; :level ?l]
        """
        # move to syncedgraph patchMapping

        self.sub.graph.patchMapping(context=self.session,
                                    subject=self.session,
                                    predicate=L9['subSetting'],
                                    nodeClass=L9['SubSetting'],
                                    keyPred=L9['sub'], newKey=uri,
                                    valuePred=L9['level'], newValue=Literal(level))

    def updateLevelFromGraph(self):
        """read rdf level, write it to subbox.slider_var"""
        # move this to syncedgraph readMapping
        graph = self.sub.graph

        for setting in graph.objects(self.session, L9['subSetting']):
            if graph.value(setting, L9['sub']) == self.sub.uri:
                self.pauseTrace = True # don't bounce this update back to server
                try:
                    self.slider_var.set(graph.value(setting, L9['level']))
                finally:
                    self.pauseTrace = False

    def updateName(self):
        def shortUri(u):
            return '.../' + u.split('/')[-1]
        self.namelabel.config(text=self.sub.graph.label(self.sub.uri) or shortUri(self.sub.uri))

class KeyboardComposer(Frame, SubClient):
    def __init__(self, root, graph, session,
                 hw_sliders=True):
        Frame.__init__(self, root, bg='black')
        SubClient.__init__(self)
        self.graph = graph
        self.session = session
        self.submasters = Submasters(graph)
        self.subbox = {} # sub uri : SubmasterBox
        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.send_levels_loop()
        self.graph.addHandler(self.rowFromGraph)

    def make_buttons(self):
        self.buttonframe = Frame(self, bg='black')
        self.buttonframe.pack(side=BOTTOM)

        self.sliders_status_var = IntVar()
        self.sliders_status_var.set(self.use_hw_sliders)
        self.sliders_checkbutton = Checkbutton(self.buttonframe,
            text="Sliders", variable=self.sliders_status_var,
            command=lambda: self.toggle_slider_connectedness(),
            bg='black', fg='white')
        self.sliders_checkbutton.pack(side=LEFT)

        self.alltozerobutton = Button(self.buttonframe, text="All to Zero",
            command=self.alltozero, bg='black', fg='white')
        self.alltozerobutton.pack(side='left')

        self.save_stage_button = Button(self.buttonframe, text="Save",
            command=lambda: self.save_current_stage(self.sub_name.get()),
            bg='black', fg='white')
        self.save_stage_button.pack(side=LEFT)
        self.sub_name = Entry(self.buttonframe, bg='black', fg='white')
        self.sub_name.pack(side=LEFT)

    def redraw_sliders(self):
        self.graph.addHandler(self.draw_sliders)
        if len(self.rows):
            self.change_row(self.current_row)
            self.rows[self.current_row].focus()

        self.stop_frequent_update_time = 0

    def draw_sliders(self):
        for r in self.rows:
            r.destroy()
        self.rows = []
        for b in self.subbox.values():
            b.cleanup()
        self.subbox.clear()
        self.slider_table.clear()

        self.tk_focusFollowsMouse()

        self.submasters.findSubs() # trigger graph load, but we read
                                   # from get_all_subs, below
        
        rowcount = -1
        col = 0
        last_group = None

        # there are unlikely to be any subs at startup because we
        # probably haven't been called back with the graph data yet

        withgroups = sorted((self.graph.value(sub.uri, L9['group']),
                             self.graph.value(sub.uri, L9['order']),
                             sub)
            for sub in self.submasters.get_all_subs())
        log.info("withgroups %s", withgroups)

        for group, order, sub in withgroups:
            group = self.graph.value(sub.uri, L9['group'])

            if col == 0 or group != last_group:
                row = self.make_row(group)
                rowcount += 1
                col = 0

            subbox = SubmasterBox(row, sub, self.session, col, rowcount)
            subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)
            self.subbox[sub.uri] = self.slider_table[(rowcount, col)] = subbox

            self.setup_key_nudgers(subbox.scale)

            col = (col + 1) % 8
            last_group = group

    def toggle_slider_connectedness(self):
        self.use_hw_sliders = not self.use_hw_sliders
        if self.use_hw_sliders:
            self.sliders.reopen()
        else:
            self.sliders.close()
        self.change_row(self.current_row)
        self.rows[self.current_row].focus()

    def connect_to_hw(self, hw_sliders):
        if hw_sliders:
            try:
                self.sliders = Sliders(self)
            except IOError:
                log.info("no hardware sliders")
                self.sliders = DummySliders()
                self.use_hw_sliders = False
            dispatcher.connect(self.send_to_hw, 'send_to_hw')
        else:
            self.sliders = DummySliders()

    def make_key_hints(self):
        keyhintrow = Frame(self)

        col = 0
        for upkey, downkey in zip(nudge_keys['up'],
                                  nudge_keys['down']):
            # what a hack!
            downkey = downkey.replace('semicolon', ';')
            upkey, downkey = (upkey.upper(), downkey.upper())

            # another what a hack!
            keylabel = Label(keyhintrow, text='%s\n%s' % (upkey, downkey),
                width=1, font=('Arial', 10), bg='red', fg='white', anchor='c')
            keylabel.pack(side=LEFT, expand=1, fill=X)
            col += 1

        keyhintrow.pack(fill=X, expand=0)
        self.keyhints = keyhintrow

    def setup_key_nudgers(self, tkobject):
        for d, keys in nudge_keys.items():
            for key in keys:
                # lowercase makes full=0
                keysym = "<KeyPress-%s>" % key
                tkobject.bind(keysym, \
                    lambda evt, num=keys.index(key), d=d: \
                        self.got_nudger(num, d))

                # uppercase makes full=1
                keysym = "<KeyPress-%s>" % key.upper()
                keysym = keysym.replace('SEMICOLON', 'colon')
                tkobject.bind(keysym, \
                    lambda evt, num=keys.index(key), d=d: \
                        self.got_nudger(num, d, full=1))

        # Row changing:
        # Page dn, C-n, and ] do down
        # Page up, C-p, and ' do up
        for key in '<Prior> <Next> <Control-n> <Control-p> ' \
                   '<Key-bracketright> <Key-apostrophe>'.split():
            tkobject.bind(key, self.change_row_cb)

    def change_row_cb(self, event):
        diff = 1
        if event.keysym in ('Prior', 'p', 'bracketright'):
            diff = -1
        self.change_row(self.current_row + diff)

    def rowFromGraph(self):
        self.change_row(int(self.graph.value(self.session, L9['currentRow'], default=0)), fromGraph=True)

    def change_row(self, row, fromGraph=False):
        old_row = self.current_row
        self.current_row = row
        self.current_row = max(0, self.current_row)
        self.current_row = min(len(self.rows) - 1, self.current_row)
        try:
            row = self.rows[self.current_row]
        except IndexError:
            # if we're mid-load, this row might still appear soon. If
            # we changed interactively, the user is out of bounds and
            # needs to be brought back in
            if fromGraph:
                return
            raise

        self.unhighlight_row(old_row)
        self.highlight_row(self.current_row)
        self.keyhints.pack_configure(before=row)

        if not fromGraph:
            self.graph.patchObject(self.session, self.session, L9['currentRow'],
                                   Literal(self.current_row))

        for col in range(1, 9):
            try:
                subbox = self.slider_table[(self.current_row, col - 1)]
                self.sliders.valueOut("button-upper%d" % col, True)
            except KeyError:
                # unfilled bottom row has holes (plus rows with incomplete
                # groups
                self.sliders.valueOut("button-upper%d" % col, False)
                self.sliders.valueOut("slider%d" % col, 0)
                continue
            self.send_to_hw(sub=subbox.sub.uri, hwCol=col,
                            boxRow=self.current_row)

    def got_nudger(self, number, direction, full=0):
        try:
            subbox = self.slider_table[(self.current_row, number)]
        except KeyError:
            return

        if direction == 'up':
            if full:
                subbox.scale.fade(1)
            else:
                subbox.scale.increase()
        else:
            if full:
                subbox.scale.fade(0)
            else:
                subbox.scale.decrease()

    def hw_slider_moved(self, col, value):
        value = int(value * 100) / 100
        try:
            subbox = self.slider_table[(self.current_row, col)]
        except KeyError:
            return # no slider assigned at that column

        if hasattr(self, 'pendingHwSet'):
            import twisted.internet.error
            try:
                self.pendingHwSet.cancel()
            except twisted.internet.error.AlreadyCalled:
                pass
        self.pendingHwSet = reactor.callLater(.01, subbox.slider_var.set, value)

    def send_to_hw(self, sub, hwCol, boxRow):
        if isinstance(self.sliders, DummySliders):
            return

        assert isinstance(sub, URIRef), repr(subUri)

        if boxRow != self.current_row:
            return
        
        try:
            level = self.get_levels()[sub]
        except KeyError:
            log.warn("%r not in %r", sub, self.get_levels())
            raise
        v = round(127 * level)
        chan = "slider%s" % hwCol

        # workaround for some rounding issue, where we receive one
        # value and then decide to send back a value that's one step
        # lower.  -5 is a fallback for having no last value.  hopefully
        # we won't really see it
        if abs(v - self.sliders.lastValue.get(chan, -5)) <= 1:
            return
        self.sliders.valueOut(chan, v)

    def make_row(self, group):
        """group is a URI or None"""
        row = Frame(self, bd=2, bg='black')
        row.subGroup = group
        def onDrop(ev):
            self.change_group(sub=URIRef(ev.data), row=row)
            return "link"
        
        dropTargetRegister(row, onDrop=onDrop, typeList=['*'],
                           hoverStyle=dict(background="#555500"))
        
        row.pack(expand=1, fill=BOTH)
        self.setup_key_nudgers(row)
        self.rows.append(row)
        return row

    def change_group(self, sub, row):
        """update this sub's group, and maybe other sub groups as needed, so
        this sub displays in this row"""
        group = row.subGroup
        self.graph.patchObject(
            context=self.session,
            subject=sub, predicate=L9['group'], newObject=group)

    def subs_in_row(self, row):
        """uris of the submasters displayed in this row. untested"""
        rowNum = self.rows.index(row) + 1
        ret = set()
        for coords, subbox in self.slider_table.items():
            if coords[0] == rowNum:
                ret.add(subbox.sub.uri)
        return ret
            
    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_levels_as_sub(self, graph=None):
        """this has to depend on the graph to get called back enough"""
        if graph is None:
            graph = self.graph
        # but it was using all synced values accidentally
        for setting in graph.objects(self.session, L9['subSetting']):
            level = graph.value(setting, L9['level'])
            if level != 0:
                sub = graph.value(setting, L9['sub'])
                for ll in graph.objects(sub, L9['lightLevel']):
                    graph.value(ll, L9['channel'])
                    graph.value(ll, L9['level'])

        # this is the older code, which uses some local objects
        # that are (supposedly) synced to the graph. It's a waste,
        # since I think the previous graph code just fetched all this
        # same data
        scaledsubs = [self.submasters.get_sub_by_uri(sub) * level
            for sub, level in self.get_levels().items() if level > 0.0]
        maxes = sub_maxes(*scaledsubs)
        return maxes

    def save_current_stage(self, subname):
        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)

    def alltozero(self):
        for uri, subbox in self.subbox.items():
            if subbox.scale.scale_var.get() != 0:
                subbox.scale.fade(value=0.0, length=0)

# move to web lib
def postArgGetter(request):
    """return a function that takes arg names and returns string
    values. Supports args encoded in the url or in postdata. No
    support for repeated args."""
    # this is something nevow normally does for me
    request.content.seek(0)
    fields = cgi.FieldStorage(request.content, request.received_headers,
                              environ={'REQUEST_METHOD': 'POST'})
    def getArg(n):
        try:
            return request.args[n][0]
        except KeyError:
            return fields[n].value
    return getArg


class LevelServerHttp(resource.Resource):
    isLeaf = True
    def __init__(self,name_to_subbox):
        self.name_to_subbox = name_to_subbox

    def render_POST(self, request):
        arg = postArgGetter(request)

        if request.path == '/fadesub':
            # fadesub?subname=scoop&level=0&secs=.2
            self.name_to_subbox[arg('subname')].scale.fade(
                float(arg('level')),
                float(arg('secs')))
            return "set %s to %s" % (arg('subname'), arg('level'))
        else:
            raise NotImplementedError(repr(request))

class Sliders(BCF2000):
    def __init__(self, kc):
        devices = ['/dev/snd/midiC1D0', '/dev/snd/midiC2D0', '/dev/snd/midiC3D0']
        for dev in devices:
            try:
                BCF2000.__init__(self, dev=dev)
            except IOError, e:
                if dev is devices[-1]:
                    raise
            else:
                break

        self.kc = kc
    def valueIn(self, name, value):
        kc = self.kc
        if name.startswith("slider"):
            kc.hw_slider_moved(int(name[6:]) - 1, value / 127)
        elif name.startswith("button-upper"):
            kc.change_row(kc.current_row)
        elif name.startswith("button-lower"):
            col = int(name[12:]) - 1
            self.valueOut(name, 0)
            try:
                tkslider = kc.slider_table[(kc.current_row, col)]
            except KeyError:
                return

            slider_var = tkslider.slider_var
            if slider_var.get() == 1:
                slider_var.set(0)
            else:
                slider_var.set(1)
        elif name.startswith("button-corner"):
            button_num = int(name[13:]) - 1
            if button_num == 1:
                diff = -1
            elif button_num == 3:
                diff = 1
            else:
                return

            kc.change_row(kc.current_row + diff)
            self.valueOut(name, 0)

def launch(opts, root, graph, session):
    tl = toplevelat("Keyboard Composer - %s" % opts.session,
                    existingtoplevel=root, graph=graph, session=session)

    kc = KeyboardComposer(tl, graph, session,
                          hw_sliders=not opts.no_sliders)
    kc.pack(fill=BOTH, expand=1)

    for helpline in ["Bindings: B3 mute"]:
        tk.Label(root,text=helpline, font="Helvetica -12 italic",
                 anchor='w').pack(side='top',fill='x')
            
if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option('--no-sliders', action='store_true',
                      help="don't attach to hardware sliders")
    clientsession.add_option(parser)
    parser.add_option('-v', action='store_true', help="log info level")
    opts, args = parser.parse_args()

    log.setLevel(logging.INFO if opts.v else logging.WARN)

    graph = SyncedGraph("keyboardcomposer")

    # i think this also needs delayed start (like subcomposer has), to have a valid graph
    # before setting any stuff from the ui
    
    root = Tk()
    initTkdnd(root.tk, 'tkdnd/trunk/')

    session = clientsession.getUri('keyboardcomposer', opts)

    graph.initiallySynced.addCallback(
        lambda _: launch(opts, root, graph, session))

    if 0: # needs fixing, or maybe it's obsolete because other progs can just patch the rdf graph
        import twisted.internet
        try:
            reactor.listenTCP(networking.keyboardComposer.port,
                              server.Site(LevelServerHttp(kc.name_to_subbox)))
        except twisted.internet.error.CannotListenError, e:
            log.warn("Can't (and won't!) start level server:")
            log.warn(e)

    root.protocol('WM_DELETE_WINDOW', reactor.stop)

    tksupport.install(root,ms=10)


#    prof.watchPoint("/usr/lib/python2.4/site-packages/rdflib-2.3.3-py2.4-linux-i686.egg/rdflib/Graph.py", 615)

    prof.run(reactor.run, profile=False)