#!bin/python

from __future__ import division, nested_scopes

from run_local import log

from optparse import OptionParser

import webcolors, colorsys

from louie import dispatcher

from twisted.internet import reactor, tksupport

import Tix as tk

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.namespaces import L9

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.rdfdb import clientsession

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

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

        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'})

        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'

    """

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

        self.name = sub.name

        self.pauseTrace = False

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

            fg='white', pady=0)

        self.sub.graph.addHandler(self.updateName)

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

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

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

    def __init__(self, root, graph, session,

                 hw_sliders=True):

        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.sliders_status_var.set(self.use_hw_sliders)

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

            command=lambda: self.toggle_slider_connectedness(),

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

            command=self.alltozero, bg='black', fg='white')

        self.alltozerobutton.pack(side='left')

            command=lambda: self.save_current_stage(self.sub_name.get()),

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

    def redraw_sliders(self):

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

        # 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']),

             self.graph.label(sub), # todo: split numbers into ints so they sort right

             sub.uri, 

             sub)

            for sub in self.submasters.get_all_subs())

        log.info("withgroups %s", 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)

            try:

                self.sliders = Sliders(self)

                log.info("connected to sliders")

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

        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!

                width=1, font=('Arial', 10), bg='red', fg='white', anchor='c')

            col += 1

        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

        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

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

        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)

                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/midiC3D0', '/dev/snd/midiC2D0', '/dev/snd/midiC1D0']

        for dev in devices:

            try:

                BCF2000.__init__(self, dev=dev)

                if dev is devices[-1]:

                    raise

            else:

                break

        self.kc = kc

        log.info('found sliders on %s', dev)

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

            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)

    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(networking.rdfdb.url, "keyboardcomposer")

    # i think this also needs delayed start (like subcomposer has), to have a valid graph

    # before setting any stuff from the ui

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