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 Glib.Object; use Glib.Object;
with Gtk.Text_Buffer; use Gtk.Text_Buffer;
with Gtk.Combo_Box; use Gtk.Combo_Box;
with Gtk.Text_Iter;    use Gtk.Text_Iter;
with Gtk.List_Store;   use Gtk.List_Store;
with Gtk.Tree_Model;  use Gtk.Tree_Model;
with Gtk.Tree_View;  use Gtk.Tree_View;
with Gtk.Tree_View_Column;  use Gtk.Tree_View_Column;
with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with Glib.Values; use Glib.Values;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with unbounded_strings;     use unbounded_strings;
with Processors;                                           use Processors;
with address_spaces; 	use address_spaces;
with Processors.extended;                                  use Processors.extended;
with unbounded_strings;                                    use unbounded_strings;
use unbounded_strings.strings_table_package;
with Framework_Config;                                     use Framework_Config;
with Buffer_Set;                                           use Buffer_Set;
use Buffer_Set.Generic_Buffer_Set;
with Resource_Set;                                         use Resource_Set;
use Resource_Set.Generic_Resource_Set;
with graphical_editor.user_message;    use graphical_editor.user_message;
with GNAT.Current_Exception;                               use GNAT.Current_Exception;
with Translate;                                            use Translate;
with Networks;                                             use Networks;
with Task_Set;                                             use Task_Set;
use Task_Set.Generic_Task_Set;
with Scheduler;                                            use Scheduler;
with Scheduler.user_defined.interpreted.pipeline;  use  Scheduler.user_defined.interpreted.pipeline;
with Scheduler.user_defined.interpreted.Automata;  use  Scheduler.user_defined.interpreted.Automata;
with Scheduler_Interface;                                  use Scheduler_Interface;
with Processor_Set; 					use Processor_Set;
with Address_Space_Set; 			use Address_Space_Set;

package body graphical_editor.address_spaces is

procedure Initialize_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	ob1: GObject:= Get_Object(Object, "textbuffer1");
	ob2: GObject:= Get_Object(Object, "combobox1");
	ob3: GObject:= Get_Object(Object, "textbuffer3");
	ob4: GObject:= Get_Object(Object, "textbuffer4");
	ob5: GObject:= Get_Object(Object, "textbuffer5");
	ob6: GObject:= Get_Object(Object, "textbuffer6");
	ob7: GObject:= Get_Object(Object, "liststore1");
	ob8: GObject:= Get_Object(Object, "treeview1");
	wid1: t_widget := (ptype => buffer_string, buffer_value => Gtk_Text_Buffer(ob1));
	wid2: t_widget := (ptype => combo, combo_value => Gtk_Combo_Box(ob2));
	wid3: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob3));
	wid4: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob4));
	wid5: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob5));
	wid6: t_widget := (ptype => buffer_integer, buffer_value => Gtk_Text_Buffer(ob6));
	wid7: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob7));
	wid8: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob8));
	wid9: t_widget := (ptype => window, window_value => adress_space_window);

begin

	my_tab(1..address_space_table_length) := (new t_widget'(wid1), new t_widget'(wid2), new t_widget'(wid3), new t_widget'(wid4), 
	new t_widget'(wid5), new t_widget'(wid6), new t_widget'(wid7), new t_widget'(wid8), new t_widget'(wid9));

end initialize_Address_Space;

procedure Check_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; Error_Message: in out Unbounded_String; Ok: in out Boolean) is 

	Address_Space_Name, Cpu_Name, text_Memory_Size_String, Stack_Memory_Size_String, Data_Memory_Size_String, 
	Heap_Memory_Size_String : Unbounded_String;
	Text_Memory_Size, Stack_Memory_Size, Data_Memory_Size, Heap_Memory_Size: Integer;
	Integer_Ok  : Boolean;


