class SendOSC(object):

    def __init__(self):
        self.osc_message = None
        self.osc_client = OSCClient()
        self.osc_message = OSCMessage()        
        
        self.ip = ""
        self.port = 0

    def connect(self, ip="localhost", port=8080):
        self.ip = ip
        self.port = port
        self.osc_client.connect((self.ip, self.port))

    def send(self, address, value):
        self.osc_message.setAddress(address)
        self.osc_message.append(value)
        self.osc_client.send(self.osc_message)

    def send_distane(self, distance):
        oscdump = "/dumpOSC/DistanceTipTarget"
        self.send(oscdump, distance)

    def send_needle_tip_position(self, x, y, z):
        oscdump = "/dumpOSC/needltip/x"
        self.send(oscdump, x)
        oscdump = "/dumpOSC/needltip/y"
        self.send(oscdump, y)
        oscdump = "/dumpOSC/needltip/z"
        self.send(oscdump, z)

def serialComms():
	while run:
		proximity = ser.readline()
		proxMsg = OSCMessage()
		proxMsg.setAddress(OSCAddress)
		proxMsg.append(proximity)
		columnClient.send(proxMsg)

def sendMessage():
    msg = OSCMessage()
    msg.setAddress("/oscTest")
    msg.append(100)
    print "sending '/oscTest 100' message to SuperCollider"
    client.send(msg)
    timedSendMessage()  # recursive call, keeps the timer going

def espaces_callback(path, tags, args, source):

    msg_string = ""
    msg_string += "\n\tpath   : %s" % path
    msg_string += "\n\ttags   : %s" % tags
    msg_string += "\n\targs   : %s" % args
    msg_string += "\n\tsource :%s" % str(source)
    print "OSCServer received: %s\nfrom %s.\n" % (msg_string, getUrlStr(source))

    ir_params = {  'duration'      : float(args[4]),
                   'nu'            : float(args[5]),
                   'sampling_rate' : float(args[6]),
                   'ev_params'     : {'space': str(args[1]), 'c':float(args[2]), 'j_max':int(args[3]),'F':list(args[7:])},
                }

    command = espace_client.handle_request(ir_params)

    # send reply to the client
    reply_port = int(args[0])
    reply_addresse = (source[0], reply_port)
    msg = OSCMessage("/pd")
    msg.append(command['saved_audio_path'])
    server.client.sendto(msg,reply_addresse,timeout=1)
    print "OSCServer send:\n\t%s\nto %s.\n" %(msg,reply_addresse)

    return OSCMessage("/")

 def send(self, sample):
     mes = OSCMessage(self.address)
     mes.append(sample.channel_data)
     try:
         self.client.send(mes)
     except:
         return

def send_event():
    spectral_densities = ['filled', 'packed', 'opaque','translucent','transparent','empty']
    # fill blanks
    data = ['']*17*3
    #onset, continuant, termination
    data[0] = 'attack'

    #elegimos el de mayor momento transversal
    i = [l for l in tree.lep_pt].index(max(tree.lep_pt))

    #duration, based on momento transversal .. lep_pt
    data[1] = mapValue(tree.lep_pt[i],0,100000,0.1,10)
    #Spectrum types: electrones : inarmonico  ,  muones:  granular
    data[10] = 'inharmonic' if tree.lep_type[i] == 11 else 'granular'
    #Spectrum occupation: angulo
    data[11] = 'center'
    #Spectrum density: lepton energy .. lep_E
    data[16] = spectral_densities[int(mapValue(tree.lep_E[i],0,100000,0,5))]

    bundle = OSCBundle()
    msg = OSCMessage("/"+args.messagename)
    for d in data:
        msg.append(d)
    bundle.append(msg)
    client.send(bundle)

 def send(self,name,val=None):
     msg = OSCMessage(name)
     if val is not None:
         msg.append(val)
     r = self.client.send(msg)
     self.osc_messages_sent += 1
     return r

 def send_oscbundle(self):
     # send a bundle with current bpm and polar coordinates of 
     # sound-objects relative to player
     #            /game/bpm
     client = OSCClient()
     bpm = OSCMessage()     
     bpm.setAddress("/game/bpm")
     bpm.append(self.player['bpm'])   
     bundle = OSCBundle()
     bundle.append(bpm)
     #            /game/sndobj/id-bola (ang, mod)  
     scn = bge.logic.getCurrentScene()
     play = scn.objects["player"]
     
     for ball in self.soundobjects:
         ballpos = ball.worldPosition
         vect = mathutils.Vector((0,1))
         dist = play.getVectTo(ballpos)[0]
         vect2 = play.getVectTo(ballpos)[2].to_2d()
         angle = math.degrees(-vect.angle_signed(vect2))
         #print("angle ", angle, "distancia ",dist)
         data = (angle, dist)
         # append data to bundle
         msg = OSCMessage()
         tag = "/game/sndobj/position/" + str(ball['id'])
         msg.setAddress(tag)
         msg.append(data)
         bundle.append(msg)
         #print(msg)
     #gl.client is a tuple in gl with ip and port
     client.sendto(bundle, gl.send_to)

