with Ada.Text_IO;           use Ada.Text_IO;
with Ada.Command_Line;      use Ada.Command_Line;
with Ada.Strings.Fixed;     use Ada.Strings.Fixed;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with GNAT.Os_Lib;

with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;

with Objects;                   use Objects;
with Memories;              use Memories;
use Memories.Memories_Table_Package;
with Memory_set;              use Memory_set;
with Tasks;              use Tasks;
with Task_Set;           use Task_Set;
with Systems;            use Systems;
with Processors;         use Processors;
with Processor_Set;      use Processor_Set;
with Address_Spaces;     use Address_Spaces;
with Address_Space_Set;  use Address_Space_Set;
with Buffers;     use Buffers; 
with Buffer_set;  use Buffer_set;
use Buffers.Buffer_Roles_Package;
with Queueing_Systems; use Queueing_Systems;
with Core_Units;         use Core_Units;
use Core_Units.Core_Units_Table_Package;
with batteries;          use batteries;
with battery_set;        use battery_set;
with Processor_Interface;      use Processor_Interface;
with Scheduler_Interface;      use Scheduler_Interface;

with Random_Tools;             use Random_Tools;
with architecture_factory;     use architecture_factory;
with unbounded_strings;        use unbounded_strings;
with call_framework;           use call_framework;
with feasibility_test.feasibility_interval;
use feasibility_test.feasibility_interval;
with doubles; use doubles;
with priority_assignment.rm;
use priority_assignment.rm;
with Ada.Numerics;
with Ada.Numerics.Float_Random;

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

with ipc_analysis; use ipc_analysis;


procedure Schedule_Icq is

	sys                  	: System;
	
	my_iterator 		: core_units_iterator;
	a_core_unit 		: core_unit_ptr;
	a_core_unit_table	: core_units_set;
	
	my_buffer_iterator 	: buffers_iterator;
	a_buffer		: buffer_ptr;
	
	max_ICL		: Integer;
	min_ICL		: Integer;
	
	disp_WCRT		: Integer;
	disp_BCRT		: Integer;

	output_file_name	: Unbounded_String;
	output_file 		: File_Type;
	
begin

	if Argument_Count < 1 then
		Put ("Usage: " & Command_Name & " ");
		Put_Line ("system_cheddar_File");
		GNAT.OS_Lib.OS_Exit (1);
	end if;

	Call_Framework.initialize (False);

	read_from_xml_File(sys, Argument(1));
	
	output_file_name := To_Unbounded_String(Argument(1)(1 .. Argument(1)'Length - 6));
	Create(output_file, OUt_File, To_String(output_file_name & "_result.txt"));

	

	if not is_empty (sys.core_units) then
	
		reset_iterator (sys.core_units, my_iterator);
		loop
		current_element (sys.core_units, a_core_unit, my_iterator);

			disp_WCRT := compute_core_dispatcher_worst_case_response_time(sys, a_core_unit.name);
			disp_BCRT := compute_core_dispatcher_best_case_response_time(sys, a_core_unit.name);
			
			Put_Line(output_file, "Dispatcher " & To_String(a_core_unit.name) & " WCRT: " & disp_WCRT'Image); 
			Put_Line(output_file, "Dispatcher " & To_String(a_core_unit.name) & " BCRT: " & disp_BCRT'Image); 

		exit when is_last_element (sys.core_units, my_iterator);
		next_element (sys.core_units, my_iterator);
		end loop;

	end if;
	
	

	
	
	if not is_empty (sys.Buffers) then
	
		reset_iterator (sys.Buffers, my_buffer_iterator);
		loop
		current_element(sys.Buffers, a_buffer, my_buffer_iterator);
		
			declare
			
				IndexB  	: Natural := Index(To_String(a_buffer.name), "B");
				sender_name 	:  Unbounded_String;
				receiver_name 	:  Unbounded_String;
			begin
			
				sender_name 	:= To_Unbounded_String(To_String(a_buffer.name)(1 .. IndexB - 1));
      				receiver_name 	:= To_Unbounded_String(To_String(a_buffer.name)(IndexB + 1 .. To_String(a_buffer.name)'Last));
				
				max_ICL := compute_tasks_max_intercore_communication_latency(sys, sender_name , receiver_name);
		
				min_ICL := compute_tasks_min_intercore_communication_latency(sys, sender_name , receiver_name);
				
				Put_Line(output_file, "Worst intercore communication latency " & To_String(sender_name) & "->" & To_String(receiver_name) & ": " & max_ICL'Image); 
				Put_Line(output_file, "Best intercore communication latency " & To_String(sender_name) & "->" & To_String(receiver_name) & ": " & min_ICL'Image); 

			end;
		exit when is_last_element (sys.Buffers, my_buffer_iterator);
		next_element (sys.Buffers, my_buffer_iterator);
		end loop;
	
	end if;

	close(output_file);

end Schedule_Icq;