with Gtk;            use Gtk;
with Gtk.Main;       use Gtk.Main;
with Glib.Error;     use Glib.Error;
with Gtk.Widget;     use Gtk.Widget;
with Ada.Text_IO; use Ada.Text_IO;
with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with Gtk.Combo_Box; 		use Gtk.Combo_Box;
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 Tasks;                             use Tasks;
with Task_Set;                          use Task_Set;   
with Task_Groups;                             use Task_Groups;
with Task_Group_Set;                          use Task_Group_Set;
with Resources; use Resources;
with Resource_set; use Resource_set;
with Messages;              use Messages;
with Message_Set;           use Message_Set;
with core_units;   use core_units;
with Processors;                                           use Processors;
with Processor_set;                                           use Processor_set;
with Processors.extended;                                  use Processors.extended;
use Processor_Set.Generic_Processor_Set;
use Processor_Set.Generic_core_unit_Set;
with buffers;			use buffers;
with buffer_set;			use buffer_set;
with Networks;                                         use Networks;
with Network_Set;                                         use Network_Set;
with Event_Analyzers;    use Event_Analyzers;
with Event_Analyzer_set;    use Event_Analyzer_set;
with address_spaces; 	use address_spaces;
with address_space_set; 	use address_space_set;
with caches; 	use caches;
with cache_set; 	use cache_set;
with deployments; use deployments;
with deployment_set; use deployment_set;

with objects; use objects;
use objects.Generic_Object_Set_Package;
with objects.extended; use objects.extended;

with sets;

with Glib;      use Glib;
with Glib.Object; use Glib.Object;
with glib.values; use glib.values;

with graphical_editor.user_message;    use graphical_editor.user_message;
with GNAT.Current_Exception;                               use GNAT.Current_Exception;


package body graphical_editor.static_deployments is

procedure Initialize_static_deployment(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, "textbuffer2");
	ob3: GObject:= Get_Object(Object, "liststore4");
	ob4: GObject:= Get_Object(Object, "treeview2");
	ob5: GObject:= Get_Object(Object, "liststore5");
	ob6: GObject:= Get_Object(Object, "treeview3");
	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 => buffer_string, buffer_value => Gtk_Text_Buffer(ob2));
	wid3: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob3));
	wid4: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob4));
	wid5: t_widget := (ptype => lists, list_value => Gtk_List_Store(ob5));
	wid6: t_widget := (ptype => view, view_value => Gtk_Tree_View(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 => static_deployment_window);

begin

	my_tab(1..static_deployment_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_static_deployment;

function search_by_name(name : in unbounded_string) return Generic_Object_Ptr is 
	obj : Generic_Object_Ptr;
begin
	-- gerer ainsi toutes les entités et mettre ceci dans object_extended ..
	if Task_Is_Present(sys.tasks, name) then 
		obj := Generic_Object_Ptr(Search_Task(sys.tasks, name));
	end if;
	if Processor_Is_Present(sys.Processors, name) then 
		obj := Generic_Object_Ptr(Search_Processor(sys.Processors, name));
	end if;
	if Core_Is_Present(sys.Core_units, name) then 
		obj := Generic_Object_Ptr(Search_Core_unit(sys.Core_units, name));
	end if;
	if Address_Space_Is_Present(sys.Address_Spaces, name) then 
		obj := Generic_Object_Ptr(Search_Address_Space(sys.Address_Spaces, name));
	end if;

	return obj;
end search_by_name;

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

begin

	null;

end Check_static_deployment;

procedure Add_In_Sys_static_deployment(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	deployment_name : Unbounded_String;
	resource_entities : Generic_Objects_Set;
	tree_iter_resource : Gtk_Tree_Iter;
	number_rows: Integer;
	object_name_value : GValue;
begin

	number_rows:= get_number_elements(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(6).view_value)));
	tree_iter_resource := Get_Iter_First (Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(6).view_value)));
	for i in 1 .. number_rows loop
		Gtk.Tree_Model.Get_Value(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(6).view_value)), 
		tree_iter_resource, 0, object_name_value);
		add (resource_entities, search_by_name(to_unbounded_string(Get_String(object_name_value))));
		next(Gtk_Tree_Model(Gtk.Tree_View.Get_Model(my_tab(6).view_value)), tree_iter_resource); 
	end loop;

	deployment_name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	--deployment_set.Add_deployment (sys.deployments, deployment_name, resource_entities);


--resource_entities : in Generic_Objects_Set;
--consumer_entities : in Generic_Objects_Set;
  --    allocation_description   : in Unbounded_String;
    --  capacity       : in Integer :=0;
     -- period         : in Integer :=0;
     -- priority       : in Integer :=0;
     -- 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 deployment_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_static_deployment;

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

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

