#!bin/python
"""
Replaced by bin/collector


this is the only process to talk to the dmx hardware. other clients
can connect to this server and present dmx output, and this server
will max ('pile-on') all the client requests.

this server has a level display which is the final set of values that
goes to the hardware.

clients shall connect to the xmlrpc server and send:

  their PID (or some other cookie)

  a length-n list of 0..1 levels which will represent the channel
    values for the n first dmx channels.

server is port 8030; xmlrpc method is called outputlevels(pid,levellist).

todo:
  save dmx on quit and restore on restart
  if parport fails, run in dummy mode (and make an option for that too)
"""

from twisted.internet import reactor
from twisted.web import xmlrpc, server
import sys, time, os
from optparse import OptionParser
import run_local
import txosc.dispatch, txosc. async
from light9.io import ParportDMX, UsbDMX

from light9.updatefreq import Updatefreq
from light9 import networking

from txzmq import ZmqEndpoint, ZmqFactory, ZmqPullConnection, ZmqRequestTimeoutError
import json


def startZmq(port, outputlevels):
    zf = ZmqFactory()
    e = ZmqEndpoint('bind', 'tcp://*:%s' % port)
    s = ZmqPullConnection(zf, e)

    def onPull(message):
        msg = json.loads(message[0])
        outputlevels(msg['clientid'], msg['levellist'])

    s.onPull = onPull


class ReceiverApplication(object):
    """
    receive UDP OSC messages. address is /dmx/1 for dmx channel 1,
    arguments are 0-1 floats for that channel and any number of
    following channels.
    """

    def __init__(self, port, lightServer):
        self.port = port
        self.lightServer = lightServer
        self.receiver = txosc.dispatch.Receiver()
        self.receiver.addCallback("/dmx/*", self.pixel_handler)
        self._server_port = reactor.listenUDP(
            self.port,
            txosc. async .DatagramServerProtocol(self.receiver),
            interface='0.0.0.0')
        print("Listening OSC on udp port %s" % (self.port))

    def pixel_handler(self, message, address):
        # this is already 1-based though I don't know why
        startChannel = int(message.address.split('/')[2])
        levels = [a.value for a in message.arguments]
        allLevels = [0] * (startChannel - 1) + levels
        self.lightServer.xmlrpc_outputlevels("osc@%s" % startChannel, allLevels)


