import random as random_mod

import math

import logging, colorsys

import light9.Submaster as Submaster

from .chase import chase as chase_logic

from . import showconfig

from tkinter.tix import *

from time import time, sleep

class Mass:

    def __init__(self):

        self.x = 0  # position

        self.xgoal = 0  # position goal

import os, logging, time

from rdflib import Graph, RDF

from rdflib import RDFS, Literal, BNode

from light9.namespaces import L9, XSD

from light9.TLUtility import dict_scale, dict_max

from light9 import showconfig

from light9.Patch import resolve_name, get_dmx_channel, get_channel_uri, reload_data

from louie import dispatcher

from .rdfdb.patch import Patch

log = logging.getLogger('submaster')

class Submaster(object):

    """mapping of channels to levels"""

    def __init__(self, name, levels):

        """this sub has a name just for debugging. It doesn't get persisted.

        See PersistentSubmaster.

        levels is a dict

        """

    def no_nonzero(self):

        return all(v == 0 for v in self.levels.values())

    def __mul__(self, scalar):

        return Submaster("%s*%s" % (self.name, scalar),

                         levels=dict_scale(self.levels, scalar))

    __rmul__ = __mul__

    def max(self, *othersubs):

        return sub_maxes(self, *othersubs)

    def __add__(self, other):

        return self.max(other)

        for k, v in list(leveldict.items()):

            if v == 0:

                continue

            try:

                dmxchan = get_dmx_channel(k) - 1

            except ValueError:

                raise

            if dmxchan >= len(levels):

                levels.extend([0] * (dmxchan - len(levels) + 1))

            levels[dmxchan] = max(v, levels[dmxchan])

        return levels

        for k in list(self.levels.keys()) + list(otherlevels.keys()):

            keys_set[k] = 1

        all_keys = list(keys_set.keys())

        xfaded_sub = Submaster("xfade", {})

        for k in all_keys:

                                             amount))

        return xfaded_sub

class PersistentSubmaster(Submaster):

    def __init__(self, graph, uri):

        if uri is None:

            raise TypeError("uri must be URIRef")

        self.graph, self.uri = graph, uri

        self.graph.addHandler(self.setName)

        self.graph.addHandler(self.setLevels)

    def _saveContext(self):

        """the context in which we should save all the lightLevel triples for

        this sub"""

        typeStmt = (self.uri, RDF.type, L9['Submaster'])

        with self.graph.currentState(tripleFilter=typeStmt) as current:

            try:

                          list(current.contextsForStatement(typeStmt)))

                ctx = current.contextsForStatement(typeStmt)[0]

            except IndexError:

                log.info("declaring %s to be a submaster" % self.uri)

                ctx = self.uri

                    (self.uri, RDF.type, L9['Submaster'], ctx),

                    ]))

        return ctx

    def editLevel(self, chan, newLevel):

        self.graph.patchMapping(self._saveContext(),

                                nodeClass=L9['ChannelSetting'],

                                valuePred=L9['level'],

                                newValue=Literal(newLevel))

    def clear(self):

        """set all levels to 0"""

        with self.graph.currentState() as g:

            quads.extend(current.quads((self.uri, None, None)))

            for s,p,o,c in quads:

                if p == L9['lightLevel']:

                    quads.extend(current.quads((o, None, None)))

        return quads

    def save(self):

        raise NotImplementedError("obsolete?")

        if self.temporary:

            log.info("not saving temporary sub named %s",self.name)

            return

    """Fades between two floats by an amount.  amount is a float between

    0 and 1.  If amount is 0, it will return the start value.  If it is 1,

    the end value will be returned."""

    level = start + (amount * (end - start))

    return level

def sub_maxes(*subs):

    nonzero_subs = [s for s in subs if not s.no_nonzero()]

    name = "max(%s)" % ", ".join([repr(s) for s in nonzero_subs])

    return Submaster(name,

                     levels=dict_max(*[sub.levels for sub in nonzero_subs]))