procedure Show_In_Sys_static_deployment(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	name : unbounded_string;
	A_deployment: generic_deployment_ptr;
	liststore1, liststore2 : GObject;
	tree_iter1, tree_iter2 : Gtk_Tree_Iter;
	consumer_entities_set, resource_entities_set : Generic_Objects_Set;
	My_consumer_entities_set_Iterator, My_resource_entities_set_Iterator : Generic_Object_Set_Package.iterator;
	A_consumer_entities, A_resource_entities : Generic_Object_Ptr;
begin
	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_deployment := Search_deployment (sys.deployments, Name);

	liststore1:= Get_Object(Object, "liststore4");
	liststore2:= Get_Object(Object, "liststore5");

	Gtk.List_Store.Clear(Gtk_List_Store(liststore1));
	Gtk.List_Store.Clear(Gtk_List_Store(liststore2));

	consumer_entities_set := A_deployment.consumer_entities;
	resource_entities_set := A_deployment.resource_entities;

	reset_iterator (consumer_entities_set, My_consumer_entities_set_Iterator);
	if not is_empty (consumer_entities_set) then 
	loop
		current_element (consumer_entities_set, A_consumer_entities, My_consumer_entities_set_Iterator);
		Append(Gtk_List_Store(liststore1), tree_iter1);
		Gtk.List_Store.Set(Gtk_List_Store(liststore1), tree_iter1, 0, 
		To_String (get_name_of_generic_object(A_consumer_entities)));
		
	exit when is_last_element (consumer_entities_set, My_consumer_entities_set_Iterator);
		next_element (consumer_entities_set, My_consumer_entities_set_Iterator);
	end loop;
	end if;

	reset_iterator (resource_entities_set, My_resource_entities_set_Iterator);
	if not is_empty (resource_entities_set) then 
	loop
		current_element (resource_entities_set, A_resource_entities, My_resource_entities_set_Iterator);
		Append(Gtk_List_Store(liststore2), tree_iter2);
		Gtk.List_Store.Set(Gtk_List_Store(liststore2), tree_iter2, 0, 
		To_String (get_name_of_generic_object(A_resource_entities)));
		
	exit when is_last_element (resource_entities_set, My_resource_entities_set_Iterator);
		next_element (resource_entities_set, My_resource_entities_set_Iterator);
	end loop;
	end if;
end Show_In_Sys_static_deployment;


package static_deployment_callbacks is new generic_callbacks(Number_of_widget => static_deployment_table_length, 
	Initialize => initialize_static_deployment, Check => Check_static_deployment, Add_In_Sys => Add_In_Sys_static_deployment, 
	Deleted_In_Sys => Deleted_In_Sys_static_deployment, Modify_In_Sys => Modify_In_Sys_static_deployment, 
	Show_In_Sys => Show_In_Sys_static_deployment);  use static_deployment_callbacks;

procedure Show_Static_Deployment_Widget is 

	Builder : Gtkada_Builder;
	Error   : Glib.Error.GError;

	My_Iterator : deployments_Iterator;
	A_deployment: generic_deployment_ptr; 
	tree_iter: Gtk_Tree_Iter;
	liststore: GObject;

	A_Task : Generic_Task_Ptr;
	A_Task_group : Generic_Task_Group_Ptr;
	A_Resource : Generic_Resource_Ptr;
	A_Message : Generic_Message_Ptr;
	A_Core_units : Core_Unit_Ptr;
	A_Processor : Generic_Processor_Ptr;
	A_Buffer : Buffer_Ptr;
	A_Network : Network_Ptr;
	An_Event_Analyzer : Event_Analyzer_Ptr;
	An_Address_Space: Address_Space_Ptr;
	A_Cache : Generic_Cache_Ptr;
	
	My_Task_Iterator : Tasks_Iterator;
	My_Task_group_Iterator : Task_Groups_Iterator;
	My_Resource_Iterator : Resources_Iterator;
	My_Message_Iterator : Messages_Iterator;
	My_Core_units_Iterator : core_units_Iterator;
	My_Processor_Iterator : Processors_Iterator;
	My_Buffer_Iterator : buffers_Iterator;
	My_Network_Iterator : Network_Iterator;
	My_Event_Iterator       : Event_Analyzers_Iterator;
	My_Address_Space_Iterator : Address_Spaces_Iterator;
	My_Cache_Iterator : Caches_Iterator;

	my_combo_consumer, my_combo_resource : GObject;

begin
	Gtk.Main.Init;
	Gtk_New (Builder);
	Error := Add_From_File (Builder, to_string(Glade_path) & "static_deployment.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_consumer := Get_Object(Builder, "combobox1");
	my_combo_resource := Get_Object(Builder, "combobox2");

	reset_iterator (sys.Tasks, My_Task_Iterator);
	if not is_empty (sys.Tasks) then 
	loop
	current_element (sys.Tasks, A_Task, My_Task_Iterator);
		
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Task.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Task.name));

	exit when is_last_element (sys.Tasks, My_Task_Iterator);
		next_element (sys.Tasks, My_Task_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Task_Groups, My_Task_group_Iterator);
	if not is_empty (sys.Task_Groups) then 
	loop
	current_element (sys.Task_Groups, A_Task_group, My_Task_group_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Task_group.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Task_group.name));

	exit when is_last_element (sys.Task_Groups, My_Task_group_Iterator);
		next_element (sys.Task_Groups, My_Task_group_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Resources, My_Resource_Iterator);
	if not is_empty (sys.Resources) then 
	loop
	current_element (sys.Resources, A_Resource, My_Resource_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Resource.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Resource.name));

	exit when is_last_element (sys.Resources, My_Resource_Iterator);
		next_element (sys.Resources, My_Resource_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Messages, My_Message_Iterator);
	if not is_empty (sys.Messages) then 
	loop
	current_element (sys.Messages, A_Message, My_Message_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Message.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Message.name));

	exit when is_last_element (sys.Messages, My_Message_Iterator);
		next_element (sys.Messages, My_Message_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Core_units, My_Core_units_Iterator);
	if not is_empty (sys.Core_units) then 
	loop
	current_element (sys.Core_units, A_Core_units, My_Core_units_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Core_units.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Core_units.name));

	exit when is_last_element (sys.Core_units, My_Core_units_Iterator);
		next_element (sys.Core_units, My_Core_units_Iterator);
	end loop;
	end if;

	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_consumer), To_String(A_Processor.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Processor.name));

	exit when is_last_element (sys.Processors, My_Processor_Iterator);
		next_element (sys.Processors, My_Processor_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Buffers, My_Buffer_Iterator);
	if not is_empty (sys.Buffers) then 
	loop
	current_element (sys.Buffers, A_Buffer, My_Buffer_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Buffer.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Buffer.name));

	exit when is_last_element (sys.Buffers, My_Buffer_Iterator);
		next_element (sys.Buffers, My_Buffer_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Networks, My_Network_Iterator);
	if not is_empty (sys.Networks) then 
	loop
	current_element (sys.Networks, A_Network, My_Network_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Network.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Network.name));

	exit when is_last_element (sys.Networks, My_Network_Iterator);
		next_element (sys.Networks, My_Network_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Event_Analyzers, My_Event_Iterator);
	if not is_empty (sys.Event_Analyzers) then 
	loop
	current_element (sys.Event_Analyzers, An_Event_Analyzer, My_Event_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(An_Event_Analyzer.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(An_Event_Analyzer.name));

	exit when is_last_element (sys.Event_Analyzers, My_Event_Iterator);
		next_element (sys.Event_Analyzers, My_Event_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Address_Spaces, My_Address_Space_Iterator);
	if not is_empty (sys.Address_Spaces) then 
	loop
	current_element (sys.Address_Spaces, An_Address_Space, My_Address_Space_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(An_Address_Space.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(An_Address_Space.name));

	exit when is_last_element (sys.Address_Spaces, My_Address_Space_Iterator);
		next_element (sys.Address_Spaces, My_Address_Space_Iterator);
	end loop;
	end if;

	reset_iterator (sys.Caches, My_Cache_Iterator);
	if not is_empty (sys.Caches) then 
	loop
	current_element (sys.Caches, A_Cache, My_Cache_Iterator);
	
	Append_Text (Gtk_Combo_Box(my_combo_consumer), To_String(A_Cache.name));
	Append_Text (Gtk_Combo_Box(my_combo_resource), To_String(A_Cache.name));

	exit when is_last_element (sys.Caches, My_Cache_Iterator);
		next_element (sys.Caches, My_Cache_Iterator);
	end loop;
	end if;

	liststore:= Get_Object(Builder, "liststore1");
	reset_iterator (sys.Deployments, My_Iterator);
	if not is_empty (sys.Deployments) then
		loop
		current_element (sys.Deployments, A_deployment, My_Iterator);
		--put_line(Deployments_Type'image(a_deployment.deployment_type));
		--a_deployment.deployment_type := static_deployment_type;
		if A_deployment.deployment_type = STATIC_DEPLOYMENT_TYPE then 
		Append(Gtk_List_Store(liststore), tree_iter);
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (A_deployment.name));
		
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
		To_String (Static_Deployment_ptr(A_deployment).allocation_description));
		end if;
		exit when is_last_element (sys.Deployments, My_Iterator);
		next_element (sys.Deployments, My_Iterator);
		end loop;
	end if;

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

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

end graphical_editor.static_deployments;