with Arch;                              use Arch;
with Arch.Abstracts;
with Arch.Classes;
with Arch.Environment;
with Arch.Install;
with Arch.Window;
with Gtk;                               use Gtk;
with Gdk.Threads;
with Gtk.Main;
with Gtk.Enums;                         use Gtk.Enums;
with Ada;                               use Ada;
with Ada.Text_Io;
procedure Archman is
 
   Gtk_Error : exception;
begin
   -- initialize Environment !                                                 
   Gdk.Threads.G_Init;
   Gdk.Threads.Init;
   Gtk.Main.Init;
   if not Main.Init_Check then
      raise Gtk_Error;
   end if;
   declare
      -- initialize window !                                                   
   begin
      -- Start Environment !                                                   
      Gdk.Threads.Enter;
      Gtk.Main.Main;
      Gdk.Threads.Leave;
   end;
exception
 
   when Gtk_Error =>
      Text_Io.Put_Line("Gtk Error." );
end Archman;

-- Archman is Gnu/Linux interface over Ada and GtkAda.                          
-- Archman (C) 2015 Copyright Manlight.net                                      
 
-- This program is free software: you can redistribute it and/or modify         
-- it under the terms of the GNU General Public License as published by         
-- the Free Software Foundation, either version 3 of the License, or            
-- (at your option) any later version.                                          
--                                                                              
-- This program is distributed in the hope that it will be useful,              
-- but WITHOUT ANY WARRANTY; without even the implied warranty of               
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                
-- GNU General Public License for more details.                                 
--                                                                              
-- You should have received a copy of the GNU General Public License            
-- along with this program.  If not, see <http://www.gnu.org/licenses/>.        
-------------------------------------------------------------------------------
-- Author       : Manuel De Girardi                                          --
-- Date         : 2015-01-12                                                 --
-- Project name : Archman                                                    --
-- Version      : 2.0.8a                                                     --
-- Description  : This program is writed over Gnu/Linux with Ada and GtkAda. --
-------------------------------------------------------------------------------
 
with Arch;                              use Arch;
with Arch.Abstracts;
with Arch.Ai;
with Arch.Angels;
with Arch.Classes;
with Arch.Environment;
with Arch.Install;
with Arch.Terminal;
with Arch.Window;
with Gtk;                               use Gtk;
with Gdk.Threads;
with Gtk.Main;
with Gtk.Enums;                         use Gtk.Enums;
with Ada;                               use Ada;
with Ada.Text_Io;
procedure Archman is
 
   Gtk_Error : exception;
 
   Context : constant Arch.Interfaces_Type := Textual;
 
   Errno   : Integer := 0;
 
   Non_Zero : exception;
