#!bin/python

from __future__ import division, nested_scopes
from optparse import OptionParser
import logging
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

logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger()

class _NoNewVal(object):
    pass

class Observable(object):
    """
    like knockout's observable. Hopefully this can be replaced by a
    better python one
    """
    def __init__(self, val):
        self.val = val
        self.subscribers = set()

    def __call__(self, newVal=_NoNewVal):
        if newVal is _NoNewVal:
            return self.val
        self.val = newVal
        for s in self.subscribers:
            s(newVal)

    def subscribe(self, cb, callNow=True):
        """cb is called with new values, and also right now with the
        current value unless you opt out"""
        self.subscribers.add(cb)
        if callNow:
            cb(self.val)

class Local(object):
    """placeholder for the local uri that EditChoice does not
    manage. Set resourceObservable to Local to indicate that you're
    unlinked"""

class EditChoice(tk.Frame):
    """
    Observable <-> linker UI

    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, graph, resourceObservable):
        """
        getResource is called to get the URI of the currently
        """
        self.frame = tk.Frame(parent, relief='raised',border=8)
        self.frame.pack(side='top')
        tk.Label(self.frame, text="Editing:").pack(side='left')
        self.currentSubFrame = tk.Frame(self.frame)
        self.currentSubFrame.pack(side='left')

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

        self.resourceObservable = resourceObservable
        resourceObservable.subscribe(self.uriChanged)

        dragSourceRegister(self.subIcon, 'copy', 'text/uri-list',
                           self.resourceObservable)
        def onEv(ev):
            self.resourceObservable(ev.data)
            return "link"
        self.onEv = onEv

        # it would be nice if I didn't receive my own drags here
        dropTargetRegister(self.subIcon, typeList=["*"], onDrop=onEv,
                           hoverStyle=dict(background="#555500", bd=3,
                                           relief='groove'))

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


    def uriChanged(self, newUri):
        print "chg", newUri
        # i guess i show the label and icon for this
        if newUri is Local:
            self.subIcon.config(text="(local)")
        else:
            self.subIcon.config(text=newUri)

    def switchToLocalSub(self):
        self.resourceObservable(Local)


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>

    Contains an EditChoice widget

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

        currentUri = Observable(Local)

        def pc(val):
            print "change viewed sub to", val
        currentUri.subscribe(pc)

        EditChoice(self, self.graph, currentUri).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)