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 Systems;                   use Systems;
with Call_Scheduling_Framework; use Call_Scheduling_Framework;
with Multiprocessor_Services;   use Multiprocessor_Services;
with Multiprocessor_Services_interface;   use Multiprocessor_Services_interface;
use Multiprocessor_Services_interface.Scheduling_Result_Per_Processor_package;
with Ada.Exceptions;            use Ada.Exceptions;
with scheduler_interface; use scheduler_interface;
with Processor_Set;             use Processor_Set;
use Processor_Set.Generic_Processor_Set;
with ProcessorS;             use ProcessorS;
with Processor_interface;             use Processor_interface;
with caches;
use caches;
use caches.Caches_Table_Package;
with Parameters;                use Parameters;
with Parameters.extended;       use Parameters.extended;
use Parameters.Framework_Parameters_Table_Package;
with tasks; use tasks;
with Task_Set;                  use Task_Set;
use Task_Set.Generic_Task_Set;
with Resources;             use Resources;
with resource_Set;                  use resource_Set;
use resource_Set.Generic_resource_Set;
with address_space_Set;                  use address_space_Set;
use address_space_Set.Generic_address_space_Set;
with offsets;
use offsets;
use offsets.offsets_table_package;
with buffer_set;use buffer_set;
with buffers; use buffers;
use buffers.buffer_roles_package;
with queueing_systems; use queueing_systems;
with message_set; use message_set;
with messages;
use messages;
with task_dependencies; use task_dependencies;
with dependencies; use dependencies;
with objects;use objects;
use objects.Generic_Object_Set_Package;
with deployment_set; use deployment_set;
with deployments; use deployments;
use deployment_set.Generic_deployment_Set;
with framework_config; use framework_config;
with Ada.Numerics.Aux;          use Ada.Numerics.Aux;
with Ada.Numerics.Float_Random; use Ada.Numerics.Float_Random;

