#!/usr/bin/python

from __future__ import division, nested_scopes

import sys, time

from twisted.internet import reactor, tksupport

from twisted.web import xmlrpc, server

from Tix import *

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

from light9.uihelpers import toplevelat

nudge_keys = {

    'up' : list('qwertyuiop'),

    'down' : list('asdfghjkl')

}

nudge_keys['down'].append('semicolon')

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'

            self.current_sub_levels = current_sub_levels

        else:

            try:

                self.current_sub_levels = \

                    pickle.load(file('.keyboardcomposer.savedlevels'))

            except IOError:

                pass

        self.draw_ui()

        self.send_levels_loop()

    def draw_ui(self):

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

        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.current_row = 0

        self.make_key_hints()

        self.draw_sliders()

        self.highlight_row(self.current_row)

        self.rows[self.current_row].focus()

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

        self.buttonframe.pack(side=BOTTOM)

        self.refreshbutton = Button(self.buttonframe, text="Refresh", 

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

        self.refreshbutton.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)

        self.stop_frequent_update_time = 0

    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)

        sub.name = subname

        sub.temporary = 0

        sub.save()

    def save(self):

        pickle.dump(self.get_levels(), 

                    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 refresh(self):

        self.save()

        self.submasters = Submasters()

        self.current_sub_levels = \

            pickle.load(file('.keyboardcomposer.savedlevels'))

        for r in self.rows:

            r.destroy()

        self.keyhints.destroy()

        self.buttonframe.destroy()

        self.draw_ui()

class LevelServer(xmlrpc.XMLRPC):

    def __init__(self,name_to_subtk):

        self.name_to_subtk = name_to_subtk

    def xmlrpc_fadesub(self,subname,level,secs):

        """submaster will fade to level in secs"""

        try:

            self.name_to_subtk[subname].scale.fade(level,secs)

            ret='ok'

        except Exception,e:

            ret=str(e)

        return ret

if __name__ == "__main__":

    s = Submasters()

    root = Tk()

    tl = toplevelat("Keyboard Composer", existingtoplevel=root)

    kc = KeyboardComposer(tl, s)

    kc.pack(fill=BOTH, expand=1)

    ls = LevelServer(kc.name_to_subtk)

    reactor.listenTCP(networking.kcPort(), server.Site(ls))

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

    reactor.addSystemEventTrigger('after', 'shutdown', kc.save)

    tksupport.install(root,ms=10)

    reactor.run()