#!/usr/bin/python

from padhelper import PadHelper, _Event
from simplemidi.options import *
from simplemidi.midimessage import *
from simplemidi.utils import *

from threading import Thread, Lock
import time


class SyncEvent(_Event):
	def __init__(self, evt):
		_Event.__init__(self, 0, (evt.tick, evt.evt))
		self.startTime=time.time()
		
	def __eq__(self, x):
		return x.tick==evt.tick and x.evt==self.evt

class SyncPadHelper(PadHelper):
	
	_DEFAULT_PARAMS=dictAssign(PadHelper._DEFAULT_PARAMS, {
		'forward_all_input': True
	})
	
	def __init__(self, adapter, path, params):
		param=initParams(SyncPadHelper._DEFAULT_PARAMS, params)
		PadHelper.__init__(self, adapter, path, params)
		self.lockQueue=Queue()
		self.forwardAllKey=param['forward_all_input']
		
	
	"""
	def send(self, evt) :
		if evt.track==self.padTrack :
			if evt.type==MidiType.NOTE_ON:
				if (evt.key+self.padTranslate) in self.ledbuttons: 
					self[evt.key+self.padTranslate]=evt.evt.velocity
					if evt.evt.velocity==1:
						self.lockQueue
		else:
			MidiPlayer.send(self, evt)
	"""
	
	def _findNoteEnd(self, istart, evt):
		for i in range(istart+1, len(self.events)):
			e=self.events[i]
			if e.type==MidiType.NOTE_ON and e.key==evt.key and e.evt.velocity==0:
				return e.transpose(self.transposeNote)
		return None
	
	def inputMessage(self, delta, msg):
		channel=msg.channel
		if msg.getType()==MidiType.NOTE_ON:
			x=self.lockQueue.peek()
			msg.key-=self.padTranslate
			if x!=None:
				if x.channel==msg.channel and x.key+self.transposeNote==(msg.key):
					self.lockQueue.dequeue()
					self.port.send(msg)
					
				elif self.forwardAllKey: self.port.send(msg)
				
			elif self.forwardAllKey: self.port.send(msg)
			
		elif msg.getType()==MidiType.NOTE_OFF:
			msg.key-=self.padTranslate
			self.port.send(msg)
			
		elif self.forwardAllKey:
			self.port.send(msg)
				
	
	def waitForEvent(self, evt):
		tick=evt.tick
		#DEBUG("waiting "+str(tick-self.tick)+" ticks for: ",evt)
		if tick<=0: return
		while not self.lockQueue.isEmpty():
			time.sleep(0.001)

		t=self.tick2time(tick-self.tick)
		time.sleep(t)
		self.tick=tick
		
			
	def play(self):
		self._load_track_event()
		self.tick=0
		self.startTime=time.time()
		for i in range(len(self.events)):
			evt=self.events[i].transpose(self.transposeNote)
			self.waitForEvent(evt)
			
			#self.addToQueue(i,3)
			
			
			if evt.track==self.padTrack and evt.type==MidiType.NOTE_ON:
				self[evt.key+self.padTranslate+self.transposeNote]=evt.evt.velocity
				if evt.evt.velocity==1:
					end=self._findNoteEnd(i, self.events[i])
					self.lockQueue.enqueue(evt)
			else:	
				self.send(evt)