#!bin/python

from run_local import log

from optparse import OptionParser

from typing import Any, Dict, Tuple, List

import cgi, time, logging

import imp

import tkinter.tix as tk

from louie import dispatcher

from rdflib import URIRef, Literal

from twisted.internet import reactor, tksupport

from twisted.web import resource

import webcolors, colorsys

from bcf2000 import BCF2000

from light9 import clientsession

from light9 import showconfig, networking, prof

from light9.Fadable import Fadable

from light9.effect.sequencer import CodeWatcher

from light9.effect.settings import DeviceSettings

from light9.effect.simple_outputs import SimpleOutputs

from light9.namespaces import L9, RDF, RDFS

from light9.subclient import SubClient

from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

from light9.uihelpers import toplevelat

from rdfdb.patch import Patch

from rdfdb.syncedgraph import SyncedGraph

import light9.effect.effecteval

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.001,

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

    This leaks handlers or DoubleVars or something and tries to just

    skip the obsolete ones. It'll get slower and bigger over

    time. todo: make aa web version.

    """

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

        darkBg = webcolors.rgb_to_hex(

            tuple([

                int(x * 255) for x in colorsys.hsv_to_rgb(hsv[0], hsv[1], .2)

            ]))

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

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

        self._val = 0.0

        self.slider_var = tk.DoubleVar()

        self.pauseTrace = False

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

        self.dead = False

        self.namelabel = tk.Label(self,

                                  font="Arial 9",

                                  bg=darkBg,

                                  fg='white',

                                  pady=0)

        self.graph.addHandler(self.updateName)

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

        self.levellabel = tk.Label(self,

                                   textvariable=self.slider_var,

                                   font="Arial 6",

                                   bg='black',

                                   fg='white',

                                   pady=0)

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

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

        for w in [self, self.namelabel, self.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)

        # initial position

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

    def getVal(self) -> float:

        return self._val

    def setVal(self, newVal: float) -> None:

        if self.dead:

            return

        try:

            self.scale.set(newVal)

            self.levellabel.config(text=str(newVal))

        except Exception:

            log.warning("disabling handlers on broken subbox")

            self.dead = True

    def cleanup(self):

        self.slider_var.trace_vdelete('w', self._slider_var_trace)

    def slider_changed(self, *args):

        self._val = self.scale.get()

        self.scale.draw_indicator_colors()

        if self.pauseTrace:

            return

        self.updateGraphWithLevel(self.sub, self.getVal())

        # 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,

                        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.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.graph

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

            if graph.value(setting, L9['sub']) == self.sub:

                self.pauseTrace = True  # don't bounce this update back to server

                try:

                    self.setVal(graph.value(setting, L9['level']).toPython())

                finally:

                    self.pauseTrace = False

    def updateName(self):

        if self.scale is None:

            return

        def shortUri(u):

            return '.../' + u.split('/')[-1]

        try:

            self.namelabel.config(

                text=self.graph.label(self.sub) or shortUri(self.sub))

        except Exception:

            log.warn("disabling handlers on broken subbox")

            self.scale = None

class KeyboardComposer(tk.Frame, SubClient):

    def __init__(self,

                 root: tk.Tk,

                 graph: SyncedGraph,

                 session: URIRef,

                 hw_sliders=True):

        tk.Frame.__init__(self, root, bg='black')

        SubClient.__init__(self)

        self.graph = graph

        self.session = session

        self.subbox: Dict[URIRef, SubmasterBox] = {}  # sub uri : SubmasterBox

        self.slider_table: Dict[Tuple[int, int], SubmasterBox] = {

        }  # coords : SubmasterBox

        self.rows: List[tk.Frame] = []  # 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.codeWatcher = CodeWatcher(

            onChange=lambda: self.graph.addHandler(self.redraw_sliders))

        self.send_levels_loop(delay=.05)

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

        self.sliders_checkbutton.pack(side=tk.LEFT)

        self.alltozerobutton = tk.Button(self.buttonframe,

                                         text="All to Zero",

                                         command=self.alltozero,

                                         bg='black',

                                         fg='white')

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

        self.save_stage_button = tk.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=tk.LEFT)

        self.sub_name = tk.Entry(self.buttonframe, bg='black', fg='white')

        self.sub_name.pack(side=tk.LEFT)

    def redraw_sliders(self) -> None:

        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 list(self.subbox.values()):

            b.cleanup()

        self.subbox.clear()

        self.slider_table.clear()

        self.tk_focusFollowsMouse()

        rowcount = -1

        col = 0

        last_group = None

        withgroups = []

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

            withgroups.append((self.graph.value(effect, L9['group']),

                               self.graph.value(effect, L9['order']),

                               self.graph.label(effect), effect))

        withgroups.sort()

        self.effectEval: Dict[URIRef, light9.effect.effecteval.EffectEval] = {}

        imp.reload(light9.effect.effecteval)

        simpleOutputs = SimpleOutputs(self.graph)

        for group, order, sortLabel, effect in withgroups:

            if col == 0 or group != last_group:

                row = self.make_row(group)

                rowcount += 1

                col = 0

            subbox = SubmasterBox(row, self.graph, effect, self.session, col,

                                  rowcount)

            subbox.place(relx=col / 8, rely=0, relwidth=1 / 8, relheight=1)

            self.subbox[effect] = self.slider_table[(rowcount, col)] = subbox

            self.setup_key_nudgers(subbox.scale)

            self.effectEval[effect] = light9.effect.effecteval.EffectEval(

                self.graph, effect, simpleOutputs)

            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)

                log.info("connected to 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 = tk.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 = tk.Label(keyhintrow,

                                text='%s\n%s' % (upkey, downkey),

                                width=1,

                                font=('Arial', 10),

                                bg='red',

                                fg='white',

                                anchor='c')

            keylabel.pack(side=tk.LEFT, expand=1, fill=tk.X)

            col += 1

        keyhintrow.pack(fill=tk.X, expand=0)

        self.keyhints = keyhintrow

    def setup_key_nudgers(self, tkobject):

        for d, keys in list(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: int, fromGraph=False) -> None:

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

    def send_to_hw(self, sub, hwCol, boxRow):

        if isinstance(self.sliders, DummySliders):

            return

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

        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 = tk.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=tk.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 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.getVal()) for uri, box in list(self.subbox.items())

        ])

    def get_output_settings(self, _graph=None):

        _graph = _graph or self.graph

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

                out, report = self.effectEval[effect].outputFromEffect(

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

                    songTime=now,

                    # should be counting from when you bumped up from 0

                    noteTime=now)

                outputSettings.append(out)

        return DeviceSettings.fromList(_graph, outputSettings)

    def save_current_stage(self, subname):

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

        with self.graph.currentState() as g:

            ds = self.get_output_settings(_graph=g)

        effect = L9['effect/%s' % subname]

        ctx = URIRef(showconfig.showUri() + '/effect/' + subname)

        stmts = ds.statements(effect, ctx, effect + '/', set())

        stmts.extend([

            (effect, RDF.type, L9['Effect'], ctx),

            (effect, RDFS.label, Literal(subname), ctx),

            (effect, L9['publishAttr'], L9['strength'], ctx),

        ])

        self.graph.suggestPrefixes(ctx, {'eff': effect + '/'})

        self.graph.patch(Patch(addQuads=stmts, delQuads=[]))

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

    def alltozero(self):

        for uri, subbox in list(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/midiC3D0', '/dev/snd/midiC2D0', '/dev/snd/midiC1D0'

        ]

        for dev in devices:

            try:

                BCF2000.__init__(self, dev=dev)

            except IOError:

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

            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

            if tkslider.getVal() == 1.0:

                tkslider.setVal(0.0)

            else:

                tkslider.setVal(1.0)

        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: Any, root: tk.Tk, graph: SyncedGraph, session: URIRef):

    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=tk.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()

    logging.getLogger('colormath').setLevel(logging.INFO)

    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

    root = tk.Tk()

    initTkdnd(root.tk, 'tkdnd/trunk/')

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

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

                                                       session))

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

    tksupport.install(root, ms=20)

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