System /*-trace*/ waiter

//interazione ingresso client
Request  checkAvail : checkAvail(X) 
Reply    waitingTime : waitingTime(X)
Request  tabStatus : tabStatus(X) 
Reply    tabState : tabState(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)


//interazione col planner
Dispatch doMove     : doMove(V)
Request moveTo : moveTo(X)
Dispatch  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 di spostamento
Dispatch convoyTable : convoyTable(X)
Dispatch returnHome : returnHome(X)
Dispatch readyToTakeOrder : readyToTakeOrder(X)
Dispatch listenRequests : listenRequests(X)
Dispatch goTable1 : goTable1(X)
Dispatch pay : pay(X)


Context ctxwaiter ip [ host= "localhost"   port= 8010 ] 


Context ctxsmartbell ip [ host= "127.0.0.1"   port= 8040 ] 
Context ctxbarman ip [ host= "127.0.0.1"   port= 8050 ] 
Context ctxclientsimulator ip [ host= "127.0.0.1"   port= 8060 ] 
Context ctxbasicrobot ip [ host= "127.0.0.1" port= 8070]

ExternalQActor smartbell context ctxsmartbell
ExternalQActor barman context ctxbarman
ExternalQActor clientsimulator context ctxclientsimulator
ExternalQActor basicrobot context ctxbasicrobot



