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;
      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;