with Text_IO;                   	use Text_IO;
with Ada.Text_IO, Ada.Integer_Text_IO;	use Ada.Text_IO, Ada.Integer_Text_IO;
with Ada.Float_Text_IO;			use Ada.Float_Text_IO;
with Ada.Text_IO.Unbounded_IO; 		use Ada.Text_IO.Unbounded_IO;
with Ada.Strings.Unbounded; 		use Ada.Strings.Unbounded;
with Systems;               		use Systems;
with Caches;                		use Caches;
with Cache_Set;             		use Cache_Set;
with CFG_Nodes; 			use CFG_Nodes.CFG_Nodes_Table_Package;
with CFG_Nodes;				use CFG_Nodes;
with CFG_Nodes_Builder; 		use CFG_Nodes_Builder;
with initialize_framework; 		use initialize_framework;
with CFG_Set;				use CFG_Set;
with CFG_Edges; 			use CFG_Edges;
with CFG_Node_Set; 			use CFG_Node_Set;
with CFG_Edge_Set;			use CFG_Edge_Set;
with unbounded_strings; 		use unbounded_strings;
with unbounded_strings; 		use unbounded_strings.strings_table_package;
with unbounded_strings;			use unbounded_strings.unbounded_string_list_package;
with Call_Framework; 			use Call_Framework;
with Integer_Arrays; 			use Integer_Arrays;
with Basic_Block_Analysis; 		use Basic_Block_Analysis;
with CFGs; 				use CFGs;
with CFG_Node_Set.Basic_Block_Set;	use CFG_Node_Set.Basic_Block_Set;
with Basic_Blocks; 			use Basic_Blocks;
with CFG_Nodes.Extended; 		use CFG_Nodes.Extended;
with Ada.Integer_Text_IO;       	use Ada.Integer_Text_IO;
with Call_Cache_Framework; 		use Call_Cache_Framework;
with Processor_Set; 			use Processor_Set;
with Scheduler_Interface; 		use Scheduler_Interface;
with Core_Units; 			use Core_Units;
with Address_Space_Set; 		use Address_Space_Set;
with Ada.IO_Exceptions;                 use Ada.IO_Exceptions;
with GNAT.Current_Exception;            use GNAT.Current_Exception;
with Text_IO;                           use Text_IO;
with Ada.Strings.Unbounded;             use Ada.Strings.Unbounded;
with unbounded_strings;                 use unbounded_strings;
use unbounded_strings.strings_table_package;
use unbounded_strings.unbounded_string_list_package;
with unbounded_strings;                 use unbounded_strings;
with Parameters;                        use Parameters;
with Parameters.extended;               use Parameters.extended;
use Parameters.Framework_Parameters_Table_Package;
with Systems;                           use Systems;
with Framework;                    	use Framework;
with Call_Framework;                    use Call_Framework;
with Call_Framework_Interface;          use Call_Framework_Interface;
use Call_Framework_Interface.Framework_Response_Package;
use Call_Framework_Interface.Framework_Request_Package;
with Call_Scheduling_Framework;         use Call_Scheduling_Framework;
with Multiprocessor_Services;           use Multiprocessor_Services;
with Multiprocessor_Services_Interface; use Multiprocessor_Services_Interface;
with Multiprocessor_Services_Interface;	use Multiprocessor_Services_Interface.Scheduling_Result_Per_Processor_Package;
with GNAT.Command_Line;
with GNAT.OS_Lib;                       use GNAT.OS_Lib;
with Version;                           use Version;
with Ada.Exceptions;                    use Ada.Exceptions;
with Time_Unit_Events;                  use Time_Unit_Events;
with Ada.Text_IO.Unbounded_IO; 		use Ada.Text_IO.Unbounded_IO;
with architecture_models; 		use architecture_models;
with Ada.Directories; 			use Ada.Directories;
with Scheduler;				use Scheduler;
with architecture_factory;              use architecture_factory;
with Debug;				use Debug;
with Scheduler.Fixed_Priority.Rm; 	use Scheduler.Fixed_Priority.Rm;
with Scheduler.Dynamic_Priority.Edf;	use Scheduler.Dynamic_Priority.Edf;
with Scheduler.Fixed_Priority.Hpf; 	use Scheduler.Fixed_Priority.Hpf;
with Framework_Config; 			use Framework_Config;
with Ada.Calendar; 			use Ada.Calendar;
with Ada.Calendar.Formatting;		use Ada.Calendar.Formatting;
with Cache_Utility; 			use Cache_Utility;
with Ada.Numerics;
with Ada.Numerics.Elementary_Functions;
with Ada.Numerics.Float_Random;
with Caches;				use Caches.Cache_Blocks_Table_Package;
with Cache_Block_Set;			use Cache_Block_Set;
with Scheduling_Analysis; 		use Scheduling_Analysis;
with Cache_Access_Profile_Set; 		use Cache_Access_Profile_Set;
with Time_Unit_Events;			use Time_Unit_Events.Time_Unit_Package;
with test_case_generator; 		use test_case_generator;
with scheduling_simulation_test; 	use scheduling_simulation_test;

