System /*-trace*/ tearoom

//interazione ingresso client
Request  checkAvail : checkAvail(X) 
Reply    waitingTime : waitingTime(X) 

//interazioni client
Request 	notify 	: 	notify(X)
Reply		tempResult	:	tempResult(X)
Dispatch	accept	:	accept(ID)
Dispatch	inform	:	inform(ID,X)

//interazione ordinazione client
//prima immagine
Dispatch readyToOrder : readyToOrder(X) 

//seconda immagine
Request take : take(X)
Dispatch order : order(ID,X)
Dispatch orderReq : orderReq(ID,X) 

// barman e interfaccia web
Event prepare : prepare(ID)

//to add
Dispatch takeDrink : takeDrink(X)
  
//terza immagine  
Dispatch ready : ready(X) 

//interazione richiesta uscita client  
Dispatch exitReq : exitReq(X)

//interazione pagamento client
Request  collect : collect(X) 
Dispatch    payment : payment(ID,X)



//progressione comportamento client
Event newClient : newClient(X)
Event nextState : nextState(ID)


//interazione col planner
Dispatch doMove     : doMove(V)
Request  movetoCell : movetoCell(X,Y)
Reply    atcell     : atcell(X,Y)

//interazione col basicrobot
Dispatch cmd       	: cmd(MOVE)    
Request step : step(TIME)
Reply stepdone : stepdone(X)
Reply stepfail : stepfail(X)

//auto-messaggi
Dispatch moveTo : moveTo(X)
Dispatch readyToTakeOrder : readyToTakeOrder(X)
Dispatch listenRequests : listenRequests(X)
Dispatch pay : pay(X)
Dispatch cleanTable : cleanTable(T)

Dispatch goEntranceDoor : goEntranceDoor(X)

//interazioni resource model
Dispatch newClient : newClient(X)
Dispatch waiterCurrentPositionDirection : waiterCurrentPositionDirection(X,Y,D)
Dispatch taskDone : taskDone(T,X)
Dispatch updateClientState : updateClientState(ID,R)
Request askWhere : askWhere(X)
Reply location : location(X,Y)
Event waiterTaskChangedEvent : waiterTaskChangedEvent(X,T)
Event waitingTimeEvent : waitingTimeEvent(ID,X)
Event newOrderEvent : newOrderEvent(X)
Event orderReadyEvent : orderReadyEvent(X)

// model - client
Dispatch updateClientState : updateClientState(ID,R)
Request clientStateReq : clientStateReq(ID)
Reply clientStateRep : clientStateRep(ID, STATE)

//dall'interfaccia web al resourcemodel
Dispatch move : move(X)
Dispatch state : state(X)

// timer
Dispatch startTimer : startTimer(A,M,P,T)
Dispatch alarm : alarm(ID)



Context ctxtearoom ip [ host= "localhost"   port= 8010 ] 
Context ctxbasicrobot ip [ host= "127.0.0.1" port= 8020]


ExternalQActor basicrobot context ctxbasicrobot



