with Gtk.Menu_Item; use Gtk.Menu_Item;
with Gtk;            use Gtk;
with Gtk.Main;       use Gtk.Main;
with Glib.Error;     use Glib.Error;
with Gtk.Widget;     use Gtk.Widget;
with Gtk.Dialog;     use Gtk.Dialog;
with Gtk.About_Dialog; use Gtk.About_Dialog;
with Gtk.Label;        use Gtk.Label;
with Gtk.Text_Buffer; use Gtk.Text_Buffer;
with Ada.Text_IO;
with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with graphical_editor.scheduling_simulation_draw_callbacks; use graphical_editor.scheduling_simulation_draw_callbacks;
with graphical_editor.processors; use graphical_editor.processors;

with Framework_Config;               use Framework_Config;
with Translate;                      use Translate;
with Tasks;                          use Tasks;
with Task_Set;                       use Task_Set;
use Task_Set.Generic_Task_Set;
with Processors;                     use Processors;
with Processor_Set;                  use Processor_Set;
use Processor_Set.Generic_Processor_Set;

with graphical_editor.user_message;    use graphical_editor.user_message;



package body graphical_editor.scheduling_simulation_callbacks is



procedure Show_Scheduling_Simulation_widget(Object : access Gtkada_Builder_Record'Class) is
 
	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;

	buf1 : GObject;
	buf2 : GObject;
	buf3 : GObject;

	--- nouvelle approche : mettre ici ce que fait schedule_from_to_pkg

	 A_Task      : Generic_Task_Ptr;
      Iterator1   : Tasks_Iterator;
      A_Processor : Generic_Processor_Ptr;
      Iterator2   : Processors_Iterator;
      Max_Period  : Natural          := 0;
      Period      : Natural          := 0;
      Last_Period : constant Natural :=
        Framework_Config.Max_Scheduling_Period - 1;


begin
	graphical_editor.scheduling_simulation_callbacks.close_widget(Object);
	

	Gtk.Main.Init;

	
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "scheduling_simulation_draw.glade");
	if Error /= null then
		Ada.Text_IO.Put_Line ("Error : " & Get_Message (Error));
		Error_Free (Error);
		return;
	end if;
	

	--gerer ici les periodes et les valeurs par défaut ...
	buf1:=Get_Object(Builder, "textbuffer1");
	buf2:=Get_Object(Builder, "textbuffer2");
	buf3:=Get_Object(Builder, "textbuffer3");
	Set_Text(Gtk_Text_Buffer(buf1), "20");
	Set_Text(Gtk_Text_Buffer(buf2), "0");
	Set_Text(Gtk_Text_Buffer(buf3), "20");
  
	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button1_clicked", 
	Handler      => graphical_editor.scheduling_simulation_draw_callbacks.Draw_Scheduling'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button2_clicked", 
	Handler      => graphical_editor.scheduling_simulation_draw_callbacks.Close_Widget'Access);


	Do_Connect (Builder);
	Gtk.Widget.Show_All (Get_Widget (Builder, "window1"));
	Gtk.Main.Main;
	Unref (Builder);

	
 
end Show_Scheduling_Simulation_widget;

