#!/usr/bin/python

# CarPI Web Host
# CarPI is a project developed by Watsuprico
# CarPI's objective is to make interfacing between the raspberry pi and car, driver and raspberry pi, and driver and raspberry pi easier
#	(Add bluetooth media streaming, untilize steering wheel controls to influence bluetooth media, and to interface with underdash illumination (either with user settings or car data, like RPM))

# for some reason my leds over do the blue, R255 G255 and B100 make white


# Setup
from __future__ import division

debug = True
def debugPrint(message):
	if debug:
		print colored("[DEBUG] "+message, "yellow")

# Allow any characters (like jap ones)
import sys
import os
import codecs
sys.stdout = codecs.getwriter('utf8')(sys.stdout)
sys.stderr = codecs.getwriter('utf8')(sys.stderr)

from termcolor import colored # Allow color in the term

# Get commands from the CGI script (so I don't have to scrub dbus for every method just to pause the music (it's cpu intensive and highly ineffective))
import socket
from threading import *
# Our end
CGISocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
CGISocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
CGISocket.bind(("localhost", 8000))

# Used to get methods and stuff
import dbus
from xml.etree import ElementTree

bus=dbus.SystemBus()

# LEDs
from time import sleep
import pigpio
from random import randint
import json
from multiprocessing import Process, Manager
pi = pigpio.pi()

Stop=False

redPIN=17
greenPIN=22
bluePIN=24

colorCurrent={"red":0.0,"blue":0.0,"green":0.0}
colorCurrent["red"]=0.0
colorCurrent["green"]=0.0
colorCurrent["blue"]=0.0

brightness=1 # 0-1 (.5=half)

# OBDII
RPM="0"
SPEED="0"
ENGINE_LOAD="0"
COOLANT_TEMP="0"
FUEL_LEVEL="0"
AMBIANT_AIR_TEMP="0"

# Setup complete


# RGB Led stuff
def colorToPin(color):
	if color=="red":
		return redPIN
	elif color=="green":
		return greenPIN
	else:
		return bluePIN

def current(color):
	current=0.0
	try:
		current=pi.get_PWM_dutycycle(colorToPin(color))
	except Exception:
		current=0
	return current

def fadeFromTo(color,Int,End,duration):
	global Stop
	global colorCurrent
	pin=colorToPin(color)
	Int=round(abs(Int),5)
	End=round(abs(End),5)
	if Int>255:
		Int=255
	elif Int<0:
		Int=0
	if End>255:
		End=255
	elif End<0:
		End=0
	#debugPrint(color+" is fading "+str(Int)+"->"+str(End)+" using duration: " + str(duration))

	if duration!=0 and Int-End!=0:
		duration=abs(duration)/abs(Int-End)
	if Int>End:
		while Int>=End and not Stop:
			pi.set_PWM_dutycycle(pin, Int)
			colorCurrent[color]=Int
			sleep(duration)
			Int=Int-1
	else:
		while Int<=End and not Stop:
			pi.set_PWM_dutycycle(pin, Int)
			colorCurrent[color]=Int
			sleep(duration)
			Int=Int+1

def fadeTo(color,to,duration):
	fadeFromTo(color,current(color),to,duration)

def fadeIn(color, duration):
	fadeTo(color,255,duration)
def fadeOut(color,duration):
	fadeTo(color,0,duration)