def combine_subdict(subdict, name=None, permanent=False):

    """A subdict is { Submaster objects : levels }.  We combine all

    submasters first by multiplying the submasters by their corresponding

    levels and then max()ing them together.  Returns a new Submaster

    object.  You can give it a better name than the computed one that it

    will get or make it permanent if you'd like it to be saved to disk.

        maxes.name = name

    if permanent:

        maxes.temporary = False

    return maxes

class Submasters(object):

    "Collection o' Submaster objects"

    def __init__(self, graph):

        self.submasters = {} # uri : Submaster

        self.graph = graph

        graph.addHandler(self.findSubs)

    def get_sub_by_uri(self, uri):

        return self.submasters[uri]

    def get_sub_by_name(self, name):

        return get_sub_by_name(name, self)

# a global instance of Submasters, created on demand

_submasters = None

def get_global_submasters(graph):

    """

    Get (and make on demand) the global instance of

    Submasters. Cached, but the cache is not correctly using the graph

    argument. The first graph you pass will stick in the cache.

    """

    global _submasters

    if _submasters is None:

        _submasters = Submasters(graph)

    return _submasters

def get_sub_by_name(name, submasters=None):

    """name is a channel or sub nama, submasters is a Submasters object.

    If you leave submasters empty, it will use the global instance of

    Submasters."""

    if not submasters:

        submasters = get_global_submasters()

"""Collected utility functions, many are taken from Drew's utils.py in

Cuisine CVS and Hiss's Utility.py."""

import sys

__author__ = "David McClosky <dmcc@bigasterisk.com>, " + \

             "Drew Perttula <drewp@bigasterisk.com>"

__cvsid__ = "$Id: TLUtility.py,v 1.1 2003/05/25 08:25:35 dmcc Exp $"

__version__ = "$Revision: 1.1 $"[11:-2]

def make_attributes_from_args(*argnames):

    """

    This function simulates the effect of running

      self.foo=foo

    for each of the given argument names ('foo' in the example just

    now). Now you can write:

    for a in argnames:

        try:

            setattr(callerself,a,callerlocals[a])

        except KeyError:

            raise KeyError("Function has no argument '%s'" % a)

def enumerate(*collections):

    """Generates an indexed series:  (0,coll[0]), (1,coll[1]) ...

    this is a multi-list version of the code from the PEP:

    enumerate(a,b) gives (0,a[0],b[0]), (1,a[1],b[1]) ...

    """

    i = 0

    iters = [iter(collection) for collection in collections]

    while True:

        i += 1

def dumpobj(o):

    """Prints all the object's non-callable attributes"""

    print(repr(o))

    for a in [x for x in dir(o) if not callable(getattr(o, x))]:

        try:

            print("  %20s: %s " % (a, getattr(o, a)))

        except:

            pass

    print("")

def dict_filter_update(d, **newitems):

    """Adds a set of new keys and values to dictionary 'd' if the values are

    true:

    >>> some_dict = {}

    >>> dict_filter_update(some_dict, a=None, b=0, c=1, e={}, s='hello')

    >>> some_dict

    {'c': 1, 's': 'hello'}

    """

    for k, v in list(newitems.items()):

        if v: d[k] = v

def try_get_logger(channel):

    """Tries to get a logger with the channel 'channel'.  Will return a

    silent DummyClass if logging is not available."""

    try:

        import logging

        log = logging.getLogger(channel)

    except ImportError:

        log = DummyClass()

    return log

