#!bin/python

from __future__ import division, nested_scopes
import cgi, os, sys, time, subprocess, logging
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 Tix import *
import Tix as tk
import pickle

import run_local
from light9.Fadable import Fadable
from light9.Submaster import Submasters, sub_maxes
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
from light9.rdfdb.syncedgraph import SyncedGraph

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 SubmasterTk(Frame):
    def __init__(self, master, sub, current_level):
        self.sub = sub
        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.slider_var.set(current_level)
        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)
        bindkeys(self, "<Control-Key-l>", self.launch_subcomposer)

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

    def updateName(self):
        self.namelabel.config(text=self.sub.graph.label(self.sub.uri))

    def launch_subcomposer(self, *args):
        subprocess.Popen(["bin/subcomposer", "--no-geometry", self.name])

class KeyboardComposer(Frame, SubClient):
    def __init__(self, root, graph, current_sub_levels=None,
                 hw_sliders=True):
        Frame.__init__(self, root, bg='black')
        SubClient.__init__(self)
        self.graph = graph
        self.submasters = Submasters(graph)
        self.name_to_subtk = {}
        self.current_sub_levels = {}
        self.current_row = 0
        if current_sub_levels is not None:
            self.current_sub_levels = current_sub_levels
        else:
            try:
                self.current_sub_levels, self.current_row = \
                    pickle.load(file('.keyboardcomposer.savedlevels'))
            except IOError:
                pass

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

    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.slider_vars = {} # this holds subname:sub Tk vars
        self.slider_table = {} # this holds coords:sub Tk vars
        self.name_to_subtk.clear() # subname : SubmasterTk instance

        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 onNewSub(self, sub):
        log.info("new %s", sub)
        self.graph.addHandler(self.draw_sliders)

    def onLostSub(self, subUri):
        log.info("lost %s", subUri)
        self.graph.addHandler(self.draw_sliders)
    
    def draw_sliders(self):


        if hasattr(self, 'rows'):
            for r in self.rows:
                r.destroy()
        self.rows = [] # this holds Tk Frames for each row

        
        self.tk_focusFollowsMouse()

        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
        
        #read get_all_subs then watch 'new submaster' 'lost submaster' signals
        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())
        dispatcher.connect(self.onNewSub, "new submaster")
        dispatcher.connect(self.onLostSub, "lost submaster")
        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: # make new row
                row = self.make_row()
                rowcount += 1
                col = 0
            current_level = self.current_sub_levels.get(sub.name, 0)
            subtk = self.draw_sub_slider(row, col, sub, current_level)
            self.slider_table[(rowcount, col)] = subtk
            self.name_to_subtk[sub.name] = subtk

            def slider_changed(x, y, z, subtk=subtk,
                               col=col, sub=sub, rowcount=rowcount):
                subtk.scale.draw_indicator_colors()
                self.send_levels()
                if rowcount == self.current_row:
                    self.send_to_hw(sub.name, col + 1)

            subtk.slider_var.trace('w', slider_changed)

            # initial position
            self.send_to_hw(sub.name, col + 1)
            col = (col + 1) % 8
            last_group = group

    def draw_sub_slider(self, row, col, sub, current_level):
        subtk = SubmasterTk(row, sub, current_level)
        subtk.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)
        self.setup_key_nudgers(subtk.scale)

        self.slider_vars[sub.name] = subtk.slider_var
        return subtk

    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
        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 change_row(self, row):
        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)
        self.unhighlight_row(old_row)
        self.highlight_row(self.current_row)
        row = self.rows[self.current_row]
        self.keyhints.pack_configure(before=row)

        for col in range(1, 9):
            try:
                subtk = 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(subtk.name, col)
            
    def got_nudger(self, number, direction, full=0):
        try:
            subtk = self.slider_table[(self.current_row, number)]
        except KeyError:
            return

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

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

    def send_to_hw(self, subName, hwNum):
        if isinstance(self.sliders, DummySliders):
            return
            
        v = round(127 * self.slider_vars[subName].get())
        chan = "slider%s" % hwNum
        
        # 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):
        row = Frame(self, bd=2, bg='black')
        row.pack(expand=1, fill=BOTH)
        self.setup_key_nudgers(row)
        self.rows.append(row)
        return row

    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([(name, slidervar.get()) 
            for name, slidervar in self.slider_vars.items()])

    def get_levels_as_sub(self):
        scaledsubs = [self.submasters.get_sub_by_name(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)
        sub = self.get_levels_as_sub()
        sub.name = subname
        sub.temporary = 0
        sub.save()

    def save(self):
        pickle.dump((self.get_levels(), self.current_row),
                    file('.keyboardcomposer.savedlevels', 'w'))
    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 name, subtk in self.name_to_subtk.items():
            if subtk.scale.scale_var.get() != 0:
                subtk.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_subtk):
        self.name_to_subtk = name_to_subtk

    def render_POST(self, request):
        arg = postArgGetter(request)
        
        if request.path == '/fadesub':
            # fadesub?subname=scoop&level=0&secs=.2
            self.name_to_subtk[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)

if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option('--nonpersistent', action="store_true",
                      help="don't load or save levels")
    parser.add_option('--no-sliders', action='store_true',
                      help="don't attach to hardware sliders")
    parser.add_option('-v', action='store_true', help="log info level")
    opts, args = parser.parse_args()

    logging.basicConfig(level=logging.INFO if opts.v else logging.WARN)
    log = logging.getLogger('keyboardcomposer')

    graph = SyncedGraph("keyboardcomposer")

    root = Tk()
    initTkdnd(root.tk, 'tkdnd/trunk/')
    
    tl = toplevelat("Keyboard Composer", existingtoplevel=root)

    startLevels = None
    if opts.nonpersistent:
        startLevels = {}
    kc = KeyboardComposer(tl, graph, startLevels,
                          hw_sliders=not opts.no_sliders)
    kc.pack(fill=BOTH, expand=1)

    for helpline in ["Bindings: B3 mute; C-l edit levels in subcomposer"]:
        tk.Label(root,text=helpline, font="Helvetica -12 italic",
                 anchor='w').pack(side='top',fill='x')

    import twisted.internet
    try:
        reactor.listenTCP(networking.keyboardComposer.port,
                          server.Site(LevelServerHttp(kc.name_to_subtk)))
    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)
    if not opts.nonpersistent:
        reactor.addSystemEventTrigger('after', 'shutdown', kc.save)
    
    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)