def fadeRGBToRGB(redIntValue,greenIntValue,blueIntValue,redEndValue,greenEndValue,blueEndValue,duration):
	redChange=redEndValue-redIntValue
	greenChange=greenEndValue-greenIntValue
	blueChange=blueEndValue-blueIntValue
	maxChange=max(abs(redChange),abs(greenChange),abs(blueChange),1)

	redInc=0.0
	greenInc=0.0
	blueInc=0.0
	if redChange==0:
		redInc=0
	else:
		redInc=round((redChange/maxChange),5)
	if greenChange==0:
		greenInc=0
	else:
		greenInc=round((greenChange/maxChange),5)
	if blueChange==0:
		blueInc=0
	else:
		blueInc=round((blueChange/maxChange),5)

	red=redIntValue
	green=greenIntValue
	blue=blueIntValue
	# debugPrint("maxChange: " + str(maxChange))
	# debugPrint("redChange: " + str(redChange))
	# debugPrint("greenChange: " + str(greenChange))
	# debugPrint("blueChange: " + str(blueChange))
	# debugPrint("red: " + str(red))
	# debugPrint("green: " + str(green))
	# debugPrint("blue: " + str(blue))
	# debugPrint("redInc: " + str(redInc))
	# debugPrint("greenInc: " + str(greenInc))
	# debugPrint("blueInc: " + str(blueInc))
	# debugPrint("redEndValue: " + str(redEndValue))
	# debugPrint("greenEndValue: " + str(greenEndValue))
	# debugPrint("blueEndValue: " + str(blueEndValue))
	# debugPrint("duration: " + str(duration))

	if duration!=0:
		duration=abs(duration)/maxChange
	i=0
	while i<maxChange:
		red=red+redInc
		green=green+greenInc
		blue=blue+blueInc
		fadeTo("red",red,duration/3)
		fadeTo("green",green,duration/3)
		fadeTo("blue",blue,duration/3)
		sleep(duration)
		i=i+1

def fadeToRGB(redEndValue,greenEndValue,blueEndValue,duration):
	fadeRGBToRGB(current("red"),current("green"),current("blue"),redEndValue,greenEndValue,blueEndValue,duration)


# fadeToRGB(255,0,0,0.5)
# fadeToRGB(0,255,0,0.5)
# fadeToRGB(0,0,255,0.5)
# sleep(1)
# fadeOut("blue",1)
# pi.stop()
# sys.exit(0)

# Bluetooth

def renderSupport(path):
	obj = bus.get_object('org.bluez', path)
	iface = dbus.Interface(obj, 'org.freedesktop.DBus.Introspectable')
	return iface.Introspect()

def renderPathFull(bus, object_path):
	paths={}
	xml_string = renderSupport(object_path)
	for child in ElementTree.fromstring(xml_string):
		if child.tag == 'node':
			new_path = '/'.join((object_path, child.attrib['name']))
			paths[child.attrib['name']]=renderPathFull(bus, new_path)
	return paths

def renderPath(bus, object_path, prog):
	paths={}
	xml_string = renderSupport(object_path)
	for child in ElementTree.fromstring(xml_string):
		if child.tag == 'node':
			if prog==0:
				new_path = '/'.join((object_path, child.attrib['name']))
				paths[child.attrib['name']]=renderPath(bus, new_path,1)
			else:
				paths[child.attrib['name']]={}
	return paths

# List the different bluetooth adapters connected to the pi
def getAdapters():
	return renderPath(bus,'/org/bluez',0)

# List the devices under an adapter
def devices(btadapters):
	for btadapter in btadapters:
		btadapters[btadapter]=renderPathFull(bus, '/org/bluez/'+btadapter)
	return btadapters

# Searches for a bluetooth media player on all adapters and then sets that as our player
def autoSelectDevice():
	global bluetoothPlayerObj
	global bluetoothPlayerInterface
	global devInt
	global bluetoothPlayerPath

	btadapters=getAdapters()
	paths=devices(btadapters)
	for btadapter in btadapters:
		debugPrint(btadapter)
		for btdevice in paths[btadapter]:
			debugPrint(btdevice)
			if btdevice:
				for player in paths[btadapter][btdevice]:
					debugPrint("'" + player + "'")
					if player.startswith("player"):
						bluetoothPlayerPath="/org/bluez/"+btadapter+"/"+btdevice+"/"+player
						debugPrint("Player found! Path: "+bluetoothPlayerPath)
						bluetoothPlayerObj = bus.get_object('org.bluez', bluetoothPlayerPath)
						bluetoothPlayerInterface = dbus.Interface(bluetoothPlayerObj, 'org.bluez.MediaPlayer1')
						devInt = dbus.Interface(bluetoothPlayerObj, dbus_interface='org.freedesktop.DBus.Properties') # I use this to get properties (I don't know another way)