package body hierarchical_analysis_methods_temporary is


   function compute_partition_internal_busy_period 
	(deployment	: in Generic_deployment_Ptr;
	 priority : priority_range;
	 window : Double;
	 bounded_tasks	: in boolean)
	return 		Double
   is
	Iterator	: Generic_Object_Set_Package.Iterator;
	Taskj		: Generic_Object_Ptr;
	Li_w		: Double;
   begin
	reset_iterator (deployment.consumer_entities, Iterator);
	Li_w := 0.0;
   loop
            current_element (deployment.consumer_entities, Taskj, Iterator);
            -- If Taskj is in hp(Taski)
            if (Periodic_Task_Ptr(Taskj).priority < priority) then
		if (bounded_tasks) then
               		Li_w := Li_w +
                         Double'Ceiling
                            (window /
                             Double (Periodic_Task_Ptr (Taskj).period)) *
                         Double (Periodic_Task_Ptr (Taskj).capacity);
		else
			Li_w := Li_w +
                         Double'Ceiling
                            ((window + (Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).period))  
				- (Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).capacity)))/
                             Double (Periodic_Task_Ptr (Taskj).period)) *
                         Double (Periodic_Task_Ptr (Taskj).capacity);
		
		end if;
	    -- Add the capacity of the concerned task
	    else if (Periodic_Task_Ptr(Taskj).priority = priority) then 
			Li_w := Li_w + Double(Periodic_Task_Ptr(Taskj).capacity);
		end if;
            end if;
            -- exit loop when there is no more task
            exit when is_last_element (deployment.consumer_entities, Iterator);
            next_element (deployment.consumer_entities, Iterator);
      
    end loop;
   return Li_w;
  end compute_partition_internal_busy_period;


  function compute_partition_internal_gaps 
	(deployment	: in Generic_deployment_Ptr;
	 priority : priority_range;
	 window : Double;
	 bounded_tasks	: in boolean)
	return 		Double
   is
	gap		: Double;
	gap2		: Double;
	gap3		: Double;
	gap4		: Double;
   begin
           gap := (Double'Ceiling(compute_partition_internal_busy_period(deployment, priority, window, bounded_tasks)/
			(Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).capacity))) -1.0)
			*((Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).period))  
				- (Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).capacity)));


	gap2 :=(Double'Ceiling(compute_partition_internal_busy_period(deployment, priority, window, bounded_tasks)/
			(Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).capacity))) -1.0);
	gap3 :=((Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).period))  
				- (Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).capacity)));
	gap4 :=	(Double(Periodic_Task_Ptr(get_random_element(deployment.resource_entities)).period));

	Put_line("Gap Internal L(w)" & (Double'Ceiling(compute_partition_internal_busy_period(deployment, priority, window, bounded_tasks))'IMG));
	Put_line("Gap Internal Cs" & (gap2'IMG));
	Put_line("Gap Internal Ts-Cs" & (gap3'IMG));
	Put_line("Gap Internal Ts" & (gap4'IMG));
	Put_line("**************************************************************");
put(deployment.resource_entities);
	Put_line("**************************************************************");
	Put_line("**************************************************************");
put(deployment.consumer_entities);
	Put_line("**************************************************************");
   return gap;

  end compute_partition_internal_gaps;

  function Max (d1 : Double; d2 : Double) return double is begin if d1>d2 then return d1; else return d2; end if; end Max;

  function compute_server_interference  
	(My_deployments	: in deployments_Set;
	 Taski_Ptr 	: Generic_Task_Ptr;
	 window 	: Double;
	 bounded_tasks	: in boolean)
	return 		Double
  is
	ServerS		: Periodic_Task_Ptr;
	ServerX		: Generic_Object_Ptr;
	deploymentS	: Generic_deployment_Ptr;
	deploymentGlobal 	: Generic_deployment_Ptr;
	Iterator	: Generic_Object_Set_Package.Iterator;
	Taskj		: Generic_Object_Ptr;
	I	 	: Double;
  begin
	I := 0.0;
	deploymentGlobal := Search_deployment_By_Processor_Name(My_deployments,Taski_Ptr.Cpu_Name);
	deploymentS := Search_deployment_By_Consumer_Task_Name(My_deployments, Taski_Ptr.Name);
	ServerS := (Periodic_Task_Ptr(get_random_element(deploymentS.resource_entities)));
	reset_iterator (deploymentGlobal.consumer_entities, Iterator);
  loop
 	current_element (deploymentGlobal.consumer_entities, ServerX, Iterator);

	-- If ServerX is in hp(ServerS)
	if (Periodic_Task_Ptr(ServerX).priority < ServerS.priority) then
		I:= I + (Double'Ceiling((
		Max(0.0,
		window -(Double'Ceiling(compute_partition_internal_busy_period(deploymentS, Taski_Ptr.priority, window, bounded_tasks)/(Double(ServerS.capacity)))-1.0)*(Double(ServerS.period))
		)--end of max
		+(Double(Periodic_Task_Ptr(ServerX).jitter)))
		/ (Double(Periodic_Task_Ptr(ServerX).period))
		)--end of first Ceiling 
		)
		*(Double(Periodic_Task_Ptr(ServerX).capacity));
	end if;
            next_element (deploymentGlobal.consumer_entities, Iterator);
   exit when is_last_element (deploymentGlobal.consumer_entities, Iterator);

  end loop;

  return I;
  end compute_server_interference;


  function compute_wcrt  
	(My_sys		: in System;
	 Taski_Ptr 	: Generic_Task_Ptr;
	 bounded_tasks	: in boolean)
	return 		Double 
  is
	deploymentS	: Generic_deployment_Ptr;
	window,window_plus_one : Double;
	ServerS		: Periodic_Task_Ptr;
  begin 
	deploymentS := Search_deployment_By_Consumer_Task_Name(My_sys.deployments, Taski_Ptr.Name);
	ServerS := (Periodic_Task_Ptr(get_random_element(deploymentS.resource_entities)));
	window := Double(Taski_Ptr.capacity) + (Double'Ceiling(Double(Taski_Ptr.capacity)/Double(ServerS.capacity)) -1.0)*(Double(ServerS.period-ServerS.capacity));

	loop

		window_plus_one := 
	 compute_partition_internal_busy_period(deploymentS, Taski_Ptr.priority, window, bounded_tasks)
	+ compute_partition_internal_gaps (deploymentS, Taski_Ptr.priority, window, bounded_tasks)
	+ compute_server_interference(My_sys.deployments, Taski_Ptr, window, bounded_tasks);

	exit when (window = window_plus_one) or (window_plus_one>Double(Taski_Ptr.deadline-Periodic_Task_Ptr(Taski_Ptr).jitter));
		window := window_plus_one;
 	end loop;
	if (window = window_plus_one) then
	return window + Double(ServerS.jitter);
	else return -1.0; end if;
  end compute_wcrt;

end hierarchical_analysis_methods_temporary;