begin

	Address_Space_Name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	if (Address_Space_Name = "") then
		Ok := False;
		Error_Message := Lb_Address_Space_Name_Mandatory (Current_Language);
		return;
	end if;

	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	if (Cpu_Name = "") then
		Ok            := False;
		Error_Message := Lb_processor_name_Mandatory (Current_Language);
		return;
         end if;

	text_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(3).buffer_value));
	if (text_Memory_Size_String = "") then
		text_Memory_Size := 0;
	else
		to_integer (text_Memory_Size_String, text_Memory_Size, Integer_Ok);
		if not Integer_Ok then
			Error_Message := Lb_Text_Memory_Size (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
			Ok := False;
			return;
		end if;
	end if;

	Stack_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(4).buffer_value));
	if (Stack_Memory_Size_String = "") then
		Stack_Memory_Size := 0;
	else
         to_integer (Stack_Memory_Size_String, Stack_Memory_Size, Integer_Ok);
         if not Integer_Ok then
            Error_Message := Lb_Stack_Memory_Size (Current_Language) &
                             Lb_Must_Be_Numeric (Current_Language);
            Ok            := False;
            return;
         end if;
      end if;

	Data_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(5).buffer_value));
	if (Data_Memory_Size_String = "") then
         Data_Memory_Size := 0;
      else
         to_integer (Data_Memory_Size_String, Data_Memory_Size, Integer_Ok);
         if not Integer_Ok then
            Error_Message := Lb_Data_Memory_Size (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
            Ok  := False;
            return;
         end if;
      end if;

	Heap_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(6).buffer_value));
	if (Heap_Memory_Size_String = "") then
         Heap_Memory_Size := 0;
      else
         to_integer (Heap_Memory_Size_String, Heap_Memory_Size, Integer_Ok);
         if not Integer_Ok then
            Error_Message := Lb_Heap_Memory_Size (Current_Language) & Lb_Must_Be_Numeric (Current_Language);
            Ok            := False;
            return;
         end if;
      end if;

	Check_Address_Space (Sys.Address_Spaces, Address_Space_Name, Cpu_Name, Text_Memory_Size, 
	Stack_Memory_Size, Data_Memory_Size, Heap_Memory_Size); 

	-- soit je retrouve les données suivantes a partir du cpu, soit je laisse ainsi ...
	-- voir avec frank

      --Is_Preemptive     : in Preemptives_Type := preemptive;
      --Quantum           : in Integer          := 0;
      --File_Name         : in Unbounded_String := empty_string;
      --A_Scheduler       : in Schedulers_Type  := No_Scheduling_Protocol;
      --automaton_name    : in Unbounded_String := empty_string);

	   exception
      when others =>
         Ok            := False;
         Error_Message := To_Unbounded_String (Exception_Message);

end Check_Address_Space;

procedure Add_In_Sys_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 

	Address_Space_Name, cpu_name, Text_Memory_Size_String, Stack_Memory_Size_string, Heap_Memory_Size_string,  
	Data_Memory_Size_String : Unbounded_String;
	Text_Memory_Size, Stack_Memory_Size, Data_Memory_Size, Heap_Memory_Size: Integer;
	Integer_Ok      : Boolean;
begin

	Address_Space_Name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	Cpu_Name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));

	text_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(3).buffer_value));
	if (Text_Memory_Size_String = "") then
		Text_Memory_Size := 0;
	else
		to_integer (Text_Memory_Size_String, Text_Memory_Size, Integer_Ok);
      end if;

	Stack_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(4).buffer_value));
	if (Stack_Memory_Size_String = "") then
		Stack_Memory_Size := 0;
	else
		to_integer (Stack_Memory_Size_String, Stack_Memory_Size, Integer_Ok);
      end if;

	Data_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(5).buffer_value));
	if (Data_Memory_Size_String = "") then
		Data_Memory_Size := 0;
	else
		to_integer (Data_Memory_Size_String, Data_Memory_Size, Integer_Ok);
      end if;

	Heap_Memory_Size_String := get_value_buffer_string(Gtk_Text_Buffer(my_tab(6).buffer_value));
	if (Heap_Memory_Size_String = "") then
		Heap_Memory_Size := 0;
	else
		to_integer (Heap_Memory_Size_String, Heap_Memory_Size, Integer_Ok);
      end if;

	Add_Address_Space (Sys.Address_Spaces, Address_Space_Name, Cpu_Name, Text_Memory_Size, Stack_Memory_Size, 
	Data_Memory_Size, Heap_Memory_Size);

	-- pareil que pour check: voir avec frank
      --Is_Preemptive     : in Preemptives_Type := preemptive;
      --Quantum           : in Integer          := 0;
      --File_Name         : in Unbounded_String := empty_string;
      --A_Scheduler       : in Schedulers_Type  := No_Scheduling_Protocol;
      --automaton_name    : in Unbounded_String := empty_string);

	   exception
      when Address_Space_Set.Invalid_Parameter =>
         begin
            Show_Message_Box (Exception_Message);
            return;
         end;
      when others =>
         begin
            Show_Message_Box (Exception_Name & Exception_Message);
            return;
         end;

end Add_In_Sys_Address_Space;

procedure Deleted_In_Sys_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	An_Address_Space : Address_Space_Ptr;
	name : unbounded_string;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	An_Address_Space := Search_Address_Space (Sys.Address_Spaces, name);
	delete (Sys.Address_Spaces, An_Address_Space);
end Deleted_In_Sys_Address_Space;

procedure Modify_In_Sys_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; name: unbounded_string) is 
	An_Address_Space, An_Address_Space_Buffer : Address_Space_Ptr;