package body feasibility_interval_test is

   procedure test_feasibility_interval
     (file_name                 : in Unbounded_String;
      N                		: in Integer	:= 5;
      PU 	       		: in Float	:= 0.70;
      CU 	       		: in Float	:= 2.0;
      CS       	       		: in Integer	:= 8;
      RF	       		: in Float	:= 0.3)
   is
      sys 		      : System;
      a_Sys                   : System;
      Project_File_Dir_List : unbounded_string_list;

      a_core : Core_Unit_Ptr;

      Result : Unbounded_String := empty_string;
      F: Ada.Text_IO.File_Type;

      i_iterator : Tasks_Iterator;
      j_iterator : Tasks_Iterator;
      j1_iterator : Tasks_Iterator;

      ipriority : Natural := 0;

      Sched : Scheduling_Table_Ptr;
      ETable : Scheduling_Sequence_Ptr;

      index_P : Natural := 0;

   begin
      Set_Initialize;
      generate_system_with_cache_and_CAP(file_name => file_name,
                                         N         => N,
                                         PU        => PU,
                                         CU        => CU,
                                         CS        => CS,
                                         RF        => RF,
                                         a_system  => sys);

      --Initilize the string
      Result := Result & file_name & ",";
      -----------------------------------------
      --
      -----------------------------------------
      Initialize(a_Sys);
      Systems.Read_From_Xml_File (a_Sys,
                                  Project_File_Dir_List,
                                  file_name);

      a_core := Search_core_unit(a_Sys.Core_units,To_Unbounded_String("Core_01"));
      a_core.scheduling.scheduler_type := Rate_Monotonic_Protocol;

      compute_scheduling_of_tasks_from_hardcoded_model(480,a_Sys, To_Unbounded_String("RM1.xml"), TRUE);

      --TODO: Integrate module Total CRPD computation + Number of preemption counter
      --Result := Result & a_Sys.Number_Of_Preemption'Img & "," & a_Sys.Total_CRPD'Img & ",";

      Read_From_Xml_File(Sched     => Sched,
                         Sys       => a_Sys,
                         File_Name => "RM1.xml");

      ETable := Sched.entries(0).data.result;

      --CHECK if the index is used to store the time unit or not.
      Put_Line(ETable.entries(0).item'Img);
      --CHECK ok :)

      --TODO: Consider to export cache state in event table as an option
      --        for i in 0..ETable.nb_entries-1 loop
      --
      --           if(ETable.entries(i).item >= 140 AND ETable.entries(i).item <= 260) then
      --              Put_line(ETable.entries(i).item'Img & " - " & ETable.entries(i).data.running_task.name);
      --
      --              index_P := ETable.entries(i).item + 120;
      --
      --              for j in 0..ETable.nb_entries-1 loop
      --                 if(ETable.entries(j).item = index_P) then
      --                    if(ETable.entries(i).data.running_task.name /= ETable.entries(j).data.running_task.name OR
      --                      ETable.entries(i).data.cache_state /= ETable.entries(j).data.cache_state) then
      --                       Put_Line("Different in cache state!");
      --                    else
      --                       Put_Line("No different in cache state");
      --                    end if;
      --                 end if;
      --              end loop;
      --           end if;
      --        end loop;

      -----------------------------------------
      -- WRITE FILE
      -----------------------------------------
      begin
         Open(F,Ada.Text_IO.Append_File,"result.txt");
      exception
         when Ada.IO_Exceptions.Name_Error =>
            Create(F,Ada.Text_IO.Out_File,"result.txt");
      end;

      Unbounded_IO.Put(F, result);
   end test_feasibility_interval;

end feasibility_interval_test;