QActor resourcemodel context ctxtearoom{
	[#
		var TeatableNumber = ""
		var Teatable = ""
		var busy = false
		var ID = ""
	#]
	State s0 initial{
		println("[RESOURCE MODEL] STARTING, I will be soon ready to listen to changes!")
		solve( consult("sysRules.pl")	 ) 
		solve(consult("tearoomkb.pl"))
		discardMsg Off
	}
	Goto listenToChanges
	
	State listenToChanges{
		//println("[RESOURCE MODEL] LISTENING...")
	} Transition t0 
			whenMsg newClient -> informChanges
			whenMsg ready -> informChanges
			whenMsg orderReq -> informChanges
			whenMsg waiterCurrentPositionDirection -> informChanges
			whenMsg updateClientState -> informChanges
			whenMsg taskDone -> informChanges
			whenRequest askWhere -> findLocation
			whenMsg move -> informChanges
			whenMsg state -> informChanges
			whenRequest clientStateReq -> returnClientState
			whenMsg alarm -> informChanges
	
	State informChanges{

		onMsg(newClient : newClient(X)) {
			println("[RESOURCE MODEL] New Client")
			solve(newClient(ID))
			[#
				ID = getCurSol("ID").toString()
			#]
			solve(teatable(TeatableNumber,available))
	 		ifSolved {
	 			println("[RESOURCE MODEL] A table is free!")
	 			[# 
				TeatableNumber = getCurSol("TeatableNumber").toString()
				#]
				solve(replaceRule(teatable($TeatableNumber,_),teatable($TeatableNumber,busy)))
				solve(assignTable($TeatableNumber,$ID))
				solve(replaceRule(client($ID,_),client($ID, entering)))
				println("[RESOURCE MODEL] Waiter task updated: reachEntranceDoor")
				emit waitingTimeEvent : waitingTimeEvent($ID,0)
				if [#busy#] {
					solve(addTask(reachEntranceDoor,$TeatableNumber))
				} else {
					[# busy = true #]
					solve(replaceRule(waiter(_),waiter(reachEntranceDoor)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(reachEntranceDoor,$TeatableNumber)
		 		}
		 		forward timer -m startTimer : startTimer(resourcemodel, alarm, $ID, 500000)
	 		} else {
	 			println("[RESOURCE MODEL] All tables is busy")
	 			solve(addWaitingClient($ID))
				emit waitingTimeEvent : waitingTimeEvent($ID,600000) //maxwaitingtime
		 	}		
		}
		onMsg(updateClientState : updateClientState(ID,R)){
			[#
				ID = payloadArg(0)
				val R = payloadArg(1)
				when(R) {
					"ordering" -> {#]
						solve(replaceRule(client($ID,_),client($ID,ordering)))
						
						solve(teatableClientID(TeatableNumber,$ID))
						[# TeatableNumber = getCurSol("TeatableNumber").toString() #]
						if [#busy#] {
							solve(addTask(takingOrder,$TeatableNumber))
						} else {
							[# busy = true #]
							solve(replaceRule(waiter(_),waiter(takingOrder)))
							emit waiterTaskChangedEvent : waiterTaskChangedEvent(takingOrder,$TeatableNumber)
						}
					[#}
					"waitingtea" -> {#] //TODO: FORSE INUTILE LA PARTE DEL WAITER SE LUI VA AUTOMATICAMENTE A CASA
						solve(replaceRule(client($ID,_),client($ID,waitingtea)))
						//solve(replaceRule(waiter(_),waiter(returnHome)))
						//emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
					[#}
					"drinking" -> {#] //TODO: FORSE INUTILE LA PARTE DEL WAITER SE LUI VA AUTOMATICAMENTE A CASA
						solve(replaceRule(client($ID,_),client($ID,drinking)))
						if [#busy#] {
							solve(addTask(returnHome,0))
						} else {
							[# busy = true #]
							solve(replaceRule(waiter(_),waiter(returnHome)))
							emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)	
						}
					[#}
					"paying" -> {#]
						solve(replaceRule(client($ID,_),client($ID,paying)))
						solve(teatableClientID(T, $ID))
						[# TeatableNumber = getCurSol("T").toString() #]
						if [#busy#] {
							solve(addTask(collectingPayment,$TeatableNumber))
						} else {
							[# busy = true #]
							solve(replaceRule(waiter(_),waiter(collectingPayment)))
							emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingPayment,$TeatableNumber)
						}
						
					[#}
					"exiting" -> {#]
						solve(replaceRule(client($ID,_),client($ID,exiting)))
						//solve(replaceRule(waiter(_),waiter(collectingPayment)))
						//emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingPayment,0)
					[#}
					"gone" -> {#]
						solve(replaceRule(client($ID,OldState),client($ID,gone))) 
						[# val OS = getCurSol("OldState").toString() #]
						if [# OS == "waiting" #] {
							solve(withdraw)
						}
						solve(roomstate( waiter(S),currentWaiterPosDir(Y,X,D) , stateOfTeatables(T1,T2), servicedesk(SD), orders(O), getClientsState(CS), teaServed(TS), totalNumberOfClients(NC), clientsInTheRoom(CR), withdraws(W)))
						[# 	
							val S = getCurSol("S").toString()
							val X = getCurSol("X").toString()
							val Y = getCurSol("Y").toString()
							val D = getCurSol("D").toString()
							val T1 = getCurSol("T1").toString()
							val T2 = getCurSol("T2").toString()
							val SD = getCurSol("SD").toString()
							val O = getCurSol("O").toString()
							val CS = getCurSol("CS").toString()
							val TS = getCurSol("TS").toString()
							val NC = getCurSol("NC").toString()
							val CR = getCurSol("CR").toString()
							val W = getCurSol("W").toString()
							
							
							val JsonState : String = itunibo.formatter.formatterUtil.formatJson(S,X,Y,D,T1,T2,SD,O,CS,TS,NC,CR,W)
						#]
						updateResource [# JsonState #]
						solve(exitClient($ID))
						
			 		
					[#}
				}
			#]
		}
		onMsg(orderReq : orderReq(ID,O)){
			[# 
				ID = payloadArg(0)
				val O = payloadArg(1)
			#]
			println("[RESOURCE MODEL] New order for client $ID")
			solve(replaceRule(servicedesk(_),servicedesk(preparing($ID,$O))))
			solve(addOrder($ID,$O))
			emit newOrderEvent : newOrderEvent($ID)
		}
		onMsg(ready : ready(ID)){
			[# ID = payloadArg(0)#]
			solve(client($ID,_))
			ifSolved {
				println("[RESOURCE MODEL] Order is ready for client $ID")
				solve(replaceRule(servicedesk(_),servicedesk(ready($ID))))
				solve(deleteOrder($ID,_))
				solve(teatableClientID(TeatableNumber,$ID))
				[# TeatableNumber = getCurSol("TeatableNumber").toString() #]
				if [#busy#] {
					solve(addTask(collectingDrink,$TeatableNumber))
				} else {
					[# busy = true #]
					solve(replaceRule(waiter(_),waiter(collectingDrink)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingDrink,$TeatableNumber)
				}
			} else {
				println("[RESOURCE MODEL] Order is ready for client $ID but is gone")
				solve(replaceRule(servicedesk(_),servicedesk(idle)))
				solve(deleteOrder($ID,_))
			}
		}
		onMsg(waiterCurrentPositionDirection : waiterCurrentPositionDirection(X,Y,D)) {
			[# 
				val X = payloadArg(0)
				val Y = payloadArg(1)
				val D = payloadArg(2)
			#]
			solve(replaceRule(currentWaiterPosDir(_,_,_),currentWaiterPosDir($X,$Y,$D)))
		}
		onMsg(taskDone : taskDone(T,X)) {
			[# var Task = payloadArg(0) #]
			[# when(Task) {
				"reachEntranceDoor" ->  { #]
				solve(replaceRule(waiter(_),waiter(convoyTable)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(convoyTable,0)
			[# } 
				"convoyTable" ->  {
			#] 
				solve(getTask(T,P))
				ifSolved {
					[# Task = getCurSol("T").toString() 
						var P = getCurSol("P").toString()
					#]
					solve(replaceRule(waiter(_),waiter($Task)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
				} else {
					solve(replaceRule(waiter(_),waiter(returnHome)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				}
			[# } 
				"returnHome" ->  {
			#] 
				solve(replaceRule(waiter(_),waiter(athome)))
				solve(teatable(TeatableNumber,dirty))
				ifSolved {
					[# TeatableNumber = getCurSol("TeatableNumber").toString() #]
					solve(replaceRule(waiter(_),waiter(sanitizing)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(sanitizing,$TeatableNumber)
				} else {
					solve(getTask(T,P))
					ifSolved {
						[# Task = getCurSol("T").toString() 
							var P = getCurSol("P").toString()
						#]
						solve(replaceRule(waiter(_),waiter($Task)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
					} else {
						[# busy = false #]
					}
				}

			[# } 
				"takingOrder" ->  {
			#] 
				solve(getTask(T,P))
				ifSolved {
					[# Task = getCurSol("T").toString() 
						var P = getCurSol("P").toString()
					#]
					solve(replaceRule(waiter(_),waiter($Task)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
				} else {
					solve(replaceRule(waiter(_),waiter(returnHome)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				}
			[# } 
				"collectingDrink" ->  {
			#] 
				solve(replaceRule(servicedesk(_),servicedesk(idle)))
				solve(replaceRule(waiter(_),waiter(bringingDrinkToClient)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(bringingDrinkToClient,0)
			[# } 
				"bringingDrinkToClient" ->  {
			#] 
				solve(getTask(T,P))
				ifSolved {
					[# Task = getCurSol("T").toString() 
						var P = getCurSol("P").toString()
					#]
					solve(replaceRule(waiter(_),waiter($Task)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
				} else {
					solve(replaceRule(waiter(_),waiter(returnHome)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				}
				solve(serveTea)
			[# } 
				"collectingPayment" ->  {
			#] 
				solve(teatableClientID(T, $payloadArg(1)))
				[# TeatableNumber = getCurSol("T").toString() #]
				solve(replaceRule(teatable($TeatableNumber,_), teatable($TeatableNumber,dirty)))
				solve(replaceRule(waiter(_),waiter(convoyExit)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(convoyExit,0)
			[# } 
				"convoyExit" ->  {
			#] 
				//solve(exitClient)
				solve(getTask(T,P))
				ifSolved {
					[# Task = getCurSol("T").toString() 
						var P = getCurSol("P").toString()
					#]
					solve(replaceRule(waiter(_),waiter($Task)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
				} else {
					solve(replaceRule(waiter(_),waiter(returnHome)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				}
			[# } 
				"sanitizing" ->  {
			#]  
				[#
				TeatableNumber = payloadArg(1)
				#]
				solve(getWaitingClient(ID))
				ifSolved {
					[# ID = getCurSol("ID").toString() #]
					solve(replaceRule(teatable($TeatableNumber,_),teatable($TeatableNumber,busy)))
					solve(assignTable($TeatableNumber,$ID))
					solve(replaceRule(client($ID,_),client($ID, entering)))
					println("[RESOURCE MODEL] Waiter task updated: reachEntranceDoor")
					//emit waitingTimeEvent : waitingTimeEvent($ID,0)
					[# busy = true #]
					solve(replaceRule(waiter(_),waiter(reachEntranceDoor)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(reachEntranceDoor,$TeatableNumber)
			 		
				} else {
					solve(replaceRule(teatable($TeatableNumber,_),teatable($TeatableNumber,available)))
					solve(getTask(T,P))
					ifSolved {
						[# Task = getCurSol("T").toString() 
							var P = getCurSol("P").toString()
						#]
						solve(replaceRule(waiter(_),waiter($Task)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent($Task,$P)
					} else {
						solve(replaceRule(waiter(_),waiter(returnHome)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
					}	
				}
			[#}
				"forceExit" -> {#]
					solve(replaceRule(teatable($payloadArg(1),_), teatable($payloadArg(1),dirty)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(convoyExit,0)
				[#}
			}#]	
			
		}
		onMsg(move : move(X)){
			[# 
				val Task = payloadArg(0)
				when(Task) {
					"stepAhead" -> {#]
						solve(replaceRule(waiter(_),waiter(stepAhead)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(stepAhead,0)
					[#}
					"turnLeft" -> {#]
						solve(replaceRule(waiter(_),waiter(turnLeft)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(turnLeft,0)
					[#}
					"turnRight" -> {#]
						solve(replaceRule(waiter(_),waiter(turnRight)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(turnRight,0)
					[#}
					"returnHome" -> {#]
						solve(replaceRule(waiter(_),waiter(returnHome)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
					[#}
				}
			#]
		}
		
		onMsg(alarm : alarm(ID)) {
			[# var served = true 
				ID = payloadArg(0)
			#]
			solve(client($ID,ClientState))
			ifSolved {
				[# var clientState = getCurSol("ClientState").toString() #]
				solve(teatableClientID(T, $ID))
				[# TeatableNumber = getCurSol("T").toString() #]
				if [#clientState == "ordering" || clientState == "entering"#]{
					[# served = false #]
				}
				if [#busy#] {
					if [#served#] {
						solve(addTask(collectingPayment,$TeatableNumber))	
						solve(replaceRule(client($ID,_),client($ID,paying)))
					} else {
						solve(addTask(forceExit,$TeatableNumber))	
						solve(replaceRule(client($ID,_),client($ID,exiting)))
					}
				} else {
					[# busy = true #]
					if [#served#] {
						solve(replaceRule(client($ID,_),client($ID,paying)))
						solve(replaceRule(waiter(_),waiter(collectingPayment)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingPayment,$TeatableNumber)
					} else {
						solve(replaceRule(client($ID,_),client($ID,exiting)))
						solve(replaceRule(waiter(_),waiter(forceExit)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(forceExit,$TeatableNumber)
					}
					
				}
			
			}
		}
		

		solve(roomstate( waiter(S),currentWaiterPosDir(Y,X,D) , stateOfTeatables(T1,T2), servicedesk(SD), orders(O), getClientsState(CS), teaServed(TS), totalNumberOfClients(NC), clientsInTheRoom(CR), withdraws(W)))
		[# 	
			val S = getCurSol("S").toString()
			val X = getCurSol("X").toString()
			val Y = getCurSol("Y").toString()
			val D = getCurSol("D").toString()
			val T1 = getCurSol("T1").toString()
			val T2 = getCurSol("T2").toString()
			val SD = getCurSol("SD").toString()
			val O = getCurSol("O").toString()
			val CS = getCurSol("CS").toString()
			val TS = getCurSol("TS").toString()
			val NC = getCurSol("NC").toString()
			val CR = getCurSol("CR").toString()
			val W = getCurSol("W").toString()
			
			
			val JsonState : String = itunibo.formatter.formatterUtil.formatJson(S,X,Y,D,T1,T2,SD,O,CS,TS,NC,CR,W)
		#]
		updateResource [# JsonState #]
		
	} Goto listenToChanges
	
	State findLocation {
		onMsg(askWhere : askWhere(X)){
			[# var Spot = payloadArg(0) #]
			println("[RESOURCE MODEL] Find location $Spot")
			solve(pos($Spot,X,Y))
			[# 
			val X = getCurSol("X").toString() 
		  	val Y = getCurSol("Y").toString()
			#]
			replyTo askWhere with location : location($X,$Y)
		}
	}Goto listenToChanges
	
	State returnClientState {
		onMsg(clientStateReq : clientStateReq(ID)) {
			[# ID = payloadArg(0) #]
			solve(client($ID,S))
			[# val S = getCurSol("S").toString()#]
			replyTo clientStateReq with clientStateRep : clientStateRep($ID,$S)
		}
		
	}Goto listenToChanges
}

QActor waiter context ctxtearoom{ 
	
	[# 
		var WhatImDoing = "athome" 
		var TeatableNumber = ""
		var Teatable = ""
	#]
	
	State s0 initial{ 
		println("[WAITER] waiter is starting..I'm HOME!") 
		discardMsg Off
	} 
	Goto reqHandler
	
 	State reqHandler{
 		println("[WAITER] Waiting for a request!")
 	}
 	Transition t0 
 		whenEvent waiterTaskChangedEvent -> handleChange
 		whenMsg moveTo -> movementHelper
 		
 	State handleChange {
 		onMsg(waiterTaskChangedEvent : waiterTaskChangedEvent(T,X)) {
 			[# 
 				WhatImDoing = payloadArg(0)
 				if(payloadArg(1) == "1" || payloadArg(1) == "2") {
 					TeatableNumber = payloadArg(1)
 					Teatable = "teatable" + TeatableNumber
 				}
 			#]
 			println("[WAITER] New task: $WhatImDoing")
 			
 			[#
			when(WhatImDoing) {
				"reachEntranceDoor" -> {#]
					forward waiter -m moveTo : moveTo(entrancedoor)
				[#}
				"convoyTable" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
				"takingOrder" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
				"collectingDrink" -> {#]
					 forward waiter -m moveTo : moveTo(barman)
				[#}
				"bringingDrinkToClient" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
				"collectingPayment" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
				"convoyExit" -> {#]
					forward waiter -m moveTo : moveTo(exitdoor)
				[#}
				"returnHome" -> {#]
					forward waiter -m moveTo : moveTo(home)
				[#}	
				"sanitizing" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
	
				"stepAhead" -> {#]
					forward planner -m doMove : doMove(w)
				[#}
				"turnLeft" -> {#]
					forward planner -m doMove : doMove(l)
				[#}
				"turnRight" -> {#]
					forward planner -m doMove : doMove(r)
				[#}
					
				"forceExit" -> {#]
					forward waiter -m moveTo : moveTo($Teatable)
				[#}
 			}#]
 		}
 	}Goto reqHandler 
	
	State clientReady {
		
	}Goto reqHandler
	//Transition t0 whenMsg order -> clientReady
	
	State takingOrder {
		onMsg(order : order(ID, O)) {
			[# var ID = payloadArg(0) 
				var O = payloadArg(1)
			#]
			forward resourcemodel -m orderReq : orderReq( $ID, $O )
			println("[WAITER] I'm transmitting the order to the barman")
			forward resourcemodel -m taskDone : taskDone($WhatImDoing,0)
		}
	} 
	Goto reqHandler
	
	// TODO:FORSE IL ROBOT DEVE ASPETTARE CHE IL CLIENTE ENTRI NELLO STATO DI DRINKING PRIMA
	// DI ANDARSENE???
	
	State servingDrinkToClient {
		println("[WAITER] Serving the drink")
		//forward clientsimulator -m serveDrink : serveDrink(tea)
		//delay 5000
		forward resourcemodel -m taskDone : taskDone($WhatImDoing,0)
	}
	Goto reqHandler
	
	State payment{
		println("[WAITER] Collecting the money!")
		//request clientmanager -m collect : collect(1)
	}
	Transition t0 whenMsg payment -> handlePayment
	
	State handlePayment {
		//delay 5000
		onMsg(payment : payment( ID, MONEY )){
			[# println("[WAITER] " + payloadArg(0) + " EUR collected! Have a nice day!") #]
			forward resourcemodel -m taskDone : taskDone($WhatImDoing,$payloadArg(0))
		}
		
	}
	Goto reqHandler
	
	State cleaningTable{
		onMsg(cleanTable : cleanTable(T)) {
			[#TeatableNumber = payloadArg(0)#]
			println("[WAITER] Cleaning $Teatable!")
			delay 5000
			forward resourcemodel -m taskDone : taskDone($WhatImDoing,$TeatableNumber)
		}
	}Goto reqHandler
	
	
	// Stati legati al movimento
	
	State movementHelper {
		onMsg(moveTo : moveTo(L)){
			[#val Location = payloadArg(0)#]
			request resourcemodel -m askWhere : askWhere($Location)
		}
		onMsg (location : location(X,Y)) {
			[# 
				val XT = payloadArg(0)
			   	val YT = payloadArg(1)			  
			 #]
			request planner -m movetoCell : movetoCell($XT,$YT)
		}
	}Transition t1 	whenReply location -> movementHelper
					whenReply atcell -> handleAtCell
					

	State handleAtCell {	
		onMsg(atcell : atcell(X,Y)){
			[# when(WhatImDoing) {
				"takingOrder" ->  {
			#] 
				//forward waiter -m readyToTakeOrder : readyToTakeOrder(A)
			[# } 
				"bringingDrinkToClient" ->  {
			#] 
				//forward waiter -m listenRequests : listenRequests(1)
				//forward waiter -m serveDrink : serveDrink(A)
			[# } 
				"collectingPayment" ->  {
			#] 
				//forward waiter -m pay : pay(A)
			[# } 
				"sanitizing" ->  {
			#]  
				forward waiter -m cleanTable : cleanTable($TeatableNumber)
			[#}
				"forceExit" -> {#]
				forward waiter -m listenRequests : listenRequests(1)
				forward resourcemodel -m taskDone : taskDone($WhatImDoing,$TeatableNumber)
			[#}
				else -> {
			#]
				forward waiter -m listenRequests : listenRequests(1)
				forward resourcemodel -m taskDone : taskDone($WhatImDoing,0)
			[#}
			}#]
		}
	}	Transition t1 	whenMsg moveTo -> movementHelper  
						whenMsg order -> takingOrder
						whenMsg takeDrink -> servingDrinkToClient
						whenMsg payment -> handlePayment
						whenMsg cleanTable -> cleaningTable
						whenMsg listenRequests -> reqHandler
						
	
}





/*
 * excutes a plan without 'interruption'
 */
QActor planner context ctxtearoom{  
[#
	var XT = "0"
	var YT = "0"
	var CurrentPlannedMove = ""
	var StepTime    	   = 100L
	var Configured = false
	var SingleMove = false
#]
	State s0 initial {	     
		//println("&&&  insensitivewalker STARTED")
		if [# !Configured #] {
			[# Configured = true #]
			run itunibo.planner.plannerUtil.initAI()
			run itunibo.planner.plannerUtil.loadRoomMap( "teaRoomExplored" )
			discardMsg Off
		}
		[# SingleMove = false #]
	}	
	Transition t0 	whenRequest movetoCell -> walk
					whenMsg doMove  -> execSingleMove
	
	State execSingleMove {
		[# SingleMove = true #]
		onMsg( doMove : doMove(M) ){ 	
  			if [# payloadArg(0) == "w" #] {
  				request basicrobot -m step : step(370)
  			} else {
  				forward basicrobot -m cmd : cmd($payloadArg(0))
  				delay 500	
  			}
  		}
  		[# 
  			val move = payloadArg(0)
  			itunibo.planner.plannerUtil.updateMap(move,"")
  		#]	
	}Goto updateCurrentWaiterPosDir if [# payloadArg(0) != "w" #] else waitStepDoneFail
	
	
	State walk{
		onMsg( movetoCell : movetoCell(X,Y) ){
			[# XT = payloadArg(0)
			   YT = payloadArg(1)			  
			 #]
			println("[PLANNER] MOVING to ($XT,$YT)")
			run itunibo.planner.plannerUtil.planForGoal("$XT","$YT")
		}
	}
	Goto execPlannedMoves
	
	
	State execPlannedMoves{ 
 		[#  CurrentPlannedMove = itunibo.planner.plannerUtil.getNextPlannedMove() #]
 		if [# CurrentPlannedMove.length > 0 # ]{
 			forward planner -m doMove : doMove($CurrentPlannedMove)
 		}else{
	     	println("[PLANNER] POINT ($XT,$YT) REACHED")
	     	replyTo movetoCell with atcell : atcell($XT,$YT) 			
 		}
 	}
 	Transition t0 whenMsg doMove  -> execTheMove
 				  whenRequest movetoCell and [# CurrentPlannedMove.length == 0 #]-> walk
 				  
 	State execTheMove{ 
  		onMsg( doMove : doMove(M) ){ 	
  			if [# payloadArg(0) == "w" #] {
  				request basicrobot -m step : step(370)
  			} else {
  				forward basicrobot -m cmd : cmd($payloadArg(0))
  				delay 500	
  			}
  		}
  		[# 
  			val move = payloadArg(0)
  			itunibo.planner.plannerUtil.updateMap(move,"")
  		#]		 			
 	 } 
     Goto updateCurrentWaiterPosDir if [# payloadArg(0) != "w" #] else waitStepDoneFail
     
     State waitStepDoneFail {
     } Transition t1 	whenReply stepdone -> updateCurrentWaiterPosDir
     					whenReply stepfail -> updateCurrentWaiterPosDir
     					
     State updateCurrentWaiterPosDir {
     	[# 
     		val X = itunibo.planner.plannerUtil.getPosX()
     		val Y = itunibo.planner.plannerUtil.getPosY()
     		val Direction = itunibo.planner.plannerUtil.getDirection()
     	#]
     	forward resourcemodel -m waiterCurrentPositionDirection : waiterCurrentPositionDirection($X,$Y,$Direction)
     }Goto execPlannedMoves if [# !SingleMove #] else s0
     
 }
 



QActor smartbell context ctxtearoom{  
	[#  
		var T     = 37.0
	#]   
	  
	State s0 initial {	     
 		discardMsg Off
 	} 
	Goto  waitingForClient  
	
	State waitingForClient{
		println("[SMARTBELL] Waiting for a new client...")
 	} 
	Transition t0 whenRequest notify      -> checkTemp

	State checkTemp{ 
		onMsg(notify : notify(T)) {
			[# T = payloadArg(0).toDouble() #]
	 		println("[SMARTBELL] Checking your temperature...")
	 		if[# T > 37.5 #]{
	 			println("[SMARTBELL] You should go to the hospital! ")
   				replyTo notify with tempResult : tempResult(no) 
	 		} else {
	 			println("[SMARTBELL] Your temperature is ok ")
   				replyTo notify with tempResult : tempResult(yes)
	 		}
 		}
 	}
 	Goto waitingForClient if [# T > 37.5 #] else waiterInfo

 	
 	State waiterInfo {  
 		println("[SMARTBELL] Checking table situation... ")
 		forward resourcemodel -m newClient : newClient(0)
 	}
    Transition t1 	whenEvent waitingTimeEvent -> informClient
    				
 	
 	State informClient{
 		onMsg(waitingTimeEvent : waitingTimeEvent(ID,X)){
  			if [# payloadArg(1).toDouble() == 0.0 	#] {
  				println("[SMARTBELL] A waiter is coming... ")
  				forward clientmanager -m accept : accept($payloadArg(0))
  			} else {
  				println("[SMARTBELL] You have to wait... ")
  				forward clientmanager -m inform : inform($payloadArg(0),$payloadArg(1))
  			}
  		}
 	}   
 	Goto waitingForClient 
 	
}

QActor barman context ctxtearoom{  
	
	[#var ID = ""#]
	  	  
	State s0 initial {	     
 		discardMsg Off
 	} 
	Goto  waitingForOrder 
	
	State waitingForOrder{
		println("[BARMAN] Waiting for events...")
 	} 
	Transition t0 whenEvent newOrderEvent -> makeTea
					whenEvent prepare -> teaReady

	State makeTea{ 
		onMsg(newOrderEvent : newOrderEvent(ID)) {
			[#ID = payloadArg(0)#]
	 		println("[BARMAN] Making some delicious tea...")
 		}
 	}
 	Goto waitingForOrder
 
 	State teaReady{   
 		onMsg(prepare : prepare(ID)) {
 			[# ID = payloadArg(0) #]
			println("[BARMAN] The order for client $ID is ready!")
   			forward resourcemodel -m ready : ready($ID)
   		}
  	}
	Goto waitingForOrder
		 	
} 

QActor clientmanager context ctxtearoom {
	[# 
		var tempResult = ""	
		var ID = ""
		var Temperature = 0.0
	#]
	
	State init initial {
		println("[CLIENT MANAGER] Client Manager STARTED")
		discardMsg Off
	}Goto waitingMsg
	
	State waitingMsg {
	}Transition t0  whenEvent newClient -> newClientState
					whenEvent nextState -> retrieveClientState
					whenMsg alarm -> handleAlarm
					//whenRequest take -> makeOrder
					//whenRequest collect -> pay
					//whenMsg serveDrink -> drink
	
	State handleAlarm {
		onMsg(alarm : alarm(ID)) {
			[# var ID = payloadArg(0) #]
			request resourcemodel -m clientStateReq : clientStateReq($ID)
		}
	}Transition t0 whenReply clientStateRep -> stayOrLeave
	
	State stayOrLeave {
		onMsg(clientStateRep : clientStateRep(ID, CurrentState)) {
			[# 
				var ID = payloadArg(0)
				var CurrentState = payloadArg(1) 
				var NextState = ""
				if(CurrentState == "waiting"){
					NextState = "gone"
					println("[CLIENT $ID] Bye!")
				 #] forward resourcemodel -m updateClientState : updateClientState($ID,$NextState) [#
				}
			#]
		}
	}Goto waitingMsg
					
	
	// newClient operazione atomica
	
	State newClientState {
		println("[CLIENT MANAGER] A new client is here!")
		[# if(Math.random() < 0.95) {
			Temperature = 36.0
		} else {
			Temperature = 39.0
		}#]
		request smartbell -m notify : notify($Temperature)
	}Transition t0 whenReply tempResult -> handleReply
	
	
	State handleReply {
		onMsg(tempResult : tempResult(RES)){
			[# tempResult = payloadArg(0) #]
		}
	}Goto waitToEnter if [# tempResult == "yes" #] else exit
	
	State waitToEnter {
	}Transition t1 	whenMsg inform -> wait
					whenMsg accept -> enter

	State wait {
		println("[POSSIBLE CLIENT] I have to wait")
		onMsg(inform : inform(ID,TIME)){
			[# var Time = payloadArg(1).toLong() 
				ID = payloadArg(0)
			#]
			forward timer -m startTimer : startTimer(clientmanager, alarm, $ID, $Time)
		}
	}Goto waitingMsg
	
	State enter {
		onMsg(accept : accept(ID)){
			[# 
				ID = payloadArg(0)
			#]
			//println("[CLIENT] Choosing a drink")
		}
	}Goto waitingMsg
	//Transition t0 whenEvent nextState -> askForWaiter
	
	// fine newClient
	
	State retrieveClientState {
		onMsg(nextState : nextState(ID)) {
			[# var ID = payloadArg(0) #]
			request resourcemodel -m clientStateReq : clientStateReq($ID)
		}
	}Transition t0 whenReply clientStateRep -> progressClientState
	
	State progressClientState {
		onMsg(clientStateRep : clientStateRep(ID, CurrentState)) {
			[# 
				var ID = payloadArg(0)
				var CurrentState = payloadArg(1) 
				var NextState = ""
				when(CurrentState) {
					"entering" -> {
						NextState = "ordering"
						println("[CLIENT $ID] I want to order!")
					}
					"ordering" -> {
						#] forward waiter -m order	: order($ID,tea) [#
						NextState = "waitingtea"
						println("[CLIENT $ID] A Na-tea-li please!")
					}
					"waitingtea" -> {
						NextState = "drinking"
						#] forward waiter -m takeDrink : takeDrink(0) [#
						println("[CLIENT $ID] Delicious tea!")
					}
					"drinking" -> {
						NextState = "paying"
						println("[CLIENT $ID] I want to pay!")
					}
					"paying" -> {
						#] forward waiter -m payment : payment($ID,10) [#
						NextState = "exiting"
						println("[CLIENT $ID] Exiting!")
					}
					"exiting" -> {
						NextState = "gone"
						println("[CLIENT $ID] Bye!")
					}
					"waiting" -> {
						NextState = "gone"
						println("[CLIENT $ID] Bye!")
					}
				}
			#]
			forward resourcemodel -m updateClientState : updateClientState($ID,$NextState)
			
		}
	}Goto waitingMsg
	//Transition t0 whenRequest take -> makeOrder
	/* 
	
	State askForWaiter{
		forward resourcemodel -m updateClientState : updateClientState($ID,ordering)
		//forward waiter -m readyToOrder : readyToOrder(1)
	}Goto waitingMsg
	//Transition t0 whenRequest take -> makeOrder
	*/
	State makeOrder {
		//println("[CLIENT] A Na-tea-li please")
		//replyTo take with order	: order(tea)
	}Transition t0 whenEvent nextState -> progressClientState
	//Transition t0 whenMsg serveDrink -> drink
	/*
	State drink {
		println("[CLIENT] *sip sip* Delicious tea")
	}Goto waitingMsg
	//Transition t0 whenEvent nextState -> askToPay
	
	State askToPay {
		println("[CLIENT] I want to pay")
		forward resourcemodel -m updateClientState : updateClientState($ID,paying)
		//forward waiter -m exitReq	: exitReq(1)
	}Goto waitingMsg
	//Transition t0 whenRequest collect -> pay
	*/
	State pay {
		//println("[CLIENT] Paying")
		//replyTo collect with payment : payment(10)
	}Transition t0 whenEvent nextState -> progressClientState
	
	State exit {
		println("[POSSIBLE CLIENT] Maybe next time. Bye!")
		//forward resourcemodel -m updateClientState : updateClientState($ID,exiting)
		//terminate 1
	}Goto waitingMsg
	
	
}

QActor timer context ctxtearoom {
	
	State s0 initial {
		discardMsg Off
	}Goto waitingRequests
	
	State waitingRequests{ println("[TIMER] Waiting for new requests")}
	Transition t0 whenMsg startTimer -> timer
	
	State timer {
		onMsg(startTimer : startTimer(A,M,P,T)) {
			[#
				var Actor = payloadArg(0)
				var Message = payloadArg(1)
				var Payload = payloadArg(2)
				var Time = payloadArg(3).toLong()
				println("$Actor $Message $Payload $Time")
				
				scope.launch {
					delay(Time)
					forward("$Message", "$Message($Payload)" ,"$Actor" )		
				} 
			#]
			
		}
	}Goto waitingRequests
}