#!/usr/bin/env python
"""
Example of a UDP txosc sender with Twisted.

This example is in the public domain.
"""

import argparse
import csv
import signal
import time

import ntplib
from twisted.internet import reactor
from txosc import osc
from txosc import async


class UDPSenderApplication(object):
    """
    Example that sends UDP messages.
    """
    def __init__(self, port, host, address, rows, shift, token):
        self.port = port
        self.host = host
        self.client = async.DatagramClientProtocol()
        self._client_port = reactor.listenUDP(0, self.client)
        self.rows = rows
        self.address = address
        self.shift = shift
        self.token = token
        reactor.callLater(0, self.send_messages)

    def _send(self, element):
        # This method is defined only to simplify the example
        self.client.send(element, (self.host, self.port))
        print("Sent %s to %s:%d" % (element, self.host, self.port))

    def send_messages(self):
        t0 = time.time()
        #tc = 0
        for row in self.rows:
            if not self.token.running:
                break
            if self.shift:
                row[0] = ntplib.system_to_ntp_time(t0 + float(row[1])/1000.0)
            row_conv = [ osc.TimeTagArgument(float(row[0]))] + [osc.IntArgument(int(a)) for a in row[1:]]
            #time.sleep((row_conv[1].value-tc)/1000.0)
            sleep_time = t0+float(row[1])/1000.0-time.time()
            if sleep_time > 0:
                time.sleep(sleep_time)
            #time.sleep(0.1)
            tc = row_conv[1].value
            self._send(osc.Message(self.address,*row_conv))
        print("Goodbye.")
        reactor.callLater(0.1, reactor.stop)

class Token(object):
    def __init__(self):
        self.running = True

if __name__ == "__main__":

    token = Token()

    parser = argparse.ArgumentParser(description='Simulate an (osc) pianoroll client.')
    parser.add_argument('datafile', metavar='DATAFILE', help='The file containing the pianoroll data (CSV).')
    parser.add_argument('-e', '--event', dest='event', metavar='EVENT', required=True, help='the event code.')
    parser.add_argument('-s', '--shift', dest='shift', action='store_true', required=False, help='Shift the data.', default=False)

    args = parser.parse_args()

    def customHandler(signum, _):
        print("Got signal: %s" % signum)
        token.running = False
        if reactor.running:
            reactor.callFromThread(reactor.stop) # to stop twisted code when in the reactor loop
    signal.signal(signal.SIGINT, customHandler)


    with open(args.datafile, 'rU') as datafile:
        reader = csv.reader(datafile, delimiter=' ')
        app = UDPSenderApplication(9090, "127.0.0.1", "/pianoroll/%s/" % args.event, list(reader), args.shift, token)

    reactor.run()