begin
	An_Address_Space := Search_Address_Space (Sys.Address_Spaces, name);
	An_Address_Space_Buffer := An_Address_Space;
	
	An_Address_Space_Buffer.cheddar_private_id := An_Address_Space.cheddar_private_id;
	An_Address_Space_Buffer.name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	An_Address_Space_Buffer.cpu_name := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	An_Address_Space_Buffer.text_memory_size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(3).buffer_value));
	An_Address_Space_Buffer.stack_memory_size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(4).buffer_value));
	An_Address_Space_Buffer.data_memory_size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(5).buffer_value));
	An_Address_Space_Buffer.heap_memory_size := get_value_buffer_integer(Gtk_Text_Buffer(my_tab(6).buffer_value));

	Check_Address_Space (Sys.Address_Spaces, An_Address_Space_Buffer.name, An_Address_Space_Buffer.cpu_name, 
	An_Address_Space_Buffer.text_memory_size, An_Address_Space_Buffer.stack_memory_size, An_Address_Space_Buffer.data_memory_size, 
	An_Address_Space_Buffer.heap_memory_size); 
	delete (Sys.Address_Spaces, An_Address_Space);
	Add_Address_Space (Sys.Address_Spaces, An_Address_Space_Buffer.name, An_Address_Space_Buffer.cpu_name, 
	An_Address_Space_Buffer.text_memory_size, An_Address_Space_Buffer.stack_memory_size, An_Address_Space_Buffer.data_memory_size, 
	An_Address_Space_Buffer.heap_memory_size);

	exception
	when Address_Space_Set.Invalid_Parameter =>
	begin
		Show_Message_Box (Exception_Message);
		return;
	end;
	when others =>
	begin
		Show_Message_Box (Exception_Name & Exception_Message);
		return;
	end;
end Modify_In_Sys_Address_Space;

procedure Show_In_Sys_Address_Space(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	
begin
	null;
end Show_In_Sys_Address_Space;

package Address_Space_callbacks is new generic_callbacks(Number_of_widget => Address_Space_table_length, Initialize => initialize_Address_Space, Check => Check_Address_Space, Add_In_Sys => Add_In_Sys_Address_Space, Deleted_In_Sys => Deleted_In_Sys_Address_Space, Modify_In_Sys => Modify_In_Sys_Address_Space, Show_In_Sys => Show_In_Sys_Address_Space);  use Address_Space_callbacks;

procedure Show_Address_spaces_Widget is
 
	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;
	My_Iterator : Address_Spaces_Iterator;
	An_Address_Space: Address_Space_Ptr;
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject;

	A_Processor : Generic_Processor_Ptr;
	My_Processor_Iterator : Processors_Iterator;
	my_combo: GObject;

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

	Sys_buffer := sys;

	my_combo := Get_Object(Builder, "combobox1");
	reset_iterator (sys.Processors, My_Processor_Iterator);
	if not is_empty (sys.Processors) then 
	loop
		current_element (sys.Processors, A_Processor, My_Processor_Iterator);
		Append_Text (Gtk_Combo_Box(my_combo), To_String(A_Processor.name));
		exit when is_last_element (sys.Processors, My_Processor_Iterator);

		next_element (sys.Processors, My_Processor_Iterator);
	end loop;
	else
		Show_Message_Box (Lb_Define_processors_Before (Current_Language));
	end if;

	liststore:= Get_Object(Builder, "liststore1");
	reset_iterator (sys.Address_Spaces, My_Iterator);
	if not is_empty (sys.Address_Spaces) then
		loop
		current_element (sys.Address_Spaces, An_Address_Space, My_Iterator);
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (An_Address_Space.name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, To_String (An_Address_Space.cpu_name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 2, Gint(An_Address_Space.text_memory_size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 3, Gint(An_Address_Space.stack_memory_size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 4, Gint(An_Address_Space.data_memory_size));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 5, Gint(An_Address_Space.heap_memory_size));
		exit when is_last_element (sys.Address_Spaces, My_Iterator);
	next_element (sys.Address_Spaces, My_Iterator);
	         end loop;
      end if;

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_treeview1_cursor_changed", 
	Handler      => Address_Space_callbacks.Show_Lign_Selected'Access);

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button6_clicked", 
	Handler      => Address_Space_callbacks.Add_View'Access); 

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button5_clicked", 
	Handler      => Address_Space_callbacks.Modify_Lign'Access); 

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button4_clicked", 
	Handler      => Address_Space_callbacks.Delected_Lign_Selected'Access); 

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button2_clicked", 
	Handler      => Address_Space_callbacks.Cancel_View'Access);

	Gtkada.Builder.Register_Handler
	(Builder      => Builder,
	Handler_Name => "on_button1_clicked", 
	Handler      => Address_Space_callbacks.Close_View'Access);

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

end graphical_editor.address_spaces;