function Draw_Direct_Scheduling_cbk (Object : access Gtkada_Builder_Record'Class) return boolean is
	pragma Unreferenced (Object);
	begin
	
	--Show_Direct_Scheduling_Simulation_widget(Object);
	graphical_editor.scheduling_simulation_draw_callbacks.Draw_Direct_Scheduling(Object);
	--null;
	--Draw_From   := get_value_buffer_string(Gtk_Text_Buffer(Get_Object(Object, "textbuffer2")));
	return false;
	end Draw_Direct_Scheduling_cbk;


-- je peux ajouter a cette procedure si important       Text  : Gtk_Text;  Draw_Scheduling : Draw_Scheduling_Access;
-- Sys  : in System;   Customized_Simulation : Boolean := False
procedure Show_Direct_Scheduling_Simulation_widget(Object : access Gtkada_Builder_Record'Class) is
 
	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;

	buf1 : GObject;
	buf2 : GObject;
	buf3 : GObject;


	--- nouvelle approche : mettre ici ce que fait schedule_from_to_pkg

	 A_Task      : Generic_Task_Ptr;
      Iterator1   : Tasks_Iterator;
      A_Processor : Generic_Processor_Ptr;
      Iterator2   : Processors_Iterator;
      Max_Period  : Natural          := 0;
      Period      : Natural          := 0;
      Last_Period : constant Natural :=
        Framework_Config.Max_Scheduling_Period - 1;



begin
	--graphical_editor.scheduling_simulation_callbacks.close_widget(Object);
	Gtk.Main.Init;
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "scheduling_simulation_draw.glade");
	if Error /= null then
		Ada.Text_IO.Put_Line ("Error : " & Get_Message (Error));
		Error_Free (Error);
		return;
	end if;

	buf1:=Get_Object(Builder, "textbuffer1");
	buf2:=Get_Object(Builder, "textbuffer2");
	buf3:=Get_Object(Builder, "textbuffer3");
	

	reset_iterator (Sys.Tasks, Iterator1);
	if not is_empty (sys.Tasks) then
      loop

         current_element (Sys.Tasks, A_Task, Iterator1);
         if (A_Task.task_type = Periodic_Type) or
            (A_Task.task_type = Poisson_Type) or
            (A_Task.task_type = Sporadic_Type)
         then
            Max_Period :=
               Natural'Max (Max_Period, Periodic_Task_Ptr (A_Task).period);
         else
            Max_Period := Natural'Max (Max_Period, A_Task.deadline);
         end if;

         exit when is_last_element (Sys.Tasks, Iterator1);

         next_element (Sys.Tasks, Iterator1);

      end loop;
	else
	Show_Message_Box
	(Lb_Define_tasks_Before (Current_Language));
	end if;


      reset_iterator (Sys.Processors, Iterator2);

      loop

         current_element (Sys.Processors, A_Processor, Iterator2);

         if (Get_Number_Of_Task_From_Processor (Sys.Tasks, A_Processor.name) /=
             0)
         then

            begin
               Period := Scheduling_Period (Sys.Tasks, A_Processor.name);
               if Period > Max_Period then
                  Max_Period := Period;
               end if;

            exception
               when others =>
                  null;
            end;
         end if;

         exit when is_last_element (Sys.Processors, Iterator2);

         next_element (Sys.Processors, Iterator2);

      end loop;

      if (Max_Period >= Last_Period) then
         Max_Period := Last_Period;
      end if;

  -- et donc les initialiser ici ....

	Set_Text(Gtk_Text_Buffer(buf1), Max_Period'Img);
	Set_Text(Gtk_Text_Buffer(buf2), "0");
	Set_Text(Gtk_Text_Buffer(buf3), Max_Period'Img);

	my_buf_2:= Gtk_Text_Buffer(Get_Object(object, "textbuffer2"));


	--Gtk.Drawing_Area.initialize(my_area_1);

	--draw_scheduling_pkg.initialize(draw_scheduling);

	--graphical_editor.scheduling_simulation_callbacks.Draw_Scheduling := draw_scheduling;
	
	my_area := Get_widget(object, "drawingarea1");

	--set_double_buffered();
	--my_area := Gtk_Double_buffer(Get_Object(object, "drawingarea1"));



      -- set_text(my_buf_2, "voir si ca marche dans le draw_direct");

-- je peux ajouter a cette procedure si important       Text  : Gtk_Text;  Draw_Scheduling : Draw_Scheduling_Access;
-- Sys  : in System;   Customized_Simulation : Boolean := False

-- en fait 

    --  Schedule_From_To.Customized_Simulation := Customized_Simulation;
     -- Schedule_From_To.Text                  := Text;
     -- Schedule_From_To.Draw_Scheduling       := Draw_Scheduling;


	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button1_clicked", 
	Handler      => graphical_editor.scheduling_simulation_draw_callbacks.Draw_Direct_Scheduling'Access);

	Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button2_clicked", 
	Handler      => graphical_editor.scheduling_simulation_draw_callbacks.Close_Widget'Access);

	   -- Register_Handler
    -- (Builder      => object,
     --Handler_Name => "on_drawingarea1_expose_event", 
     -- Handler      => graphical_editor.scheduling_simulation_draw_callbacks.Draw_Direct_Scheduling_Cbk'Access);


	Do_Connect (Builder);
	Gtk.Widget.Show_All (Get_Widget (Builder, "window1"));
	Gtk.Main.Main;
	Unref (Builder);

end Show_Direct_Scheduling_Simulation_widget;

procedure Close_Widget(Object : access Gtkada_Builder_Record'Class) is
	pragma Unreferenced (Object);
	my_widget : GObject;
 
begin
	my_widget:=Get_Object(Object, "window1");
	Unref(my_widget);
	Hide(Gtk_Widget(my_widget));
end Close_Widget;

end graphical_editor.scheduling_simulation_callbacks;