class DummyClass:

    """A class that can be instantiated but never used.  It is intended to

    be replaced when information is available.

    Usage:

    >>> d = DummyClass(1, 2, x="xyzzy")

    >>> d.somefunction()

    Traceback (most recent call last):

      File "<stdin>", line 1, in ?

      File "Utility.py", line 33, in __getattr__

        raise AttributeError, "Attempted usage of a DummyClass: %s" % key

    AttributeError: Attempted usage of a DummyClass: somefunction"""

    def __init__(self, use_warnings=1, raise_exceptions=0, **kw):

        """Constructs a DummyClass"""

        make_attributes_from_args('use_warnings', 'raise_exceptions')

    def __getattr__(self, key):

        """Raises an exception to warn the user that a Dummy is not being

        replaced in time."""

        if key == "__del__":

            return

        msg = "Attempted usage of '%s' on a DummyClass" % key

        if self.use_warnings:

            import warnings

            warnings.warn(msg)

        if self.raise_exceptions:

            raise AttributeError(msg)

        return lambda *args, **kw: self.bogus_function()

    def bogus_function(self):

        pass

class ClassyDict(dict):

    """A dict that accepts attribute-style access as well (for keys

    that are legal names, obviously). I used to call this Struct, but

    chose the more colorful name to avoid confusion with the struct

    module."""

    def __getattr__(self, a):

        return self[a]

    def __setattr__(self, a, v):

        self[a] = v

    def __delattr__(self, a):

        del self[a]

def trace(func):

    """Good old fashioned Lisp-style tracing.  Example usage:

    >>> def f(a, b, c=3):

    >>>     print a, b, c

    >>>     return a + b

    3

    TODO: print out default keywords (maybe)

          indent for recursive call like the lisp version (possible use of 

              generators?)"""

    name = func.__name__

    def tracer(*args, **kw):

        s = '|>> %s called' % name

        if args:

            s += ' args: %r' % list(args)

        if kw:

            s += ' kw: %r' % kw

        print(s)

        ret = func(*args, **kw)

        print('<<| %s returned %s' % (name, ret))

        return ret

    return tracer

# these functions taken from old light8 code

def dict_max(*dicts):

    """

    ({'a' : 5, 'b' : 9}, {'a' : 10, 'b' : 4})

      returns ==> {'a' : 10, 'b' : 9}

    """

    newdict = {}

    for d in dicts:

        for k,v in list(d.items()):

            newdict[k] = max(v, newdict.get(k, 0))

    return newdict

def dict_scale(d,scl):

    """scales all values in dict and returns a new dict"""

    return dict([(k,v*scl) for k,v in list(d.items())])

def dict_subset(d, dkeys, default=0):

    """Subset of dictionary d: only the keys in dkeys.  If you plan on omitting

    keys, make sure you like the default."""

    newd = {} # dirty variables!

    for k in dkeys:

        newd[k] = d.get(k, default)

    return newd

# functions specific to Timeline

# TBD

def last_less_than(array, x):

    """array must be sorted"""

    best = None

    for elt in array:

        if elt <= x:

            best = elt

        elif best is not None:

            return best

    return best

# TBD

def first_greater_than(array, x):

    """array must be sorted"""

    array_rev = array[:]

    array_rev.reverse()

    best = None

    for elt in array_rev:

        if elt >= x:

            best = elt

        elif best is not None:

            return best

    return best

