RoomModel TrafficLight {

	import etrice.api.types.boolean
	import etrice.api.types.char
	import etrice.api.types.int32
	import etrice.api.timer.PTimer
	import etrice.api.tcp.PTcpPayload
	import etrice.api.tcp.PTcpControl
	import etrice.api.tcp.ATcpClient

	ActorClass TestApplication ["The TestApplication contains the PedestrianTrafficLightController and its test harness."] {
		Structure {
			ActorRef controller: PedestrianTrafficLightController
			ActorRef controllerTestHarness: TrafficLightControllerTestHarness
			Binding controllerTestHarness.fct and controller.fct
			Binding controller.tlInterface and controllerTestHarness.tlInterface
		}
		Behavior {
		}
	}

	ActorClass SingleTrafficLight ["OneTrafficLight contains the PedestrianTrafficLightController which is connected via a SocketClient Actor to the traffic light GUI."] {
		Structure {
			ActorRef controller: PedestrianTrafficLightController
			ActorRef headquarters1: TrafficLightHeadquarters
			ActorRef tcpClient: ATcpClient
			ActorRef ref0: TrafficLightInterface
			Binding headquarters1.controllers and controller.fct
			Binding ref0.ctrl and tcpClient.controlPort
			Binding ref0.payload and tcpClient.payloadPort
			Binding ref0.fct and controller.tlInterface
		}
		Behavior {
		}
	}

	ActorClass FlatReplication ["FlatReplication uses several replicated Actors in a row to control 2 traffic lights."] {
		Structure {
			ActorRef controller [2]: PedestrianTrafficLightController
			ActorRef headquarters1: TrafficLightHeadquarters
			ActorRef tlInterface [2]: TrafficLightInterface
			ActorRef tcpClient [2]: ATcpClient
			Binding headquarters1.controllers and controller.fct
			Binding controller.tlInterface and tlInterface.fct
			Binding tlInterface.ctrl and tcpClient.controlPort
			Binding tlInterface.payload and tcpClient.payloadPort
		}
		Behavior {
		}
	}

	ActorClass HierarchicalReplication ["HierarchicalReplication structural hierarchy to combine several actors and replicate them 'en bloc'. It controls 2 traffic lights."] {
		Structure {
			ActorRef controllerWithInfrastructure [2]: TrafficLightControllerWithInfrastructure ["This is replicated "]
			ActorRef headquarters2: TrafficLightHeadquarters
			Binding controllerWithInfrastructure.fct and headquarters2.controllers
		}
		Behavior {
		}
	}

	ActorClass TrafficLightControllerWithInfrastructure ["The TrafficLightControllerWithInfrastructure encapsulates the PedestrianTrafficLightController, the TrafficLightInterface and the SocketClient."] {
		Interface {
			Port fct: PTrafficLightController
		}
		Structure {
			ActorRef controller: PedestrianTrafficLightController
			ActorRef tlInterface: TrafficLightInterface
			ActorRef tcpClient: ATcpClient
			Binding controller.tlInterface and tlInterface.fct
			Binding fct and controller.fct
			Binding tlInterface.ctrl and tcpClient.controlPort
			Binding tlInterface.payload and tcpClient.payloadPort
		}
		Behavior {
		}
	}

	ActorClass TrafficLightControllerTestHarness [
	"Test harness for the TrafficLightController. It has the same ports, but conjugated. It can run test cases for the TrafficLightController by completely simulating its environment."
	] {
		Interface {
			conjugated Port fct: PTrafficLightController
			Port tlInterface: PTrafficLightInterface
		}
		Structure {
			external Port fct
			external Port tlInterface
			SAP to: PTimer
			Attribute counter: int32 ["FEATURE: Attribute of an ActorClass"]
		}
		Behavior {
			StateMachine {
				Transition init: initial -> SetStandby
				Transition tr0: SetStandby -> InStandby {
					triggers {
						<connect: tlInterface>
					}
					action '''
						counter=0;
						tlInterface.connected();'''
				}
				Transition tr1: InStandby -> SetStart {
					triggers {
						<setCarYellow: tlInterface guard '''++counter==5'''>
					}
				}
				Transition tr2: SetStart -> InRunning {
					triggers {
						<doneStart: fct>
					}
				}
				Transition tr3: InRunning -> CarGreen {
					triggers {
						<setCarGreen: tlInterface guard '''transitionData==1'''>
					}
				}
				Transition tr4: CarGreen -> PressButton {
					triggers {
						<timeout: to>
					}
				}
				Transition tr5: PressButton -> CarGreenAgain {
					triggers {
						<setCarGreen: tlInterface guard '''transitionData==1'''>
					}
				}
				Transition tr6: CarGreenAgain -> CarYellow {
					triggers {
						<setCarYellow: tlInterface guard '''transitionData==1'''>
					}
					action '''counter=0;'''
				}
				Transition tr7: CarYellow -> SetStop {
					triggers {
						<setPedRed: tlInterface guard '''++counter==5'''>
					}
				}
				Transition tr8: SetStop -> Done {
					triggers {
						<doneStop: fct>
					}
				}
				State SetStandby {
					entry '''fct.standby(0); // dummy port not used'''
				}
				State InStandby {
					entry '''printf("InStandby\n");'''
				}
				State SetStart {
					entry '''
						fct.start();
						printf("SetStart\n");'''
				}
				State InRunning {
					entry '''printf("InRunning\n");'''
				}
				State CarGreen {
					entry '''
						to.startTimeout(1*10);
						printf("CarGreen\n");'''
				}
				State PressButton {
					entry '''
						tlInterface.pressedRequestButton();
						printf("PressButton\n");'''
				}
				State CarGreenAgain {
					entry '''
						fct.standby(0); // dummy port
						printf("CarGreenAgain\n");'''
				}
				State CarYellow {
					entry '''printf("CarYellow\n");'''
				}
				State SetStop {
					entry '''
						fct.stop();
						printf("SetStop\n");'''
				}
				State Done {
					entry '''printf("Done\n");'''
				}
			}
		}
	}

	ActorClass PedestrianTrafficLightController [
	"Control of a traffic light at a pedestrian crossing with one car traffic light and one pedestrian traffic light." ] {
		Interface {
			Port fct: PTrafficLightController
			conjugated Port tlInterface: PTrafficLightInterface
		}
		Structure {
			external Port fct
			external Port tlInterface
			SAP to: PTimer
			Attribute timeBase: int32
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Stopped {
					action '''timeBase = 100;'''
				}
				Transition tr0: Stopped -> Connecting {
					triggers {
						<standby: fct>
					}
					action '''
						printf("ptlc: connecting to port %d\n", (int)transitionData);
						tlInterface.connect(transitionData);
					'''
				}
				Transition tr1: Standby -> tpStart of Running {
					triggers {
						<start: fct>
					}
				}
				Transition tr2: Running -> AllRedBeforeStandby {
					triggers {
						<standby: fct>
					}
				}
				Transition tr3: tpStandby of Running -> AllRedBeforeStandby
				Transition tr4: AllRedBeforeStandby -> tp0 of Standby {
					triggers {
						<timeout: to>
					}
				}
				Transition tr5: Standby -> Stopped {
					triggers {
						<stop: fct>
					}
				}
				Transition tr6: Connecting -> tp0 of Standby {
					triggers {
						<connected: tlInterface>
					}
				}
				State Stopped {
					entry '''
						tlInterface.setCarRed(0);
						tlInterface.setCarYellow(0);
						tlInterface.setCarGreen(0);
						tlInterface.setPedRed(0);
						tlInterface.setPedGreen(0);
						fct.doneStop();'''
				}
				State Standby {
					entry '''fct.doneStandby();'''
					subgraph {
						Transition tr0: my tp0 -> On
						Transition tr1: On -> Off {
							triggers {
								<timeout: to>
							}
						}
						Transition tr2: Off -> On {
							triggers {
								<timeout: to>
							}
						}
						EntryPoint tp0
						State On {
							entry '''
								// turn two lights on
								tlInterface.setCarYellow(1);
								tlInterface.setPedRed(1);
								
								// start timeout (fire once) for blinking
								// startTimer would start a cyclic timer
								to.startTimeout(5*timeBase);'''
							exit '''
								// TIP: turn off lights here in the exit code of state On instead of the entry code of state Off 
								// to make sure they are turned off if the superstate Standby is left by a group transition
								tlInterface.setCarYellow(0);
								tlInterface.setPedRed(0);
								
								// TIP: kill timer here to make sure it is killed if the state is left by a group transition or any other transition than a timeout
								// ALTERNATIVE: kill() could also be placed in the exit code of the superstate StandbyBlinking and so replacing the two calls in On:exit and Off:exit
								to.kill();'''
						}
						State Off {
							entry '''to.startTimeout(5*timeBase);'''
							exit '''to.kill();'''
						}
					}
				}
				State Running {
					entry '''fct.doneStart();'''
					exit '''to.kill();'''
					subgraph {
						Transition tr0: my tpStart -> AllRed
						Transition tr1: AllRed -> CarRedYellow {
							triggers {
								<timeout: to>
							}
						}
						Transition tr2: CarGreen -> CarYellow {
							triggers {
								<pressedRequestButton: tlInterface>
							}
						}
						Transition tr3: CarYellow -> CarRed {
							triggers {
								<timeout: to>
							}
						}
						Transition tr4: CarRed -> PedGreen {
							triggers {
								<timeout: to>
							}
						}
						Transition tr5: PedGreen -> AllRed {
							triggers {
								<timeout: to>
							}
						}
						Transition tr6: CarGreen -> CarYellowBeforeStandby {
							triggers {
								<standby: fct>
							}
						}
						Transition tr7: CarYellowBeforeStandby -> my tpStandby {
							triggers {
								<timeout: to>
							}
						}
						Transition tr8: CarRedYellow -> CarGreen {
							triggers {
								<timeout: to>
							}
						}
						EntryPoint tpStart
						ExitPoint tpStandby
						State AllRed {
							entry '''
								tlInterface.setCarRed(1);
								tlInterface.setPedRed(1);
								tlInterface.setPedGreen(0);
								
								to.startTimeout(10*timeBase);'''
						}
						State CarYellow {
							entry '''
								tlInterface.setCarGreen(0);
								tlInterface.setCarYellow(1);
								to.startTimeout(10*timeBase);'''
						}
						State CarGreen {
							entry '''
								tlInterface.setCarRed(0);
								tlInterface.setCarYellow(0);
								tlInterface.setCarGreen(1);'''
						}
						State CarRed {
							entry '''
								tlInterface.setCarYellow(0);
								tlInterface.setCarRed(1);
								to.startTimeout(10*timeBase);'''
						}
						State PedGreen {
							entry '''
								tlInterface.setPedRed(0);
								tlInterface.setPedGreen(1);
								to.startTimeout(20*timeBase);'''
						}
						State CarYellowBeforeStandby {
							entry '''
								tlInterface.setCarGreen(0);
								tlInterface.setCarYellow(1);
								to.startTimeout(10*timeBase);'''
						}
						State CarRedYellow {
							entry '''
								tlInterface.setCarYellow(1);
								to.startTimeout(10*timeBase);'''
						}
					}
				}
				State AllRedBeforeStandby {
					entry '''
						tlInterface.setCarRed(1);
						tlInterface.setPedRed(1);
						to.startTimeout(30*timeBase);'''
				}
				State Connecting
			}
		}
	}

	ActorClass TrafficLightInterface {
		Interface {
			Port fct: PTrafficLightInterface
			conjugated Port ctrl: PTcpControl
			conjugated Port payload: PTcpPayload
		}
		Structure {
			external Port fct
			external Port ctrl
			external Port payload
		}
		Behavior {
			Operation sendPayloadString(data: char ref) '''
				DTcpPayload package;
				DTcpPayload_setAsString(&package, data);
				payload.dataPackage(&package);'''
			Operation sendOnOffCommand(lightString: char ref, status: boolean) '''
				DTcpPayload package;
				strcpy(package.data, lightString);
				if (status==0){
					strcat(package.data, "=off\n");
				}
				else {
					strcat(package.data, "=on\n");
				}
				printf("package=%s", package.data);
				package.length = strlen(package.data);
				payload_dataPackage(&package);'''
			StateMachine {
				Transition init: initial -> Disconnected
				Transition tr0: Connected -> Connected {
					triggers {
						<setCarRed: fct>
					}
					action '''sendOnOffCommand("setCarLightRed", transitionData);'''
				}
				Transition tr1: Connecting -> Connected {
					triggers {
						<connected: ctrl>
					}
					action '''fct.connected();'''
				}
				Transition tr2: Disconnected -> Connecting {
					triggers {
						<connect: fct>
					}
					action '''
						printf("tli: connecting to port %d\n", (int)transitionData);
						DTcpControl config = {"localhost", transitionData};
						ctrl.connect(&config);'''
				}
				Transition tr3: Connected -> Connected {
					triggers {
						<setCarYellow: fct>
					}
					action '''sendOnOffCommand("setCarLightYellow", transitionData);'''
				}
				Transition tr4: Connected -> Connected {
					triggers {
						<setCarGreen: fct>
					}
					action '''sendOnOffCommand("setCarLightGreen", transitionData);'''
				}
				Transition tr5: Connected -> Connected {
					triggers {
						<setPedRed: fct>
					}
					action '''sendOnOffCommand("setPedLightRed", transitionData);'''
				}
				Transition tr6: Connected -> Connected {
					triggers {
						<setPedGreen: fct>
					}
					action '''sendOnOffCommand("setPedLightGreen", transitionData);'''
				}
				Transition tr7: Connected -> Connected {
					triggers {
						<dataPackage: payload>
					}
					action '''
						char *pressedRequestButtonString = {"pressedRequestButton\n"};
						int32 len = strlen(pressedRequestButtonString);
						if ( (transitionData->length == len) && memcmp(transitionData->data, "pressedRequestButton", len)){
							fct.pressedRequestButton();
						}'''
				}
				Transition tr8: Connected -> Connected {
					triggers {
						<setRequestButtonActive: fct>
					}
					action '''sendOnOffCommand("setRequestButtonActive", transitionData);'''
				}
				State Connecting
				State Connected
				State Disconnected
			}
		}
	}

	ActorClass TrafficLightInterfaceStub {
		Interface {
			Port fct: PTrafficLightInterface
		}
		Structure {
			external Port fct
			SAP to: PTimer
		}
		Behavior {
			StateMachine {
				Transition init: initial -> WaitingABit
				Transition tr0: WaitingABit -> PressButton {
					triggers {
						<timeout: to>
					}
				}
				State WaitingABit {
					entry '''to.startTimeout(80*10);'''
				}
				State PressButton {
					entry '''
						fct.pressedRequestButton();
					'''
				}
			}
		}
	}

	ActorClass TrafficLightHeadquarters {
		Interface {
			conjugated Port controllers [2]: PTrafficLightController
		}
		Structure {
			external Port controllers
			SAP to: PTimer
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Standby
				Transition tr0: Standby -> Running {
					triggers {
						<timeout: to>
					}
				}
				Transition tr1: Running -> Stopped {
					triggers {
						<timeout: to>
					}
				}
				State Standby {
					entry '''
						int n = PTrafficLightControllerReplPort_getReplication(&self->constData->controllers);
						int i;
						
						printf("hq: number of connections is %d\n", n);
						
						for (i=0; i<n; ++i)
							controllers[i].standby(4441+i);
						
						to.startTimeout(200*10);'''
				}
				State Running {
					entry '''
						controllers.start();
						to.startTimeout(200*10);'''
				}
				State Stopped {
					entry '''controllers.stop();'''
				}
			}
		}
	}

	ProtocolClass PTrafficLightController {
		incoming {
			Message standby(int32)
			Message start()
			Message stop()
		}
		outgoing {
			Message doneStandby()
			Message doneStart()
			Message doneStop()
		}
	}

	ProtocolClass PTrafficLightInterface {
		incoming {
			Message connect(int32)
			Message setCarRed(boolean)
			Message setCarYellow(boolean)
			Message setCarGreen(boolean)
			Message setPedRed(boolean)
			Message setPedGreen(boolean)
			Message setRequestButtonActive(boolean)
		}
		outgoing {
			Message connected()
			Message pressedRequestButton()
		}
	}
}