begin
 
   begin
      loop
         case Getopt ("x" ) is  -- Accepts '-a', '-ad', or '-b argument'         
            when ASCII.NUL => exit;
 
            when 'x' =>
               if Full_Switch /= "x" then
                  raise Invalid_Switch;
               end if;
               Context := Graphical;
            when others =>
               raise Program_Error;         -- cannot occur!                    
         end case;
      end loop;
   exception
      when Invalid_Switch    => Put_Line ("Invalid Switch " & Full_Switch);
      when Invalid_Parameter => Put_Line ("No parameter for " & Full_Switch);
   end;
 
   -- initialize Environment !                                                         
   Errno := Arch.Environment.Initialize;
   if Errno /= 0 then
      raise Non_Zero;
   end if;
 
   -- initialize Ai !                                                                  
   Errno := Arch.Ai.Initialize;
   if Errno /= 0 then
      raise Non_Zero;
   end if;
 
   declare
 
      -- use Univers !                                                                 
      Archsum  : aliased Arch.Environment.Sum_Type(Context);
   begin
 
      -- add Client Env to Environment.                                                
      Errno := Arch.Environment.Add(Archsum);
      if Errno /= 0 then
         raise Non_Zero;
      end if;
 
      -- initialize client Environment !                                               
      Errno := Archsum.Initialize;
      if Errno /= 0 then
         raise Non_Zero;
      end if;
 
      declare
 
         -- use Computer !                                                             
         Archai      : aliased Arch.Ai.Computer_Type(Context, Archsum'Access);
         -- use Interface !                                                            
         Archmachine : aliased Arch.Angels.Machine_Type(Context, Archai'Access);
      begin
 
         -- add Client Ai to Architecture !                                            
         Errno := Arch.Ai.Add(Archai);
         if Errno /= 0 then
            raise Non_Zero;
         end if;
 
         case Context is
            when Graphical =>
               -- initialize GtkAda !                                                  
               Gdk.Threads.G_Init;
               Gdk.Threads.Init;
               Gtk.Main.Init;
               if not Main.Init_Check then
                  raise Gtk_Error;
               end if;
 
               -- initialize Interface !                                               
               Errno := Arch.Window.GtkAda_Initialize(Archmachine.GtkAda_Interface);
               if Errno /= 0 then
                  raise Non_Zero;
               end if;
 
               -- Start Environment !                                                  
               Gdk.Threads.Enter;
               Gtk.Main.Main;
               Gdk.Threads.Leave;
            when others =>
 
               -- initialize Interface !                                                  
               Errno := Arch.Terminal.Shell_Initialize(Archmachine.Shell_Interface);
               if Errno /= 0 then
                  raise Non_Zero;
               end if;
 
         end case;
      end;
 
   end;
 
   -- finalize Ai !                                                                    
   Errno := Arch.Ai.Finalize;
   if Errno /= 0 then
      raise Non_Zero;
   end if;
 
 
   -- finalize Environment !                                                           
   Errno := Arch.Environment.Finalize;
   if Errno /= 0 then
      raise Non_Zero;
   end if;
 
 
   Errno := Arch.Environment.Version.Update;
   if Errno /= 0 then
      raise Non_Zero;
   end if;
 
exception
   when Non_Zero =>
      Text_Io.Put_Line("Arch Error." );
      Text_Io.Put_Line("Errno = " & Integer'Image(Errno));
   when Gtk_Error =>
      Text_Io.Put_Line("Gtk Error." );
end Archman;

case Context is
            when Graphical =>
 
               declare
 
                  -- use Interface !                                                                                                                                                                                
                  Archmachine : Arch.Window.Main.GtkAda_Interface_Type;
 
               begin
                  if Gnat.Os_Lib."=" (Gnat.Os_Lib.Getenv("DISPLAY" ), null) then
                     Print_Message(Quiet, "X not running on this session." );
                     return;
                  end if;
                  Print_Message(Quiet, "-- initialize GtkAda !" );
                  Gdk.Threads.G_Init;
                  Gdk.Threads.Init;
                  Gtk.Main.Init;
                  if not Main.Init_Check then
                     raise Gtk_Error;
                  end if;
 
 
                  -- initialize Interface !                                                                                                                                                                         
                  Text_Io.Put_Line("-- initialize GtkAda Interface !" );
                  Arch.Window.Main.GtkAda_Initialize(Archmachine, Archai, Errno);
                  if Errno /= 0 then
                     raise Non_Zero;
                  end if;
 
 
                  Print_Message(Quiet, "-- Starting Graphical environment !" );
                  -- Start Environment !                                                                                                                                                                            
                  Gdk.Threads.Enter;
                  Gtk.Main.Main;
                  Gdk.Threads.Leave;
               end;
               declare
 
                  -- use Interface !                                                                                                                                                                                
                  Archmachine : Arch.Terminal.Main.Shell_Interface_Type;
 
               begin
 
                  -- initialize Interface !                                                                                                                                                                         
                  Text_Io.Put_Line("-- initialize Terminal Interface !" );
                  Arch.Terminal.Main.Shell_Initialize(Archmachine, Archai, Errno);
                  if Errno /= 0 then
                     raise Non_Zero;
                  end if;
 
 
                  Print_Message(Quiet, "-- Starting Textual environment !" );
                  -- Start Environment !                                                                                                                                                                            
                  Arch.Terminal.Main.Main(Archmachine, Errno);
 
               end;
 
         end case;

package Arch.Window.Main is
 
   type Main_Window_Record is new Gtk.Window.Gtk_Window_Record with
      record
         Action_Group                  : Gtk_Action_Group;
         Main_Frame                    : Gtk_Frame;
         Main_Vbox                     : Gtk_Vbox;
 
         Xterm_Process_Id              : Os_Lib.Process_Id;
         Errno                         : Integer := 0;
      end record;
 
 
   type Main_Window_Type is access all Main_Window_Record'Class;
 
   type GtkAda_Interface_Record(Computer : access Ai.Computer_Type) is tagged limited
      record
         GtkAda_Machine                : Arch.Angels.GtkAda_Machine_Type(Computer);
         Main_Window                   : Main_Window_Type;
      end record;
 
   package GtkAda_Conversion is new System.Address_To_Access_Conversions(GtkAda_Interface_Record);
   subtype GtkAda_Interface_Type is GtkAda_Conversion.Object_Pointer;
 
   procedure GtkAda_Initialize (GtkAda_Interface : in out GtkAda_Interface_Type; Archai : in Arch.Ai.Computer_Access; Errno : out Integer);
 
 
 
end Arch.Window.Main;

package Arch is
   pragma Pure (Arch);
 
   type Interfaces_Type is (Graphical, Textual);
 
   type Arch_Interface_Type(Context : Interfaces_Type) is abstract tagged limited null record;
 
end Arch;

with System.Address_To_Access_Conversions;
package Arch.pointers is
 
   package Arch_Conversion is new System.Address_To_Access_Conversions(Arch_Interface_Type'class);
   subtype Arch_Pointer is Arch_Conversion.Object_Pointer;
end Arch.Pointers;

package Arch.Window.Main is
 
   type Main_Window_Record is new Gtk.Window.Gtk_Window_Record with
      record
         Action_Group                  : Gtk_Action_Group;
         Main_Frame                    : Gtk_Frame;
         Main_Vbox                     : Gtk_Vbox;
 
         Xterm_Process_Id              : Os_Lib.Process_Id;
         Errno                         : Integer := 0;
      end record;
 
 
   type Main_Window_Type is access all Main_Window_Record'Class;
 
   type GtkAda_Interface_Record(Computer : access Ai.Computer_Type) is new Arch_Interface_Type(Graphical) with
      record
         GtkAda_Machine                : Arch.Angels.GtkAda_Machine_Type(Computer);
         Main_Window                   : Main_Window_Type;
      end record;
 
 
   procedure GtkAda_Initialize (GtkAda_Interface : in out Arch.Pointers.Arch_Pointer; Errno : out Integer);
 
 
 
end Arch.Window.Main;

declare
         Archmachine : Arch.Pointers.Arch_Pointer;
      begin
 
         Print_Message(Quiet, "-- add Client Ai to Architecture !" );
         Errno := Arch.Ai.Add(Archai.all);
         if Errno /= 0 then
            raise Non_Zero;
         end if;
 
         Print_Message(Quiet, "-- initialize Ai !" );
         Archai.Initialize(Errno);
         if Errno /= 0 then
            raise Non_Zero;
         end if;
 
 
 
 
         case Context is
            when Graphical =>
 
               begin
                  Archmachine := new Arch.Window.Main.GtkAda_Interface_Record(Archai);
                  if Gnat.Os_Lib."=" (Gnat.Os_Lib.Getenv("DISPLAY" ), null) then
                     Print_Message(Quiet, "X not running on this session." );
                     return;
                  end if;
                  Print_Message(Quiet, "-- initialize GtkAda !" );
                  Gdk.Threads.G_Init;
                  Gdk.Threads.Init;
                  Gtk.Main.Init;
                  if not Main.Init_Check then
                     raise Gtk_Error;
                  end if;
 
 
                  -- initialize Interface !                                                                                                                                                                         
                  Text_Io.Put_Line("-- initialize GtkAda Interface !" );
                  Arch.Window.Main.GtkAda_Initialize(Archmachine, Errno);
                  if Errno /= 0 then
                     raise Non_Zero;
                  end if;
 
 
                  Print_Message(Quiet, "-- Starting Graphical environment !" );
                  -- Start Environment !                                                                                                                                                                            
                  Gdk.Threads.Enter;
                  Gtk.Main.Main;
                  Gdk.Threads.Leave;
               end;
            when others =>
 
               begin
                  Archmachine := new Arch.Terminal.Main.Shell_Interface_Record(Archai);
                  -- initialize Interface !                                                                                                                                                                         
                  Text_Io.Put_Line("-- initialize Terminal Interface !" );
                  Arch.Terminal.Main.Shell_Initialize(Archmachine, Errno);
                  if Errno /= 0 then
                     raise Non_Zero;
                  end if;
 
 
                  Print_Message(Quiet, "-- Starting Textual environment !" );
                  -- Start Environment !                                                                                                                                                                            
                  Arch.Terminal.Main.Main(Archmachine, Errno);
 
               end;
 
         end case;
 
      end;

procedure Shell_Info (Window : in Window_Type; Shell_Command : in out Command_Type;
                               Shell_Interface : in out Shell_Interface_Record'Class; Errno : out Integer) is
 
 
         Result : Result_Access;
      begin
 
         case Shell_Command is
            when AllManuals | GnuLinuxInterface =>
               null;
            when others =>
               --  My_Ansi_Consoles.Draw_Centered
               --        (Window, 1, White, Shell.Shell_Command_Type'Image(Shell_Command));
               if Shell."/="(Archman_Shell_Response(Shell_Command), null) then
                  Shell.To_Result(Archman_Shell_Response(Shell_Command).all, Result);
 
                  if Result.all in Search_Result_Type'class then
                     My_Ansi_Consoles.Draw_Centered
                       (Window, 3, Red, "Search" );
                     Shell_Interface.Search_Result := Search_Result_Type(Result.all);
 
                  elsif Result.all in Spawn_Result_Type then
                     My_Ansi_Consoles.Draw_Centered
                       (Window, 3, Red, "Spawn" );
                     Shell_Interface.Spawn_Result := Spawn_Result_Type(Result.all);
 
                  end if;
 
               end if;
         end case;
 
         Move_Cursor_To(Window, 4, 3);
         Errno := 0;
      end Shell_info;

Archman_Shell_Response : Shell.Response_Type;