import serial
import threading, Queue
import time
import math


class SensorData:
	maximum = 1023

	def __init__(self, line):
		self.x = -1
		self.y = -1
		self.z = -1
		self.time = time.time()
		if line:
			split = line.strip().split(',')
			if len(split) >= 3 and split[0]:
				try:
					self.x = float(split[0]) / self.maximum
					self.y = float(split[1]) / self.maximum
					self.z = float(split[2]) / self.maximum
				except ValueError, e:
					print e

	def round(self, digits):
		return round(self.x, digits), round(self.y, digits), round(self.z, digits)

	def __str__(self):
		return '%.2f x:%.2f y:%.2f z:%.2f' % (self.time, self.x, self.y, self.z)

	def __sub__(self, other):
		# subtracting one from another returns
		# the velocity in each dimension
		duration = self.time - other.time
		return (self.x - other.x)/duration, (self.y - other.y)/duration, (self.z - other.z)/duration


class SerialReader(threading.Thread):
	def __init__(self, serial_port):
		threading.Thread.__init__(self)
		self.serial_port = serial_port
		self.output = Queue.Queue()

	def read(self):
		return self.output.get()

	def run(self):
		port = serial.Serial(self.serial_port, 9600)
		time.sleep(1)
		while 1:
			try:
				line = port.readline()
			except OSError:
				break
			if not line:
				break
			s = SensorData(line)
			self.output.put(s)
		port.close()
		self.output.put(None)


class Processor(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)
		self.setDaemon(True)
		self.data_queue = Queue.Queue()

	def process(self, data):
		self.data_queue.put(data)

	def run(self):
		self._setup()
		get = self.data_queue.get
		handle = self._handle
		while 1:
			data = get()
			if data is None: break
			handle(data)

	def _setup(self):
		pass

	def _handle(self):
		raise NotImplementedError


class BeatFinder(Processor):
	threshold = 2300

	def _setup(self):
		self.first = SensorData('')
		self.beat = 0

	def _handle(self, data):
		xdiff = (data.y - self.first.y)*100000
		if abs(xdiff) >= self.threshold and data.time - self.beat >= .5:
			if xdiff >= self.threshold:
				print '        X'
			else:
				print 'O        '
			self.beat = data.time
		self.first = data


class PewPew(Processor):
	notes = {(.5,.5,.5): 'PEW!',
		 (.6,.6,.6): 'BOOM!',
		}

	def _handle(self, data):
		note_to_play = self.notes.get(data.round(1),None)
		if note_to_play:
			print note_to_play




class Printer(Processor):
	def _handle(self, data):
		print data


def read_serial(serial_port):
	reader = SerialReader(serial_port)
	reader.setDaemon(True)
	reader.start()

	processors = []

	processors.append(BeatFinder())
	processors.append(PewPew())
	#processors.append(Printer())

	# start listening
	for p in processors:
		p.start()

	while 1:
		try:
			data = reader.read()
		except KeyboardInterrupt:
			break
		if data is None: break

		for p in processors:
			p.process(data)



if __name__ == '__main__':
	import sys
	read_serial(sys.argv[1])