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.Values; use Glib.Values;
with Glib; use Glib;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with unbounded_strings;     use unbounded_strings;
with Translate;                                            use Translate;
with Framework_Config;                                     use Framework_Config;
with Ada.Strings.Unbounded;    use Ada.Strings.Unbounded;
with Gtkada.Builder; use Gtkada.Builder;
with graphical_editor.manual_callbacks; use graphical_editor.manual_callbacks;
with convert_unbounded_strings; 
with Network_Set;                                         use Network_Set;
with generic_callbacks; 
with generic_package_widget; use generic_package_widget;
with graphical_editor.user_message;    use graphical_editor.user_message;
with GNAT.Current_Exception;                               use GNAT.Current_Exception;



package body graphical_editor.networks is

network_table_length : constant natural :=5;

procedure Initialize_Network(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, "liststore2");
ob4: 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 => lists, list_value => Gtk_List_Store(ob3));
wid4: t_widget := (ptype => view, view_value => Gtk_Tree_View(ob4));
wid5: t_widget := (ptype => window, window_value => network_Window);

begin

my_tab(1..network_table_length) := (new t_widget'(wid1), new t_widget'(wid2), new t_widget'(wid3), new t_widget'(wid4), new t_widget'(wid5));


end initialize_Network;

procedure Check_Network(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; Error_Message: in out Unbounded_String; Ok: in out Boolean) is 
	network_name, network_protocol_string: Unbounded_String;
	network_protocol : Networks_Type;

begin

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

	network_protocol_string := to_unbounded_string(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));
	if (network_protocol_string = "") then
		Ok            := False;
		Error_Message := Lb_network_type_Mandatory (Current_Language);
		return;
         end if;
	network_protocol := get_compatible_network(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));

	Check_network (Sys.Networks, network_Name, network_protocol);

	exception

	when Network_Set.Invalid_Parameter =>
	begin
		Ok := False;
		Error_Message := To_Unbounded_String (Exception_Message);
		return;
	end;

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

	end;

end Check_network;


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

	network_Name: Unbounded_String;
	network_protocol: Networks_Type;

begin
	network_Name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	network_protocol := get_compatible_network(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));

	Add_Network (Sys.Networks, network_Name, network_protocol);

	exception
	when Network_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_Network;

procedure Deleted_In_Sys_Network(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class) is 
	--My_Iterator : Network_Set.Generic_Network_Set.iterator;
	a_network : Network_Ptr;
	name : unbounded_string;
begin

	name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	a_network := Search_Network (Sys.Networks, name);
	Delete_network (Sys.Networks, a_network.name);

end Deleted_In_Sys_Network;

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

begin
	null;
end Show_In_Sys_Network;

procedure Modify_In_Sys_Network(my_tab: in out table_widget_id ; Object : access Gtkada_Builder_Record'Class; name: unbounded_string) is 
	a_network, a_network_buffer : Network_Ptr;
begin
	a_network := Search_Network (Sys.Networks, name);
	a_network_buffer := a_network;
	
	A_Network_buffer.cheddar_private_id := A_network.cheddar_private_id;
	a_network_buffer.name := get_value_buffer_string(Gtk_Text_Buffer(my_tab(1).buffer_value));
	A_network_buffer.network_Type := get_compatible_network(Get_Active_Text(Gtk_Combo_Box(my_tab(2).combo_value)));

	Check_network (Sys.Networks, a_network_buffer.name, A_network_buffer.network_Type);
	Delete_network (Sys.Networks, a_network.name);
	--Add_Network (Sys.Networks, a_network_buffer.name, A_network_buffer.network_Type);
	add (Sys.Networks, a_network_buffer);

	exception
	when Network_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_Network;

function get_compatible_network(mynetwork: String) return networks_Type is 

mynetwork_net : networks_Type;

begin
	if to_Unbounded_String(mynetwork) = to_Unbounded_String("Bounded Delay") then
			mynetwork_net := Bounded_Delay;
	end if;

	if to_Unbounded_String(mynetwork) = to_Unbounded_String("Jitter Delay") then
			mynetwork_net := Jitter_Delay;
	end if;

	if to_Unbounded_String(mynetwork) = to_Unbounded_String("Parametric Delay") then
			mynetwork_net := Parametric_Delay;
	end if;

	return mynetwork_net;

end get_compatible_network;

function get_compatible_network(mynetwork: Gvalue) return networks_Type is 

begin
	return get_compatible_network(Get_String(mynetwork));

end get_compatible_network;

function get_compatible_network(mynetwork: networks_type) return unbounded_string is 
mynetwork_string: unbounded_string;
begin

	if mynetwork = Bounded_Delay then 
			mynetwork_string:= to_Unbounded_String("Bounded Delay");
	end if;

	if mynetwork = Jitter_Delay then 
			mynetwork_string:= to_Unbounded_String("Jitter Delay");
	end if;

	if mynetwork = Parametric_Delay then 
			mynetwork_string:= to_Unbounded_String("Parametric Delay");
	end if;

	return mynetwork_string;

end get_compatible_network;

package network_callbacks is new generic_callbacks(Number_of_widget => network_table_length, Initialize => Initialize_Network, 
	Check => Check_Network, Add_In_Sys => Add_In_Sys_Network, Deleted_In_Sys => Deleted_In_Sys_Network, 
	Modify_In_Sys => Modify_In_Sys_Network, Show_In_Sys => Show_In_Sys_Network);  use network_callbacks;

procedure Show_Network_Widget is

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

	tree_iter: Gtk_Tree_Iter;
	A_Network : Network_Ptr;
	My_Iterator : Network_Iterator;
	liststore: GObject; 

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

	Sys_buffer := sys;

	Set_Active (Gtk_Combo_Box(Get_Object(Builder, "combobox1")), 0);

	liststore:= Get_Object(Builder, "liststore2");
	reset_iterator (Sys.Networks, My_Iterator);

	if not is_empty (sys.Networks) then
		loop
		current_element (sys.Networks, A_Network, My_Iterator);
		Append(Gtk_List_Store(liststore), tree_iter);

		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 0, To_String (a_network.name));
		Gtk.List_Store.Set(Gtk_List_Store(liststore), tree_iter, 1, 
		To_String(get_compatible_network(A_network.network_Type)));

		exit when is_last_element (sys.Networks, My_Iterator);
		next_element (sys.Networks, My_Iterator);

		end loop;
      end if;

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

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

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

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

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

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


	Do_Connect (Builder);

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

end graphical_editor.networks;