def chase(t,

          ontime=0.5,

          offset=0.2,

          onval=1.0,

          offval=0.0,

          names=None,

from rdflib import Graph

from rdflib import URIRef

from .namespaces import MUS, L9

log = logging.getLogger('showconfig')

_config = None # graph

def getGraph():

    global _config

    if _config is None:

        graph = Graph()

        # note that logging is probably not configured the first time

        # we're in here

        warnings.warn("reading n3 files around %r" % root())

            graph.parse(location=f.path, format='n3')

        _config = graph

    return _config

def root():

    r = getenv("LIGHT9_SHOW")

    if r is None:

        raise OSError(

            "LIGHT9_SHOW env variable has not been set to the show root")

    return r

_showUri = None

def showUri():

    """Return the show URI associated with $LIGHT9_SHOW."""

    global _showUri

    if _showUri is None:

        _showUri = URIRef(open(path.join(root(), 'URI')).read().strip())

    return _showUri

def songOnDisk(song):

    """given a song URI, where's the on-disk file that mpd would read?"""

    graph = getGraph()

    root = graph.value(showUri(), L9['musicRoot'])

    if not root:

        raise ValueError("%s has no :musicRoot" % showUri())

    name = graph.value(song, L9['songFilename'])

    if not name:

        raise ValueError("Song %r has no :songFilename" % song)

    return path.abspath(path.join(root, name))

def songFilenameFromURI(uri):

    """

    'http://light9.bigasterisk.com/show/dance2007/song8' -> 'song8'

    everything that uses this should be deprecated for real URIs

    everywhere"""

    assert isinstance(uri, URIRef)

    return uri.split('/')[-1]

def getSongsFromShow(graph, show):

    playList = graph.value(show, L9['playList'])

    if not playList:

        raise ValueError("%r has no l9:playList" % show)

    # The patch in https://github.com/RDFLib/rdflib/issues/305 fixed a

    # serious bug here.

    songs = list(graph.items(playList))

    return songs

def curvesDir():

    return path.join(root(),"curves")

def subFile(subname):

    return path.join(root(),"subs",subname)

def subsDir():

    return path.join(root(),'subs')

from twisted.internet import reactor, task

import traceback

import time

import logging

log = logging.getLogger()

class SubClient:

    def __init__(self):

        """assumed that your init saves self.graph"""

        pass # we may later need init code for network setup

    def get_levels_as_sub(self):

        """Subclasses must implement this method and return a Submaster

    def send_levels(self):

        self._send_sub()

    def send_levels_loop(self, delay=1000):

        now = time.time()

        def done(sec):

                              self.send_levels_loop)

        def err(e):

            log.warn('subclient loop: %r', e)

            reactor.callLater(2, self.send_levels_loop)

        d = self._send_sub()

        d.addCallbacks(done, err)

    def _send_sub(self):

        try:

            with self.graph.currentState() as g:

                outputSettings = self.get_output_settings(_graph=g)

        except:

            traceback.print_exc()

from glob import glob

from os.path import join, basename

class TkdndEvent(object):

    """

    see http://www.ellogon.org/petasis/tcltk-projects/tkdnd/tkdnd-man-page

    for details on the fields

    The longer attribute names (action instead of %A) were made up for

    tclSubstitutions = ' '.join(sorted(substitutions.keys()))

    def __repr__(self):

        return "<TkdndEvent %r>" % self.__dict__

class Hover(object):

    def __init__(self, widget, style):

        self.widget, self.style = widget, style

        self.oldStyle = {}

    def set(self, ev):

        for k, v in list(self.style.items()):

        self.widget.configure(**self.style)

        return ev.action

    def restore(self, ev):

        self.widget.configure(**self.oldStyle)

def initTkdnd(tk, tkdndBuildDir):

    """

    pass the 'tk' attribute of any Tkinter object, and the top dir of

    your built tkdnd package

    """

    tk.call('source', join(tkdndBuildDir, 'library/tkdnd.tcl'))

                         '*tkdnd*' + tk.call('info', 'sharedlibextension'))):

    """

    if the 'data' param is callable, it will be called every time to

    look up the current data.

    If the callable returns None (or data is None to begin with), the drag

    """

    def init():

        dataValue = data() if callable(data) else data

        if dataValue is None:

            return

        return (action, datatype, dataValue)

                              widget._substitute,

                              1 # needscleanup

                              )

    widget.bind("<<DragInitCmd>>", funcId)

                       onDropEnter=None,

                       onDropPosition=None,

                       onDropLeave=None,

                       onDrop=None,

                       hoverStyle=None,

                       ):

    widget.configure(**hoverStyle) and onDropLeave to restore the

    widget's style. onDrop is also wrapped to do a restore.

    """

    if hoverStyle is not None:

        hover = Hover(widget, hoverStyle)

        def wrappedDrop(ev):

            hover.restore(ev)

            if onDrop:

                return onDrop(ev)

                                  onDropEnter=hover.set,

                                  onDropLeave=hover.restore,

                                  onDropPosition=onDropPosition,

                                  onDrop=wrappedDrop)

    if typeList is None:

        ('<<DropPosition>>', onDropPosition),

        ('<<DropLeave>>', onDropLeave),

        ('<<Drop>>', onDrop),

        ]:

        if not handler:

            continue

        widget.bind(sequence, func + " " + TkdndEvent.tclSubstitutions)

"""all the tiny tk helper functions"""

#from Tkinter import Button

import logging, time

from rdflib import Literal

from tkinter.tix import Button, Toplevel, Tk, IntVar, Entry, DoubleVar

import tkinter

from light9.namespaces import L9

    'cuefader' : '314x212+546+741',

    'effect' : '24x24+0963+338',

    'stage' : '823x683+37+030',

    'scenes' : '504x198+462+12',

}

def bindkeys(root,key, func):

    root.bind(key, func)

    for w in root.winfo_children():

        w.bind(key, func)

            f.write(tl.geometry())

        # else the window never got mapped

    except Exception as e:

        # it's ok if there's no saved geometry

        pass

def toplevelat(name, existingtoplevel=None, graph=None, session=None):

    tl = existingtoplevel or Toplevel()

    tl.title(name)

    lastSaved = [None]

    setOnce = [False]

    graphSetTime = [0]

    def setPosFromGraphOnce():

        """

        the graph is probably initially empty, but as soon as it gives

        us one window position, we stop reading them

        """

        if setOnce[0]:

        graph.addHandler(setPosFromGraphOnce)

    if name in windowlocations:

        tl.geometry(positionOnCurrentDesktop(windowlocations[name]))

    if graph is not None:

    return tl

def positionOnCurrentDesktop(xform, screenWidth=1920, screenHeight=1440):

    size, x, y = xform.split('+')

    x = int(x) % screenWidth

    y = int(y) % screenHeight

    return "%s+%s+%s" % (size, x, y)

def toggle_slider(s):

    if s.get() == 0:

        s.set(100)

    else:

        s.set(0)

# for lambda callbacks

def printout(t):

    print('printout', t)

def printevent(ev):

    for k in dir(ev):

        if not k.startswith('__'):

            print('ev', k, getattr(ev,k))

def eventtoparent(ev,sequence):

    "passes an event to the parent, screws up TixComboBoxes"

    wid_class = str(ev.widget.__class__)

    if wid_class == 'Tix.ComboBox' or wid_class == 'Tix.TixSubWidget':

        return

    evdict={}

    for x in ['state', 'time', 'y', 'x', 'serial']:

        evdict[x]=getattr(ev,x)

#    evdict['button']=ev.num

    par=ev.widget.winfo_parent()

    if par!=".":

        ev.widget.nametowidget(par).event_generate(sequence,**evdict)

    #else the event made it all the way to the top, unhandled

def colorlabel(label):

    """color a label based on its own text"""

    txt=label['text'] or "0"

    lev=float(txt)/100

    low=(80,80,180)

    high=(255,55,0o50)

    out = [int(l+lev*(h-l)) for h,l in zip(high,low)]

    col="#%02X%02X%02X" % tuple(out)

    label.config(bg=col)

# TODO: get everyone to use this

def colorfade(low, high, percent):

    '''not foolproof.  make sure 0 < percent < 1'''

    out = [int(l+percent*(h-l)) for h,l in zip(high,low)]

    col="#%02X%02X%02X" % tuple(out)

    return col

def colortotuple(anytkobj, colorname):

    'pass any tk object and a color name, like "yellow"'

    rgb = anytkobj.winfo_rgb(colorname)

    return [v / 256 for v in rgb]

class Togglebutton(Button):

    """works like a single radiobutton, but it's a button so the

    label's on the button face, not to the side. the optional command

    callback is called on button set, not on unset. takes a variable

    just like a checkbutton"""

        self.oldcommand = command

        Button.__init__(self,parent,command=self.invoke,**kw)

        self._origbkg = self.cget('bg')

        self.downcolor = downcolor

        else: # unset