dbus-send --session --type=method_call --print-reply --dest=org.bluez /org/bluez/hci0/dev_DC_74_A8_ED_40_43 org.freedesktop.DBus.Introspectable.Introspect

autoSelectDevice()


def handleWebCommand(webCommand, config):
	global bus

	global Stop

	global bluetoothPlayerObj
	global bluetoothPlayerInterface
	global devInt
	global bluetoothPlayerPath

	response=""

	if webCommand=="play":
		bluetoothPlayerInterface.Play()
		response="sys_play"
	elif webCommand=="pause":
		bluetoothPlayerInterface.Pause()
		response="sys_paused"
	elif webCommand == 'stop':
		bluetoothPlayerInterface.Stop()
		response="sys_pause\nsys_stopped"

	elif webCommand == "playpause":
		bluetoothPlayer=devInt.GetAll('org.bluez.MediaPlayer1')

		if bluetoothPlayer["Status"] != "playing":
			bluetoothPlayerInterface.Play()
			response="sys_play"
		else:
			bluetoothPlayerInterface.Pause()
			response="sys_pause"
	
	elif webCommand == 'next':
		bluetoothPlayerInterface.Next()
		response='sys_next'
	elif webCommand == 'previous':
		bluetoothPlayerInterface.Previous()
		response='sys_prev'
	elif webCommand == 'fastforward':
		bluetoothPlayerInterface.FastForward()
		response='sys_fforward'
	elif webCommand == 'rewind':
		bluetoothPlayerInterface.Rewind()
		response='sys_rewind'

	elif webCommand=="toggleShuffle":
		bluetoothPlayer=devInt.GetAll('org.bluez.MediaPlayer1')

		if "Shuffle" in bluetoothPlayer:
			if bluetoothPlayer["Shuffle"]=="off":
				devInt.Set('org.bluez.MediaPlayer1','Shuffle','alltracks')
			else:
				devInt.Set('org.bluez.MediaPlayer1','Shuffle','off')
		response="sys_complete"

	elif webCommand=="toggleRepeat":
		bluetoothPlayer=devInt.GetAll('org.bluez.MediaPlayer1')

		if "Repeat" in bluetoothPlayer:
			if bluetoothPlayer["Repeat"]=="off":
				devInt.Set('org.bluez.MediaPlayer1','Repeat','alltracks')
			elif bluetoothPlayer["Repeat"]=="alltracks":
				devInt.Set('org.bluez.MediaPlayer1','Repeat','singletrack')
			else:
				devInt.Set('org.bluez.MediaPlayer1','Repeat','off')
		response="sys_complete"

	elif webCommand=='getMediaStatus':
		bluetoothPlayer=devInt.GetAll('org.bluez.MediaPlayer1')

		response='{ "playStatus": "'+bluetoothPlayer["Status"]+'", '

		if "Shuffle" in bluetoothPlayer:
			response=response+'"shuffle": "'+bluetoothPlayer["Shuffle"]+'", '
		else:
			response=response+'"shuffle": "sys_disabled", '
		if "Repeat" in bluetoothPlayer:
			response=response+'"repeat": "'+bluetoothPlayer["Repeat"]+'", '
		else:
			response=response+'"repeat": "sys_disabled", '

		# Probably not avalible
		if "Equalizer" in bluetoothPlayer:
			response=response+'"equalizer": "'+bluetoothPlayer["Equalizer"]+'", '
		else:
			response=response+'"equalizer": "sys_disabled", '
		if "Scan" in bluetoothPlayer:
			response=response+'"scan": "'+bluetoothPlayer["Scan"]+'", '
		else:
			response=response+'"scan": "sys_disabled", '

		# Time items
		if "Position" in bluetoothPlayer:
			response=response+'"position": "'+str(bluetoothPlayer["Position"])+'", '
		else:
			response=response+'"position": "sys_disabled", '
		if "Duration" in bluetoothPlayer["Track"]:
			response=response+'"duration": "'+str(bluetoothPlayer["Track"]["Duration"])+'", '
		else:
			response=response+'"duration": "sys_disabled", '

		# The app we're controlling
		if "Name" in bluetoothPlayer:
			response=response+'"player": "'+bluetoothPlayer["Name"]+'", '
		else:
			response=response+'"player": "sys_disabled", '

		# Basics
		response=response+'"title": '
		if "Title" in bluetoothPlayer["Track"]:
			response=response+'"'+bluetoothPlayer["Track"]["Title"]+'", '
		else:
			response=response+'"Untitled", '
		response=response+'"artist": '
		if "Artist" in bluetoothPlayer["Track"]:
			response=response+'"'+bluetoothPlayer["Track"]["Artist"]+'", '
		else:
			response=response+'"Unknown artist", '
		response=response+'"album": '
		if "Album" in bluetoothPlayer["Track"]:
			response=response+'"'+bluetoothPlayer["Track"]["Album"]+'", '
		else:
			response=response+'"Unknown album", '

		if "Genre" in bluetoothPlayer["Track"]:
			response=response+'"genre": "'+str(bluetoothPlayer["Track"]["Genre"])+'", '
		else:
			response=response+'"genre": "sys_disabled", '
		# Track info
		if "NumberOfTracks" in bluetoothPlayer["Track"]:
			response=response+'"numberOfTracks": "'+str(bluetoothPlayer["Track"]["NumberOfTracks"])+'", '
		else:
			response=response+'"numberOfTracks": "sys_disabled", '
		if "TrackNumber" in bluetoothPlayer["Track"]:
			response=response+'"trackNumber": "'+str(bluetoothPlayer["Track"]["TrackNumber"])+'", '
		else:
			response=response+'"trackNumber": "sys_disabled", '

		if "Playlist" in bluetoothPlayer:
			response=response+'"playlistPath": "'+str(bluetoothPlayer["Playlist"])+'", '
		else:
			response=response+'"playlistPath": "sys_disabled", '


		# Device info
		if "Device" in bluetoothPlayer:
			response=response+'"device": "'+bluetoothPlayer["Device"]+'", '
		else:
			response=response+'"device": "sys_disabled", '
		if "Browsable" in bluetoothPlayer:
			response=response+'"browsable": "'+str(bluetoothPlayer["Browsable"])+'", '
		else:
			response=response+'"browsable": "sys_disabled", '
		if "Searchable" in bluetoothPlayer:
			response=response+'"searchable": "'+str(bluetoothPlayer["Searchable"])+'", '
		else:
			response=response+'"serachable": "sys_disabled", '

		if "Type" in bluetoothPlayer:
			response=response+'"playerType": "'+bluetoothPlayer["Type"]+'", '
		else:
			response=response+'"playerType": "sys_disabled", '

		if "Subtype" in bluetoothPlayer:
			response=response+'"playerSubtype": "'+bluetoothPlayer["Subtype"]+'" }'
		else:
			response=response+'"playerSubtype": "sys_disabled" }'


		# if "" in bluetoothPlayer[]:
		# 	response=response+'"": "'+bluetoothPlayer[]+'", '
		# else:
		# 	response=response+'"": "sys_disabled", '

	elif webCommand == "refreshDbus":
		bus=dbus.SystemBus()
		autoSelectDevice()
		response="sys_dbus-refreshed"


	elif webCommand=="setModeStatic":
		config["mode"]="static"
		response=config["mode"]
	elif webCommand=="setModeBreathing":
		config["mode"]="static"
		response=config["mode"]

	elif webCommand.startswith("setR"):
		Stop=True
		config["static"]["red"]=float(webCommand[4:])
		response="red:"+str(config["static"]["red"])
	elif webCommand.startswith("setG"):
		Stop=True
		config["static"]["green"]=float(webCommand[4:])
		response="green:"+str(config["static"]["green"])
	elif webCommand.startswith("setB"):
		Stop=True
		config["static"]["blue"]=float(webCommand[4:])
		response="blue:"+str(config["static"]["blue"])


	elif webCommand=="getOBDIISpeed":
		response=getOBDIIInfo("Speed")
	elif webCommand=="getOBDIIRpm":
		response=getOBDIIInfo("RPM")
	elif webCommand=="getOBDII":
		# {"name": "value", ...}
		response='{"FUEL_LEVEL": "'+getOBDIIInfo("FuelLevel")+'", "COOLANT_TEMP": "'+getOBDIIInfo("CoolantTemp")+'", "ENGINE_LOAD": "'+getOBDIIInfo("EngineLoad")+'"}'
	else:
		return "sys_error\nUnknown command"

	return response.encode("utf-8")


