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)
Reply order : order(X)
Dispatch orderReq : orderReq(X) 

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

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

//interazione pagamento client
Request  collect : collect(X) 
Reply    payment : payment(X)

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


//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)

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




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 = ""
	#]
	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
	
	State informChanges{

		onMsg(newClient : newClient(X)) {
			println("[RESOURCE MODEL] New Client")
			solve(newClient(ID))
			[#
				val 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")
				solve(replaceRule(waiter(_),waiter(reachEntranceDoor)))
				emit waitingTimeEvent : waitingTimeEvent($ID,0)
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(reachEntranceDoor,$TeatableNumber)
	 		} else {
	 			println("[RESOURCE MODEL] All tables is busy")
				emit waitingTimeEvent : waitingTimeEvent(5000) //maxstaytime
		 	}		
		}
		onMsg(updateClientState : updateClientState(ID,R)){
			[#
				val ID = payloadArg(0)
				val R = payloadArg(1)
				when(R) {
					"ordering" -> {#]
						solve(replaceRule(client($ID,_),client($ID,ordering)))
						solve(replaceRule(waiter(_),waiter(takingOrder)))
						solve(teatableClientID(TeatableNumber,$ID))
						[# TeatableNumber = getCurSol("TeatableNumber").toString() #]
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(takingOrder,$TeatableNumber)
					[#}
					"paying" -> {#]
						solve(replaceRule(client($ID,_),client($ID,paying)))
						solve(replaceRule(waiter(_),waiter(collectingPayment)))
						emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingPayment,0)
					[#}
					"exiting" -> {#]
						solve(replaceRule(client($ID,_),client($ID,exiting)))
						solve(roomstate( waiter(S),currentWaiterPosDir(Y,X,D) , stateOfTeatables(T1,T2), servicedesk(SD), getClientsState(CS), teaServed(TS), totalNumberOfClients(NC), clientsInTheRoom(CR)))
						[# 	
							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 CS = getCurSol("CS").toString()
							val TS = getCurSol("TS").toString()
							val NC = getCurSol("NC").toString()
							val CR = getCurSol("CR").toString()
							
							
							val JsonState : String = itunibo.formatter.formatterUtil.formatJson(S,X,Y,D,T1,T2,SD,CS,TS,NC,CR)
						#]
						updateResource [# JsonState #]
						solve(exitClient($ID))
					[#}
				}
			#]
		}
		onMsg(orderReq : orderReq(ID)){
			[# val ID = payloadArg(0)#]
			println("[RESOURCE MODEL] New order for client $ID")
			solve(replaceRule(servicedesk(_),servicedesk(preparing($ID))))
			emit newOrderEvent : newOrderEvent($ID)
		}
		onMsg(ready : ready(ID)){
			[# val ID = payloadArg(0)#]
			println("[RESOURCE MODEL] Order is ready for client $ID")
			solve(replaceRule(servicedesk(_),servicedesk(ready($ID))))
			solve(teatableClientID(TeatableNumber,$ID))
			[# TeatableNumber = getCurSol("TeatableNumber").toString() #]
			solve(replaceRule(waiter(_),waiter(collectingDrink)))
			emit waiterTaskChangedEvent : waiterTaskChangedEvent(collectingDrink,$TeatableNumber)
		}
		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)) {
			[# val Task = payloadArg(0) #]
			[# when(Task) {
				"reachEntranceDoor" ->  { #]
				solve(replaceRule(waiter(_),waiter(convoyTable)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(convoyTable,0)
			[# } 
				"convoyTable" ->  {
			#] 
				solve(replaceRule(waiter(_),waiter(returnHome)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				
			[# } 
				"returnHome" ->  {
			#] 
				solve(replaceRule(waiter(_),waiter(athome)))
				solve(teatable(TeatableNumber,dirty))
				ifSolved {
					solve(replaceRule(waiter(_),waiter(sanitizing)))
					emit waiterTaskChangedEvent : waiterTaskChangedEvent(sanitizing,$TeatableNumber)
				}

			[# } 
				"takingOrder" ->  {
			#] 
				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(replaceRule(waiter(_),waiter(returnHome)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
				solve(serveTea)
			[# } 
				"collectingPayment" ->  {
			#] 
				solve(replaceRule(teatable(1,_), teatable(1,dirty)))
				solve(replaceRule(waiter(_),waiter(convoyExit)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(convoyExit,0)
			[# } 
				"convoyExit" ->  {
			#] 
				//solve(exitClient)
				solve(replaceRule(waiter(_),waiter(returnHome)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,0)
			[# } 
				"sanitizing" ->  {
			#]  
				[#
				TeatableNumber = payloadArg(1)
				#]
				solve(replaceRule(teatable($TeatableNumber,_),teatable($TeatableNumber,available)))
				solve(replaceRule(waiter(_),waiter(returnHome)))
				emit waiterTaskChangedEvent : waiterTaskChangedEvent(returnHome,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)
					[#}
				}
			#]
		}

		solve(roomstate( waiter(S),currentWaiterPosDir(Y,X,D) , stateOfTeatables(T1,T2), servicedesk(SD), getClientsState(CS), teaServed(TS), totalNumberOfClients(NC), clientsInTheRoom(CR)))
		[# 	
			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 CS = getCurSol("CS").toString()
			val TS = getCurSol("TS").toString()
			val NC = getCurSol("NC").toString()
			val CR = getCurSol("CR").toString()
			
			
			val JsonState : String = itunibo.formatter.formatterUtil.formatJson(S,X,Y,D,T1,T2,SD,CS,TS,NC,CR)
		#]
		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
}

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)
				[#}
 			}#]
 		}
 	}Goto reqHandler 
	
	State takingOrder {
		delay 5000
		request clientsimulator -m take : take(1) 
	}Transition t0 whenReply order -> clientReady
	
	State clientReady {
		forward resourcemodel -m orderReq : orderReq( 1 )
		println("[WAITER] I'm transmitting the order to the barman")
		forward resourcemodel -m taskDone : taskDone($WhatImDoing,0)
	} 
	Goto reqHandler
	
	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 clientsimulator -m collect : collect(1)
	}
	Transition t0 whenReply payment -> handlePayment
	
	State handlePayment {
		delay 5000
		onMsg(payment : payment( MONEY )){
			[# println("[WAITER] " + payloadArg(0) + " EUR collected! Have a nice day!") #]
		}
		forward resourcemodel -m taskDone : taskDone($WhatImDoing,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 serveDrink : serveDrink(A)
			[# } 
				"collectingPayment" ->  {
			#] 
				forward waiter -m pay : pay(A)
			[# } 
				"sanitizing" ->  {
			#]  
				forward waiter -m cleanTable : cleanTable($TeatableNumber)
			[#}
				else -> {
			#]
				forward waiter -m listenRequests : listenRequests(1)
				forward resourcemodel -m taskDone : taskDone($WhatImDoing,0)
			[#}
			}#]
		}
	}	Transition t1 	whenMsg moveTo -> movementHelper  
						whenMsg readyToTakeOrder -> takingOrder
						whenMsg serveDrink -> servingDrinkToClient
						whenMsg pay -> payment
						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 temperature     = 37
	#]   
	  
	State s0 initial {	     
 		discardMsg Off
 	} 
	Goto  waitingForClient  
	
	State waitingForClient{
		println("[SMARTBELL] Waiting for a new client...")
 	} 
	Transition t0 whenRequest notify      -> checkTemp

	State checkTemp{ 
 		println("[SMARTBELL] Checking your temperature...")
 		/*[# 
 			val randomNumber = Math.random()
 			if  (randomNumber >= 0.7)
 				temperature = 39.0
 			else
 				temperature = 37.0		
 		#]*/
 	}
 	Goto badTemp if [# temperature > 37.5 #] else goodTemp
 
 	State badTemp{   
		println("[SMARTBELL] You should go to the hospital! ")
   		replyTo notify with tempResult : tempResult(no)
  	}
	Goto waitingForClient
	
	State goodTemp{   
		println("[SMARTBELL] Your temperature is ok ")
   		replyTo notify with tempResult : tempResult(yes)
  	}
	Goto 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 clientsimulator -m accept : accept($payloadArg(0))
  			} else {
  				println("[SMARTBELL] You have to wait... ")
  				forward clientsimulator -m inform : inform($payloadArg(0),$payloadArg(1))
  			}
  		}
 	}   
 	Goto waitingForClient 
 	
}

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

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

QActor clientsimulator context ctxtearoom {
	[# 
		var tempResult = "no"	
		var ID = ""
	#]
	State init initial {
		println("[CLIENT] Client STARTED")
		discardMsg Off
	}Transition t0  whenEvent newClient -> askToEnter
	
	State askToEnter {
		println("[CLIENT] Knock Knock, I'm here")
		request smartbell -m notify : notify
	}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("[CLIENT] I have to wait")
		onMsg(inform : inform(ID,TIME)){
			[# var Time = payloadArg(1).toLong() 
				ID = payloadArg(0)
			#]
			delayVar Time
		}
	}Goto enter
	
	State enter {
		onMsg(accept : accept(ID)){
			[# 
				ID = payloadArg(0)
			#]
			println("[CLIENT] Choosing a drink")
		}
	}Transition t0 whenEvent nextState -> askForWaiter
	
	State askForWaiter{
		forward resourcemodel -m updateClientState : updateClientState($ID,ordering)
		//forward waiter -m readyToOrder : readyToOrder(1)
	}Transition t0 whenRequest take -> makeOrder
	
	State makeOrder {
		println("[CLIENT] A Na-tea-li please")
		replyTo take with order	: order(tea)
	}
	Transition t0 whenMsg serveDrink -> drink
	
	State drink {
		println("[CLIENT] *sip sip* Delicious tea")
	}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)
	}Transition t0 whenRequest collect -> pay
	
	State pay {
		println("[CLIENT] Paying")
		replyTo collect with payment : payment(10)
	}Transition t0 whenEvent nextState -> exit
	
	State exit {
		println("[CLIENT] Client EXIT Byeeee!")
		forward resourcemodel -m updateClientState : updateClientState($ID,exiting)
		terminate 1
	}
	
}