QActor waiter context ctxwaiter{ 
	
	State s0 initial{ 
		println("[WAITER] waiter is starting..I'm HOME!") 
		solve( consult("sysRules.pl")	 ) 
		solve(consult("tearoomkb.pl"))	
		delay 1000
		discardMsg Off
	} 
	Goto reqHandler
	
 	State reqHandler{
 		println("[WAITER] Waiting for a request!")
 	}
 	Transition t0 
 		whenRequest checkAvail -> checkTableState		
 		whenMsg readyToOrder -> reachingClientToTakeOrder 
 		whenMsg ready -> collectingDrink 
 		whenMsg exitReq -> exitClient 
 	
 	State checkTableState {	
 		println("[WAITER] Checking table state")
 		replyTo checkAvail with waitingTime : waitingTime(0)
	}
	Goto reachEntranceDoor
	
	State reachEntranceDoor {
		solve(replaceRule(whatImDoing(_),whatImDoing(reach)))
	}Goto goingToEntranceDoor
	
	
	State reachingClientToTakeOrder{
		println("[WAITER] I'm collecting the order from the client")
		solve(replaceRule(whatImDoing(_),whatImDoing(takingOrder)))	
	}Goto goingToTable1 
	
	State takingOrder {
		request clientsimulator -m take : take(1) 
	}Transition t0 whenReply order -> clientReady
	
	State clientReady {
		onMsg( order : order( ORDER ) ){
			forward barman -m orderReq : orderReq( $payloadArg(0) )
		}
		println("[WAITER] I'm transmitting the order to the barman")
	} 
	Goto returnToHome
	
	State collectingDrink {	
		solve(replaceRule(whatImDoing(_),whatImDoing(collectingDrink))) 
	}Goto goingToBarman
	
	State servingDrinkToClient {
		println("[WAITER] Serving the drink")
		forward clientsimulator -m serveDrink : serveDrink(tea)
	}
	Goto returnToHome
	
	State exitClient{
		println("[WAITER] Client requested to exit! Proceeding to the payment")
		solve(replaceRule(whatImDoing(_),whatImDoing(exitClient)))
	}
	Goto goingToTable1
	
	State payment{
		println("[WAITER] Collecting the money!")
		request clientsimulator -m collect : collect(1)
	}
	Transition t0 whenReply payment -> handlePayment
	
	State handlePayment {
		onMsg(payment : payment( MONEY )){
			[# println("[WAITER] " + payloadArg(0) + " EUR collected! Have a nice day!") #]
		}
		solve(replaceRule(whatImDoing(_),whatImDoing(convoyExit)))
	}
	Goto goingToExitDoor
	
	
	// Stati legati al movimento
	
	State goingToEntranceDoor {	
		request planner -m moveTo : moveTo(entrancedoor)
	}Transition t1 whenReply atcell -> handleAtCell
	
	State goingToExitDoor {
		request planner -m moveTo : moveTo(exitdoor)
	}Transition t1 whenReply atcell -> handleAtCell
	
	State goingToBarman {
		request planner -m moveTo : moveTo(barman)
	}Transition t1 whenReply atcell -> handleAtCell
	
	State goingToTable1 {
		request planner -m moveTo : moveTo(teatable1)
	}Transition t1 whenReply atcell -> handleAtCell
	
	State goingToTable2 {
		request planner -m moveTo : moveTo(teatable2)
	}Transition t1 whenReply atcell -> handleAtCell
	
	
	// ora non si puņ interrompere 
	State returnToHome {
		solve(replaceRule(whatImDoing(_),whatImDoing(returnHome)))
		request planner -m moveTo : moveTo(home)
	}Transition t1 whenReply atcell -> handleAtCell
	
	State handleAtCell {
		solve(whatImDoing(Z))
		[# val WhatImDoing = getCurSol("Z").toString() #]
		onMsg(atcell : atcell(X,Y)){
			if [# WhatImDoing == "reach" #] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(convoyTable)))
				forward waiter -m convoyTable : convoyTable(A)
			} 
			if [# WhatImDoing == "convoyTable" #] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(returnHome)))
				forward waiter -m returnHome : returnHome(A)
			}
			if [# WhatImDoing == "returnHome" #] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(nothing)))
				forward waiter -m listenRequests : listenRequests(A)
			}
			if [# WhatImDoing == "takingOrder"#] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(take)))
				forward waiter -m readyToTakeOrder : readyToTakeOrder(A)
			}
			if [# WhatImDoing == "collectingDrink"#] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(bringingDrinkToClient)))
				forward waiter -m goTable1 : goTable1(A)
			}
			if [# WhatImDoing == "bringingDrinkToClient" #] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(servingDrinkToClient)))
				forward waiter -m serveDrink : serveDrink(A)
			}
			if [# WhatImDoing == "exitClient" #] {
				delay 5000
				forward waiter -m pay : pay(A)
			}
			if [# WhatImDoing == "convoyExit" #] {
				delay 5000
				solve(replaceRule(whatImDoing(_),whatImDoing(returnHome)))
				forward waiter -m returnHome : returnHome(A)
			} 
			
		}
	}	Transition t1 	whenMsg convoyTable -> goingToTable1  
						whenMsg returnHome -> returnToHome
						whenMsg readyToTakeOrder -> takingOrder
						whenMsg serveDrink -> servingDrinkToClient
						whenMsg listenRequests -> reqHandler
						whenMsg goTable1 -> goingToTable1
						whenMsg pay -> payment
	
}



/*
 * excutes a plan without 'interruption'
 */
QActor planner context ctxwaiter{  
[#
	var XT = "0"
	var YT = "0"
	var CurrentPlannedMove = ""
	var StepTime    	   = 100L
#]
	State s0 initial {	     
		//println("&&&  insensitivewalker STARTED")
		run itunibo.planner.plannerUtil.initAI()
		run itunibo.planner.plannerUtil.loadRoomMap( "teaRoomExplored" )
		solve( consult("sysRules.pl")	 ) 
		solve(consult("tearoomkb.pl"))	
		discardMsg Off
	}	
	Transition t0 whenRequest moveTo -> findTheCell
	
	State findTheCell {
		onMsg (moveTo : moveTo(A)) {
			[# var Spot = payloadArg(0) #]
			solve(pos($Spot,X,Y))
			[# 
			val X = getCurSol("X") 
		  	val Y = getCurSol("Y") 
			#]
			forward planner -m movetoCell : movetoCell($X,$Y)
		}
	}Transition t0 whenMsg movetoCell -> walk
	
	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 moveTo with atcell : atcell($XT,$YT) 			
 		}
 	}
 	Transition t0 whenMsg doMove  -> execTheMove
 				  whenRequest moveTo and [# CurrentPlannedMove.length == 0 #]-> findTheCell
 				  
 	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 execPlannedMoves if [# payloadArg(0) != "w" #] else waitStepDoneFail
     
     State waitStepDoneFail {
     } Transition t1 	whenReply stepdone -> updateCurrentPos
     					whenReply stepfail -> updateCurrentPos
     					
     State updateCurrentPos {
     	[# 
     		val X = itunibo.planner.plannerUtil.getPosX()
     		val Y = itunibo.planner.plannerUtil.getPosY()
     	#]
     	solve(replaceRule(currentPos(_,_), currentPos($X,$Y)))
     }Goto execPlannedMoves
     
 }