# Config handling
def loadConfig():
	global config
	with open('/var/CarPI/config.json') as configFile:
			config=json.load(configFile)
	debugPrint("Config loaded")
	return "sys_complete"

def saveConfig():
	global config
	with open('/var/CarPI/config.json') as configFile:
		configFile.write(str(json.dumps(config, sort_keys=True,indent=4, separators=(',', ': '))))
	debugPrint("Config saved")
	return "sys_complete"


# LED while loop
def led(config):
	global Stop
	debugPrint("Mode: " + config["mode"])
	if config["mode"]=="static":
		if colorCurrent["red"]!=config["static"]["red"] or colorCurrent["green"]!=config["static"]["green"] or colorCurrent["blue"]!=config["static"]["blue"]:
			fadeToRGB(float(config["static"]["red"]),float(config["static"]["green"]),float(config["static"]["blue"]),.25)
	elif config["mode"]=="breathing":
		for color in config["breathing"]:
			if colorCurrent["red"]!=color["red"] or colorCurrent["green"]!=color["green"] or colorCurrent["blue"]!=color["blue"]:
				fadeToRGB(float(color["red"]),float(color["green"]),float(color["blue"]),float(color["fadeDuration"]))
				sleep(float(color["timeout"]))

def ledWhile(config):
	while 1:
		led(config)
		Stop=False
		sleep(0.01)