class XMLRPCServe(xmlrpc.XMLRPC):

    def __init__(self, options):

        xmlrpc.XMLRPC.__init__(self)

        self.clientlevels = {}  # clientID : list of levels
        self.lastseen = {}  # clientID : time last seen
        self.clientfreq = {}  # clientID : updatefreq

        self.combinedlevels = []  # list of levels, after max'ing the clients
        self.clientschanged = 1  # have clients sent anything since the last send?
        self.options = options
        self.lastupdate = 0  # time of last dmx send
        self.laststatsprint = 0  # time

        # desired seconds between sendlevels() calls
        self.calldelay = 1 / options.updates_per_sec

        print("starting parport connection")
        self.parportdmx = UsbDMX(dimmers=90, port=options.dmx_device)
        if os.environ.get('DMXDUMMY', 0):
            self.parportdmx.godummy()
        else:
            self.parportdmx.golive()

        self.updatefreq = Updatefreq()  # freq of actual dmx sends
        self.num_unshown_updates = None
        self.lastshownlevels = None
        # start the loop
        self.sendlevels()

        # the other loop
        self.purgeclients()

    def purgeclients(self):
        """forget about any clients who haven't sent levels in a while.
        this runs in a loop"""

        purge_age = 10  # seconds

        reactor.callLater(1, self.purgeclients)

        now = time.time()
        cids = list(self.lastseen.keys())
        for cid in cids:
            lastseen = self.lastseen[cid]
            if lastseen < now - purge_age:
                print(("forgetting client %s (no activity for %s sec)" %
                       (cid, purge_age)))
                try:
                    del self.clientlevels[cid]
                except KeyError:
                    pass
                del self.clientfreq[cid]
                del self.lastseen[cid]

    def sendlevels(self):
        """sends to dmx if levels have changed, or if we havent sent
        in a while"""

        reactor.callLater(self.calldelay, self.sendlevels)

        if self.clientschanged:
            # recalc levels

            self.calclevels()

            if (self.num_unshown_updates is None or  # first time
                    self.options.fast_updates or  # show always
                (
                    self.combinedlevels != self.lastshownlevels and  # changed
                    self.num_unshown_updates > 5)):  # not too frequent
                self.num_unshown_updates = 0
                self.printlevels()
                self.lastshownlevels = self.combinedlevels[:]
            else:
                self.num_unshown_updates += 1

        if time.time() > self.laststatsprint + 2:
            self.laststatsprint = time.time()
            self.printstats()

        # used to be a fixed 1 in here, for the max delay between
        # calls, instead of calldelay
        if self.clientschanged or time.time(
        ) > self.lastupdate + self.calldelay:
            self.lastupdate = time.time()
            self.sendlevels_dmx()

        self.clientschanged = 0  # clear the flag

    def calclevels(self):
        """combine all the known client levels into self.combinedlevels"""
        self.combinedlevels = []
        for chan in range(0, self.parportdmx.dimmers):
            x = 0
            for clientlist in list(self.clientlevels.values()):
                if len(clientlist) > chan:
                    # clamp client levels to 0..1
                    cl = max(0, min(1, clientlist[chan]))
                    x = max(x, cl)
            self.combinedlevels.append(x)

    def printlevels(self):
        """write all the levels to stdout"""
        print("Levels:",
              "".join(["% 2d " % (x * 100) for x in self.combinedlevels]))

    def printstats(self):
        """print the clock, freq, etc, with a \r at the end"""

        sys.stdout.write("dmxserver up at %s, [polls %s] " % (
            time.strftime("%H:%M:%S"),
            str(self.updatefreq),
        ))
        for cid, freq in list(self.clientfreq.items()):
            sys.stdout.write("[%s %s] " % (cid, str(freq)))
        sys.stdout.write("\r")
        sys.stdout.flush()

    def sendlevels_dmx(self):
        """output self.combinedlevels to dmx, and keep the updates/sec stats"""
        # they'll get divided by 100
        if self.parportdmx:
            self.parportdmx.sendlevels([l * 100 for l in self.combinedlevels])
        self.updatefreq.update()

    def xmlrpc_echo(self, x):
        return x

    def xmlrpc_outputlevels(self, cid, levellist):
        """send a unique id for your client (name+pid maybe), then
        the variable-length dmx levellist (scaled 0..1)"""
        if levellist != self.clientlevels.get(cid, None):
            self.clientlevels[cid] = levellist
            self.clientschanged = 1
        self.trackClientFreq(cid)
        return "ok"

    def xmlrpc_currentlevels(self, cid):
        """get a list of levels we're currently sending out. All
        channels beyond the list you get back, they're at zero."""
        # if this is still too slow, it might help to return a single
        # pickled string
        self.trackClientFreq(cid)
        trunc = self.combinedlevels[:]
        i = len(trunc) - 1
        if i < 0:
            return []
        while trunc[i] == 0 and i >= 0:
            i -= 1
        if i < 0:
            return []
        trunc = trunc[:i + 1]
        return trunc

    def trackClientFreq(self, cid):
        if cid not in self.lastseen:
            print("hello new client %s" % cid)
            self.clientfreq[cid] = Updatefreq()
        self.lastseen[cid] = time.time()
        self.clientfreq[cid].update()


parser = OptionParser()
parser.add_option("-f",
                  "--fast-updates",
                  action='store_true',
                  help=('display all dmx output to stdout instead '
                        'of the usual reduced output'))
parser.add_option("-r",
                  "--updates-per-sec",
                  type='float',
                  default=20,
                  help=('dmx output frequency'))
parser.add_option("-d",
                  "--dmx-device",
                  default='/dev/dmx0',
                  help='dmx device name')
parser.add_option("-n",
                  "--dummy",
                  action="store_true",
                  help="dummy mode, same as DMXDUMMY=1 env variable")
(options, songfiles) = parser.parse_args()

print(options)

if options.dummy:
    os.environ['DMXDUMMY'] = "1"

port = networking.dmxServer.port
print("starting xmlrpc server on port %s" % port)
xmlrpcServe = XMLRPCServe(options)
reactor.listenTCP(port, server.Site(xmlrpcServe))

startZmq(networking.dmxServerZmq.port, xmlrpcServe.xmlrpc_outputlevels)

oscApp = ReceiverApplication(9051, xmlrpcServe)

reactor.run()