#!bin/python

from __future__ import division, nested_scopes
from optparse import OptionParser
import Tkinter as tk
import louie as dispatcher
from twisted.internet import reactor, tksupport, task
from rdflib import URIRef

import run_local
from light9.dmxchanedit import Levelbox
from light9 import dmxclient, Patch, Submaster, showconfig, prof
from light9.uihelpers import toplevelat
from light9.rdfdb.syncedgraph import SyncedGraph
from light9.rdfdb import clientsession
from light9.tkdnd import initTkdnd, dragSourceRegister, dropTargetRegister

class EditChoice(tk.Frame):
    """
    widget for tying some UI to a shared resource for editing, or
    unlinking it (which means associating it with a local resource
    that's not named or shared). This object does not own the choice
    of resource; the caller does.
    """
    def __init__(self, parent, getResource, onSetResource, onSetLocal):
        want to pass an observable uri value and an observable isLocal for 2way sync
        """
        getResource is called to get the URI of the currently 
        """
        self.frame = tk.Frame(parent)
        self.subSelection.pack(side='top')
        tk.Label(self.subSelection, text="Editing:").pack(side='left')
        self.currentSubFrame = tk.Frame(self.subSelection)
        self.currentSubFrame.pack(side='left')

        self.subIcon = tk.Label(self.currentSubFrame, text="sub1",
                                borderwidth=2,
                                relief='raised', padx=10, pady=10)
        self.subIcon.pack()

        dragSourceRegister(self.subIcon, 'copy', 'text/uri-list',
                           lambda: self.currentSub.uri)
        def onEv(*args):
            print "ev", args
            return "link"
        self.onEv = onEv
          
        dropTargetRegister(self, onDrop=onEv,
                           hoverStyle=dict(background="#555500", bd=3, relief='groove'))

        tk.Label(self.currentSubFrame, text="local data (drag sub here)").pack()
        tk.Button(text="unlink", command=self.switchToLocalSub)
    

class Subcomposer(tk.Frame):
    """
    <session> l9:currentSub ?sub is the URI of the sub we're tied to for displaying and
    editing. If we don't have a currentSub, then we're actually
    editing a session-local sub called <session> l9:currentSub <sessionLocalSub>

    UI actions:
    - drag a sub uri on here to make it the one we're editing

    - button to clear the currentSub (putting it back to
      sessionLocalSub, and also resetting sessionLocalSub to be empty
      again)

    - drag the sub uri off of here to send it to another receiver, but
      session local sub is not easily addressable elsewhere

    - make a new sub: transfers the current data (from a shared sub or
      from the local one) to the new sub. If you're on a local sub,
      the new sub is named automatically, ideally something brief,
      pretty distinct, readable, and based on the lights that are
      on. If you're on a named sub, the new one starts with a
      'namedsub 2' style name. The uri can also be with a '2' suffix,
      although maybe that will be stupid. If you change the name
      before anyone knows about this uri, we could update the current
      sub's uri to a slug of the new label.
    
    - rename this sub: not available if you're on a local sub. Sets
      the label of a named sub. Might update the uri of the named sub
      if it's new enough that no one else would have that uri. Not
      sure where we measure that 'new enough' value. Maybe track if
      the sub has 'never been dragged out of this subcomposer
      session'? But subs will also show up in other viewers and
      finders.

    """
    def __init__(self, master, graph, session):
        tk.Frame.__init__(self, master, bg='black')
        self.graph = graph
        self.session = session
        self.currentSub = Submaster.PersistentSubmaster(graph, URIRef('http://hello'))

        self.levelbox = Levelbox(self, graph)
        self.levelbox.pack(side='top')

        EditChoice(self).frame.pack(side='top')
        
        def alltozero():
            for lev in self.levelbox.levels:
                lev.setlevel(0)

        tk.Button(self, text="all to zero", command=alltozero).pack(side='top')

        dispatcher.connect(self.sendupdate, "levelchanged")

    def switchToLocalSub(self, *args):
        """
        stop editing a shared sub and go back to our local sub
        """

    def fill_both_boxes(self, subname):
        for box in [self.savebox, self.loadbox]:
            box.set(subname)

    def savenewsub(self, subname):
        leveldict={}
        for i,lev in zip(range(len(self.levels)),self.levels):
            if lev!=0:
                leveldict[Patch.get_channel_name(i+1)]=lev

        s=Submaster.Submaster(subname,leveldict=leveldict)
        s.save()

    # this is going to be more like 'tie to sub' and 'untied'
    def loadsub(self, subname):
        """puts a sub into the levels, replacing old level values"""
        s=Submaster.Submasters(showconfig.getGraph()).get_sub_by_name(subname)
        self.set_levels(s.get_dmx_list())
        dispatcher.send("levelchanged")

    def toDmxLevels(self):
        # the dmx levels we edit and output, range is 0..1 (dmx chan 1 is
        # the 0 element)
        out = {}
        for lev in self.levelbox.levels:
            out[lev.channelnum] = lev.currentlevel
        if not out:
            return []
        
        return [out.get(i, 0) for i in range(max(out.keys()) + 1)]
     
    def sendupdate(self):
        dmxclient.outputlevels(self.toDmxLevels(), twisted=True)


class EntryCommand(tk.Frame):
    def __init__(self, master, verb="Save", cmd=None):
        tk.Frame.__init__(self, master, bd=2, relief='raised')
        tk.Label(self, text="Sub name:").pack(side='left')
        self.cmd = cmd
        self.entry = tk.Entry(self)
        self.entry.pack(side='left', expand=True, fill='x')
        
        self.entry.bind("<Return>", self.action)
        tk.Button(self, text=verb, command=self.action).pack(side='left')

    def action(self, *args):
        subname = self.entry.get()
        self.cmd(subname)
        print "sub", self.cmd, subname

    def set(self, text):
        self.entry.delete(0, 'end')
        self.entry.insert(0, text)


#############################

if __name__ == "__main__":
    parser = OptionParser(usage="%prog [subname]")
    parser.add_option('--no-geometry', action='store_true',
                      help="don't save/restore window geometry")
    clientsession.add_option(parser)
    opts, args = parser.parse_args()

    root=tk.Tk()
    root.config(bg='black')
    root.tk_setPalette("#004633")

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

    graph = SyncedGraph("subcomposer")
    session = clientsession.getUri('subcomposer', opts)

    if not opts.no_geometry:
        toplevelat("subcomposer - %s" % opts.session, root, graph, session)

    sc = Subcomposer(root, graph, session)
    sc.pack()

    tk.Label(root,text="Bindings: B1 adjust level; B2 set full; B3 instant bump",
             font="Helvetica -12 italic",anchor='w').pack(side='top',fill='x')

    if len(args) == 1:
        root.config(bg='green') # trying to make these look distinctive
        sc.loadsub(args[0])
        sc.fill_both_boxes(args[0])

    task.LoopingCall(sc.sendupdate).start(1)

    root.protocol('WM_DELETE_WINDOW', reactor.stop)
    tksupport.install(root,ms=10)
    prof.run(reactor.run, profile=False)