def getOBDIIInfo(info):
	OBDIIClient = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Their end

	try:
		OBDIIClient.connect(("localhost",7000))
		OBDIIClient.send(info)
		Response=""
		Response=CGISocket.recv(1024).decode('utf-8')
		CGISocket.close()
		return Response
	except socket.error:
		return "Read Error"
	except Exception, e:
		return "sys_error - "+str(e)

def PhysicalMediaControls():
	print("Not done :^)")


# Socket command handling
class client(Thread):
	def __init__(self, socket, address, config):
		Thread.__init__(self)
		self._is_running = True
		self.config=config
		self.sock = socket
		self.addr = address
		self.start()

	def stop(self):
		self._is_running = False

	def run(self):
		while self._is_running:
			webCommand = self.sock.recv(1024).decode()
			if webCommand:
				response=handleWebCommand(webCommand,self.config)
				try:
					debugPrint('\nCommand recieved: ' + webCommand + '\nResponse: ' + response.decode('utf-8'))
					a=0
				except Exception:
					debugPrint('\nError printing response/command, probably has unicode in it')
				self.sock.sendto(response,self.addr)
			else:
				self.stop()


def main():
	global config
	try:
		manager=Manager()
		config=manager.dict()
		loadConfig()
		ledProcess=Process(target=ledWhile, args=(config,))
		ledProcess.start()
		PMC=Thread(target=PhysicalMediaControls)
		PMC.start()
		# ledThread=ledT(Thread(target=ledWhile))
		CGISocket.listen(5)
		print 'Listening.'
		while 1:
		    conn,add=CGISocket.accept()
		    client(conn, add, config)
	except KeyboardInterrupt:
		print "\nGoodbye"
		ledProcess.terminate()
		fadeToRGB(0,0,0,0.005)
		pi.stop()
		carConnection.close()
		os._exit(0)
	except Exception, e:
		print "Error!"
		print colored(str(e),"red")
		traceback.print_exc()		

	fadeToRGB(0,0,0,0.005)
	pi.stop()
	carConnection.close()
	os._exit(0)

if __name__ == "__main__":
	main()