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 rdflib import RDF

from light9 import Patch

from light9.namespaces import L9

log = logging.getLogger()

registered = []

def register(f):

    registered.append(f)

    return f

@register

class Strip(object):

    """list of r,g,b tuples for sending to an LED strip"""

    which = 'L'  # LR means both. W is the wide one

    pixels = []

from tkinter.tix import *

from time import time, sleep

class Mass:

    def __init__(self):

        self.x = 0  # position

        self.xgoal = 0  # position goal

        self.v = 0  # velocity

        self.maxspeed = .8  # maximum speed, in position/second

        self.maxaccel = 3  # maximum acceleration, in position/second^2

        self.eps = .03  # epsilon - numbers within this much are considered the same

        self._lastupdate = time()

        self._stopped = 1

    def equal(self, a, b):

        return abs(a - b) < self.eps

    def stop(self):

        self.v = 0

        self.xgoal = self.x

        self._stopped = 1

    def update(self):

        t0 = self._lastupdate

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

        """

        self.name = name

        self.levels = levels

        self.temporary = True

        if not self.temporary:

            # obsolete

            dispatcher.connect(log.error, 'reload all subs')

        #log.debug("%s initial levels %s", self.name, self.levels)

    def _editedLevels(self):

        pass

    def set_level(self, channelname, level, save=True):

        self.levels[resolve_name(channelname)] = level

        self._editedLevels()

    def set_all_levels(self, leveldict):

        self.levels.clear()

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

            # this may call _editedLevels too many times

            self.set_level(k, v, save=0)

    def get_levels(self):

        return self.levels

    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)

    def ident(self):

        return (self.name, tuple(sorted(self.levels.items())))

    def __repr__(self):

        items = sorted(list(getattr(self, 'levels', {}).items()))

        levels = ' '.join(["%s:%.2f" % item for item in items])

        return "<'%s': [%s]>" % (getattr(self, 'name', 'no name yet'), levels)

    def __cmp__(self, other):

        # not sure how useful this is

        if not isinstance(other, Submaster):

            return -1

        return cmp(self.ident(), other.ident())

    def __hash__(self):

        return hash(self.ident())

    def get_dmx_list(self):

        leveldict = self.get_levels() # gets levels of sub contents

        levels = []

        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

    def normalize_patch_names(self):

        """Use only the primary patch names."""

        # possibly busted -- don't use unless you know what you're doing

        self.set_all_levels(self.levels.copy())

    def get_normalized_copy(self):

        """Get a copy of this sumbaster that only uses the primary patch

        names.  The levels will be the same."""

        newsub = Submaster("%s (normalized)" % self.name, {})

        newsub.set_all_levels(self.levels)

        return newsub

    def crossfade(self, othersub, amount):

        """Returns a new sub that is a crossfade between this sub and

        another submaster.

        NOTE: You should only crossfade between normalized submasters."""

        otherlevels = othersub.get_levels()

        keys_set = {}

        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)

        Submaster.__init__(self, self.name, self.levels)

        self.temporary = False

    def ident(self):

        return self.uri

    def _editedLevels(self):

        self.save()

    def changeName(self, newName):

        self.graph.patchObject(self.uri, self.uri, RDFS.label, Literal(newName))

    def setName(self):

        log.info("sub update name %s %s", self.uri, self.graph.label(self.uri))

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

    def setLevels(self):

        log.debug("sub update levels")

                # broken lightLevel link- may be from someone deleting channels

                log.warn("sub %r has lightLevel %r with channel %r "

                         "and level %r" % (self.uri, lev, chan, val))

                continue

            log.debug("   new val %r", val)

            if val == 0:

                continue

            name = self.graph.label(chan)

            if not name:

                log.error("sub %r has channel %r with no name- "

                          "leaving out that channel" % (self.name, chan))

                continue

            try:

                self.levels[name] = float(val)

            except:

                log.error("name %r val %r" % (name, val))

                raise

    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:

            levs = list(g.objects(self.uri, L9['lightLevel']))

        for lev in levs:

            self.graph.removeMappingNode(self._saveContext(), lev)

    def allQuads(self):

        """all the quads for this sub"""

        quads = []

        with self.graph.currentState() as current:

            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

        graph = Graph()

        subUri = L9['sub/%s' % self.name]

        graph.add((subUri, RDFS.label, Literal(self.name)))

        for chan in list(self.levels.keys()):

            try:

                chanUri = get_channel_uri(chan)

            except KeyError:

                log.error("saving dmx channels with no :Channel node "

                          "is not supported yet. Give channel %s a URI "

                          "for it to be saved. Omitting this channel "

                          "from the sub." % chan)

                continue

            lev = BNode()

            graph.add((subUri, L9['lightLevel'], lev))

            graph.add((lev, L9['channel'], chanUri))

            graph.add((lev, L9['level'],

                       Literal(self.levels[chan], datatype=XSD['decimal'])))

        graph.serialize(showconfig.subFile(self.name), format="nt")

def linear_fade(start, end, amount):

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

    Serves 8."""

    scaledsubs = [sub * level for sub, level in list(subdict.items())]

    maxes = sub_maxes(*scaledsubs)

    if name:

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

        current = set()

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

            if self.graph.contains((s, RDF.type, L9['LocalSubmaster'])):

                continue

            log.debug("found sub %s", s)

            if s not in self.submasters:

                sub = self.submasters[s] = PersistentSubmaster(self.graph, s)

                dispatcher.send("new submaster", sub=sub)

            current.add(s)

        for s in set(self.submasters.keys()) - current:

            del self.submasters[s]

            dispatcher.send("lost submaster", subUri=s)

        log.info("findSubs finished, %s subs", len(self.submasters))

    def get_all_subs(self):

        "All Submaster objects"

        l = sorted(list(self.submasters.items()))

        l = [x[1] for x in l]

        songs = []

        notsongs = []

        for s in l:

            if s.name and s.name.startswith('song'):

                songs.append(s)

            else:

                notsongs.append(s)

        combined = notsongs + songs

        return combined

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

    # get_all_sub_names went missing. needs rework

    #if name in submasters.get_all_sub_names():

    #    return submasters.get_sub_by_name(name)

    try:

        val = int(name)

        s = Submaster("#%d" % val, levels={val : 1.0})

        return s

    except ValueError:

        pass

    try:

        subnum = get_dmx_channel(name)

        s = Submaster("'%s'" % name, levels={subnum : 1.0})

        return s

    except ValueError:

        pass

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

        def __init__(self,foo,bar,baz):

            copy_to_attributes('foo','bar','baz')

            ...

    instead of:

        def __init__(self,foo,bar,baz):

            self.foo=foo

            self.bar=bar

            self.baz=baz

            ... 

    """

    callerlocals=sys._getframe(1).f_locals

    callerself=callerlocals['self']

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

    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: someattr

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

    >>>

    >>>

    >>> f = trace(f)

    >>> f(1, 2)

    |>> f called args: [1, 2]

    1 2 3

    <<| f returned 3

    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,

          combiner=max):

    names = names or []

    # maybe this is better:

    # period = ontime + ((offset + ontime) * (len(names) - 1))

    period = (offset + ontime) * len(names)

    outputs = {}

    for index, name in enumerate(names):

        # normalize our time

        local_offset = (offset + ontime) * index

        local_t = t - local_offset

        local_t %= period

        # see if we're still in the on part

        if local_t <= ontime:

            value = onval

        else:

            value = offval

import logging, warnings

from twisted.python.filepath import FilePath

from os import path, getenv

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 light9.collector.collector_client import sendToCollector

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

        object."""

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

            return

        return sendToCollector('subclient', self.session, outputSettings)

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