type Focus is view[focus_name : String, focus_params : sequence[String]];
type Filter is view[filter_name : String, val_min : any, val_max : any];
type Foci is sequense[Focus];
type Filters is sequense[Filter];
type PerceptionRequest is view[agent_id : String, foci : Foci, filters : Filters]; 
type SenseRequest is view[agent_id : String, foci : Foci];
type Representation is any;
type Action is view[agent_id : String, action_name : String, action_params : sequence[String]];
type Message is view[ID : Integer, sender : String, receiver : String, performative : String, content : String]; 
type KnowledgeItem is view[name : String, val : any]; 
type KnowledgeItems is sequense[KnowledgeItem]; 

value SituatedAgent is abstraction ()
{
	//external interfaces
	Sense_Request : Connection[SenseRequest];
	Sense_Result : Connection[Representation];
	Act : Connection[Action];
	Send_Receive : Connection[Message]];

	//exchanged data
	sense_request : SenseRequest;
	sense_result : Representation;
	action : Action
	message_in : Message; 
	message_out : Message;
	knowledge_item : KnowledgeItem;
	
	//connections among the components
	C_Request : Connection[PerceptionRequest];
	C_Read_Write : Connection[KnowledgeItem];
	C_Update : Connection[KnowledgeItems];

	//component composition
	compose
	{
		via Perception send Void where {
			C_Request renames Request,
			C_Read_Write renames Read_Write, 
			C_Update renames Update,
			Sense_Request renames Sense_Request, 
			Sense_Result renames Sense_Result};
	and
		via CurrentKnowledge send Void where {
			C_Read_Write renames Read_Write,
			C_Update renames Update};
	and
		via DecisionMaking send Void where {
			C_Request renames Request,
			C_Read_Write renames Read_Write, 
			Act renames Act};
	and
		via Communication send Void where {
			C_Request renames Request,
	 		C_Read_Write renames Read_Write, 
			Send_Receive renames Send_Receive};
	}
}

value Perception is abstraction ()
{
	Request : Connection[PerceptionRequest];
	Sense_Request : Connection[SenseRequest];
	Sense_Result : Connection[Representation];
	  
	Read_Write : Connection[KnowledgeItem];
	Update : Connection[sequence[KnowledgeItems];

	perception_request : PerceptionRequest;

	sense_request : SenseRequest;
	representation : any; 
	knowledge_items : KnowledgeItems; 

	choose
	{ 
		//perception request
		via Request receive perception_request;
		unobservable;
		via Sense_Request send sense_request;
	or
		//knowledge update 
		via Sense_Result receive representation;
		unobservable;
		via Update send knowledge_items;
	}
}

value CurrentKnowledge is abstraction ()
{
	Read_Write : Connection[KnowldgeItem];
	Update : Connection[KnowledgeItems];
	
	read_request : KnowledgeItem;
	read_item : KnowlegeItem; 
	write_item : KnowlegeItem; 
	update_items : KnowledgeItems; 
	
	replicate 
	{
		choose 
		{
			//read item
			via Read_Write receive read_request;
			unobservable;
			via Read_Write send read_item;
		or 
	  		//write item
			via Read_Write receive write_item;
			unobservable;
		or 
			//update items
			via Update receive update_items; 
			unobservable;
		}
	}
}

value DecisionMaking is abstraction ()
{
	Request : Connection[PerceptionRequest];
	Read_Write : Connection[KnowlegeItem];
	Act : Connection[Action];

	perception_request : PerceptionRequest; 
	knowledge_item : KnowledgeItem; 
	action : Action;

	replicate
	{ 
		unobservable; 
		via Act send action;
	}
}

value Communication is abstraction ()
{
	Request : Connection[PerceptionRequest];
	Read_Write : Connection[KnowledgeItem];
	Send_Receive : Connection[Message];

	perception_request : PerceptionRequest;
	knowledge_item : KnowledgeItem; 
	message_in : Message; 
	message_out : Message; 

	perception_request : PerceptionRequest;
	knowledge_item : KnowledgeItem; 
	action : Action; 

	replicate
	{ 
		choose 
		{
			unobservable;
			via Send_Receive receive message_in;
			unobservable;
		or 
			unobservable; 
			via Send_Receive send message_out;
			unobservable;
		}
	}
}