def toggleMuteGroup(channel, state):
 stringChannel = str(channel)
 muteAddress = '/config/mute/' + stringChannel
 msg = OSCMessage(muteAddress)
 msg.append(state)
 client.send(msg)
 print msg

    def messageServer(self, messagePath, argument):
        client = OSCClient()
        client.connect((self.serverIP, self.serverPort))
        message = OSCMessage(messagePath)
        message.append(argument)

        client.send(message)

 def serve_forever(self):
     for msg in self.json_to_osc_q:
         osc_msg = OSCMessage(self.osc_command_name)
         osc_msg.append(msg[0]) #HTTP verb
         osc_msg.append(msg[1]) #HTTP path
         osc_msg.append(msg[2]) #content
         self.osc_client.send(osc_msg)

def loop(serial, host, port):
    osctx = osc_init( (host, port) )
    bitadev = bitalino_init(serial)
    if not bitadev:
        raise Exception("Coultdn't open the BITalino device")

    try:
        print "Entering reading loop..."
        while True:
            samples = bitadev.read()
            time.sleep(0.005)
            #bitadev.trigger(digitalOutput)
            for s in samples:
                msg = OSCMessage()
                msg.setAddress("/biosample")
                out = []

                for sval in s:
                    out.append(sval / 1024)

                msg.append(out)
                #print msg
                osctx.send( msg )
    except KeyboardInterrupt as e:
        print "Looks like you wanna leave. Good bye!"
    finally:
        bitadev.stop()
        bitadev.close()

def hardware_callback(addr, tags, d, client_address):
    #d is data

    h_id = int(addr.split("/")[-1])

    event = None
    error = False

    if h_id == JUNCTION:
        if len(d) == 13:    
            #create event object
            event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":JUNCTION,
                    "topRowOn":d[0],1:d[1],2:d[2],3:d[3],4:d[4],5:d[5],6:d[6],
                    7:d[7],8:d[8],9:d[9],10:d[10],11:d[11],12:d[12]})
        else:
            error = True
    elif h_id == SCIENCE:
        event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":SCIENCE,"s1":True})
    elif h_id == COMMANDER:
        event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":COMMANDER,"has_power":True})
    elif h_id == RADIO:
        event = pygame.event.Event(NETWORK_HARDWARE,{"hardware_id":RADIO,"frequency":55})

    if event != None:
        pygame.event.post(event)
    if error:
        #object malformed, return error
        msg = OSCMessage("/user/1")
        msg.append("Error")
        server.client.sendto(msg,client_address)

    def record_data(self):
        if(self.port is None):
            return None
        
        print "Logging started"
        
        while 1:
            localtime = datetime.now()
            current_time = str(localtime.hour)+":"+str(localtime.minute)+":"+str(localtime.second)+"."+str(localtime.microsecond)
            log_string = current_time
            results = {}
            for index in self.sensorlist:
                (name, value, unit) = self.port.sensor(index)
                log_string = log_string + ","+str(value)
                results[obd_sensors.SENSORS[index].shortname] = value;
                
				#send sensor data via OSC
                message = OSCMessage()
                message.setAddress("/"+obd_sensors.SENSORS[index].shortname)
                message.append(value)
                self.client.send(message)

            gear = self.calculate_gear(results["rpm"], results["speed"])
            log_string = log_string #+ "," + str(gear)
			#send gear via OSC
            message = OSCMessage()
            message.setAddress("/gear")
            message.append(gear)
            self.client.send(message)
            self.log_file.write(log_string+"\n")

def fader_callback(path, tags, args, source):
	print ("path", path) 
	print ("args", args) 
	print ("source", source) 
	msg=OSCMessage("/1/rotary1")
	msg.append(args);
	client.send(msg)

  def handle_sample(self, sample):
    mes = OSCMessage(self.address)
	mes.append(sample.channel_data)
	# silently pass if connection drops
	try:
		self.client.send(mes)
	except:
		return	

 def send(self, path, value):
     try:
         message = OSCMessage(path)
         message.append(value)
         self.osc.send(message)
     except:
         print "Error connecting to OSC server. Re-initiating Connection."
         self.setup_connection()

def sendOSCMessage(pin, value):
  # LOW/0 = pressed and HIGH/1 = released
  # example: "/b/p 12 0"
  if (value == 0):
    obj = OSCMessage("/b/p")
  else:
    obj = OSCMessage("/b/r")
  obj.append(int(pin))

def send_osc_message(name, *args):
	msg = OSCMessage(name)
	for arg in args:
		msg.append(arg)
	try:
		client.send(msg, 0)
	except Exception, e:
		pass

def rotary1_callback(path, tags, args, source):
	print str(path) + " " + str(args[0])
	json.send({'command':'put', 'key':'rotary1', 'value':'%i' % int(args[0])})
	#create feedback for faders label:	
	msg = OSCMessage("/1/label_rotary1")
	msg.insert(0, int(args[0]))
	client.connect( (source[0], 9000) )
	client.send(msg)