#!/usr/bin/perl

use strict;
use warnings;


#************* INITIALISATION DES INFORMATIONS GENERALES (LSHW) ****************
#         copie de la commande dans un tableau pour lshw
my @LshwTab=`lshw`;
# Extraction des champs relatifs aux item
my @ChampsLshw=("description|produit|fabriquant|numéro", # champs Identification ORDINATEUR
                "description|produit|fabriquant|version",# champs Identification CARTE MERE
                "description|fabriquant|version",# champs Identification BIOS
                "description|produit|bits|configuration",# champs Identification CPU
                "description|produit|fabriquant",  # champs Identification CARTE GRAPHIQUE
                "description|produit|fabriquant|capacité",# champs Identification RESEAU
                "description|produit|fabriquant",# champs Identification RESEAU
                "produit|fabriquant|capacité|configuration"# champs Identification BATTERIE
               );
my @LshwTitres=("\n########## Identification ORDINATEUR ##########\n",
                "\n########## Identification CARTE MERE ##########\n",
                "\n########## Identification BIOS #########\n",
                "\n########## Identification CPU ##########\n",
                "\n########## Identification CARTE GRAPHIQUE ##########\n",
                "\n########## Identification RESEAU ##########\n",
                "\n########## Identification BATTERIE ##########\n");
# Descripteur de l'item ordinateur                
my @DescOrdi=("0",          # titre du chapitre general (@LshwTitres)
              "0",          # champs (@ChampsLshw) de donnees à extraire
              "localhost",  # debut du bloc a extraire
              "\\*\\-"        # fin du bloc a extraire
             );
# Descripteur de l'item carte mère                             
my @DescCM=("1",            # titre du chapitre general (@LshwTitres)
            "1",          # champs (@ChampsLshw) de donnees à extraire
            "\\*\\-core", # debut du bloc a extraire
            "\\*\\-"        # fin du bloc a extraire
           );
# Descripteur de l'item BIOS                           
my @DescBios=("2",               # titre du chapitre general (@LshwTitres)
              "2",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-firmware",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item CPU                
my @DescCPU=("3",               # titre du chapitre general (@LshwTitres)
             "3",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-cpu",      # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item Affichage                
my @DescDisp=("4",               # titre du chapitre general (@LshwTitres)
             "4",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-display",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item reseau                
my @DescNet=("5",               # titre du chapitre general (@LshwTitres)
             "5",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-network",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
# Descripteur de l'item battery                
my @DescBat=("6",               # titre du chapitre general (@LshwTitres)
             "7",               # champs (@ChampsLshw) de donnees à extraire
              "\\*\\-battery",  # debut du bloc a extraire
              "\\*\\-"             # fin du bloc a extraire
             );
             
my @RefItems=("PC","CM","BIOS","CPU","DISP","NET","BAT");
#my @RefItems=("PC","CM","BIOS");
        
my @temp;
my @ident;
my $flag=0;

my $titre;
my $start;
my $end;
my $data;

#********** INITIALISATION DES INFORMATIONS USB (lsusb) *********


#********** INITIALISATION DES INFORMATIONS MEMOIRES (DMIDECODE) *********
#            copie de la commande dans un tableau pour dmidecode
my @tabdmidecode=`dmidecode -t memory`;
my @ChampsMem=("Data|Size|Bank Locator:|Type:|Speed:|Manufacturer");
my @MemTitres=("\n########## Identification MEMOIRE ##########\n");
my @DescMem=("0",      # titre du chapitre general (@SmartTitres)
             "0",      # champs (@ChampsMem) de donnees à extraire
             "Memory Device", # debut du bloc a extraire
             "Part"    # fin du bloc a extraire
              );

#*********** INITIALISATION DES INFORMATIONS DISK (SMARTCTL) **************
my @champsdisk=("Family|Model:|Serial|Capacity|Form|SATA");  
my @ListDisk=`ls -l /dev/sd?`;
my @DescDisk=("0",  # titre du chapitre general (@SmartTitres)
              "0"   # champs (@champsdisk) de donnees à extraire
              );
my @DiskTitres=("\n########## Identification DISK ##########\n");

my $D; 
my @tabsmart;              
              
#********** INITIALISATION DE LA GENERATION FICHIER RESULTAT *********
my @RefMachine=("PC", "CM"); 
my @ChampsRef=("numéro", # champs Identification ORDINATEUR
               "numéro"  # champs Identification CARTE MERE
              );
# Descripteur de l'item ordinateur                
my @DescOrdi2=("0",          # titre du chapitre general (@LshwTitres)
               "0",          # champs (@ChampsLshw) de donnees à extraire
               "localhost",  # debut du bloc a extraire
               "\\*\\-"        # fin du bloc a extraire
              );
# Descripteur de l'item carte mère                             
my @DescCM2=("1",            # titre du chapitre general (@LshwTitres)
             "1",          # champs (@ChampsLshw) de donnees à extraire
             "\\*\\-core", # debut du bloc a extraire
             "\\*\\-"        # fin du bloc a extraire
            );          
my @FicTab=@LshwTab;        
my $RefPC=undef;            
my $RefCM=undef;            
my $NomFic=undef;
my $A;
my $item;

#########################################################################
#           PROGRAMME DES INFORMATIONS GENERALES (LSHW)     
#########################################################################              
foreach (@RefItems) {  # foreach @RefItems
   # Pour chaque item a afficher 
   if ($_ eq "PC"){($titre, $data, $start, $end)=@DescOrdi;}
   if ($_ eq "CM"){($titre, $data, $start, $end)=@DescCM;}
   if ($_ eq "BIOS"){($titre, $data, $start, $end)=@DescBios;}
   if ($_ eq "CPU"){($titre, $data, $start, $end)=@DescCPU;}
   if ($_ eq "DISP"){($titre, $data, $start, $end)=@DescDisp;}
   if ($_ eq "NET"){($titre, $data, $start, $end)=@DescNet;}
   if ($_ eq "BAT"){($titre, $data, $start, $end)=@DescBat;}
   #print("$end\n");
   
   $flag=0;
   foreach (@LshwTab) {  # foreach @LshwTab
      # vidage buffer temporaire
      @temp=();
      # extraction d'un bloc memoire dans @temp
      if ( $flag==0 ){   # attente debut du bloc vu
         if ( m/$start/ ){  # debut du bloc vu
            s/$_//;
            $flag=1;
            push(@ident,$LshwTitres[$titre]);
         }   
      }else{      # attente fin du bloc vu
         push(@temp,$_);
         if ( m/$end/ ){   # fin du bloc vu
            $flag=0;
         }
      }
      # Extraction des champs d'un bloc memoire contenu dans @temp
      foreach (@temp) {   # foreach temp
         if ( m/$ChampsLshw[$data]/ ){
            s/\s+/     /;
            push(@ident,$_);
         }
      }  # fin boucle foreach temp
   }  # fin boucle foreach @LshwTab
}  # fin boucle foreach @LshwTitres

#########################################################################
#           PROGRAMME DES INFORMATIONS GENERALES (LSUSB)     
#########################################################################
   # vidage buffer temporaire
   @temp=();
   @temp=`lsusb`;
   push(@ident,"\n########## Identification USB ##########\n");
   # Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
         $_="     ".$_;
         push(@ident,$_);
   }
#########################################################################
#        PROGRAMME DES INFORMATIONS DES MEMOIRES (DMIDECODE)     
######################################################################### 
# titre Identification MEMOIRE
push(@ident,$MemTitres[$DescMem[0]]);
# initialisation des variables
$flag=0;
# vidage des tableaux temporaires 
@temp=();
# Pour chaque item a afficher
foreach (@tabdmidecode) {  # foreach @tabdmidecode
   #print"@tabdmidecode \n";
   # vidage des tableaux temporaires 
   @temp=();
   # extraction de la capacite maxi
   if ( m/Capacity/ ){
      s/\s+/     /;
      push(@ident,$_);
      #s/Capacity//;
   }
# extraction d'un bloc memoire dans @temp
   if ( $flag==0 ){   # attente debut du bloc vu
      if ( m/$DescMem[2]/ ){  # debut du bloc vu
         $flag=1;
         push(@ident,"\n************* BANK ***************\n");
      }   
   }else{      # attente fin du bloc vu
      push(@temp,$_);
      if ( m/$DescMem[3]/ ){   # fin du bloc vu
         $flag=0;
      }
   }

# Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
      if ( m/$ChampsMem[$DescMem[1]]/ ){
         s/\s+/     /;
         #print;
         push(@ident,$_);
      }
   }  # fin boucle foreach temp
} # fin boucle foreach @tabdmidecode

#########################################################################
#           PROGRAMME DES INFORMATIONS DISK (SMARTCTL)     
######################################################################### 
# titre Identification DISK
push(@ident,$DiskTitres[$DescDisk[0]]);
# pour chaque disque
foreach (@ListDisk) { # foreach disk
(my $A, my $B, $D)=split /\//;
chop($D);
@tabsmart=`smartctl -i /dev/$D`;
push(@ident,"\n*************** disk ".$D." *************\n");

# pour chaque disque extraction des champs description
   foreach (@tabsmart) {   # foreach tabsmart
      if ( m/$champsdisk[$DescDisk[1]]/ ){
         $_="     ".$_;
         #print;
         push(@ident,$_);
      }
   }  # fin boucle foreach tabsmart
} # fin foreach disk

#########################################################################
#           PROGRAMME DE LA GENERATION FICHIER RESULTAT  
######################################################################### 
# initialisation des variables
$flag=0;
foreach (@RefMachine) {  # foreach @RefMachine
   @temp=();
   # Pour chaque item a afficher
   if ($_ eq "PC"){($A, $data, $start, $end)=@DescOrdi2;}
   if ($_ eq "CM"){($A, $data, $start, $end)=@DescCM2;}
   $item=$_;
   #print "$A\n";
   #print "$data\n";
   #print "$start\n";
   #print "$fin\n";   
   foreach (@FicTab) {  # foreach @FicTab
      # extraction d'un bloc memoire dans @temp
      if ( $flag==0 ){   # attente debut du bloc vu
         if ( m/$start/ ){  # debut du bloc vu
            s/$_//;
            $flag=1;
         }   
      }else{      # attente fin du bloc vu
         push(@temp,$_);
         if ( m/$end/ ){   # fin du bloc vu
         $flag=0;
         }
      }

   # Extraction des champs d'un bloc memoire contenu dans @temp
   foreach (@temp) {   # foreach temp
      if ( m/$ChampsRef[$data]/ ){
         #s/\s+//;
         #print"$_";
         (my $E, my $Ref)=split(/:/,$_);
         $_=$Ref;
         s/\s+//;
         chop($_);
         #print"$_";
         if ($item eq "PC"){$RefPC=$_;}
         if ($item eq "CM"){$RefCM=$_;}
      }
   }  # fin boucle foreach temp
   }  # fin boucle foreach @FicTab

}   # fin boucle foreach @RefMachine
#print "$RefPC";
#print "$RefCM";

# patern pour test de la validite du test de la reference PC et CM
#$RefPC="CZC1194MME";
#$RefPC=undef;
#$RefPC="";

#$RefCM="CZC1194MMF";
#$RefCM=undef;
#$RefCM="";
# fin patern pour test de la validite du test de la reference PC et CM

# Test si $RefPC est: defini ET n'est pas une chaine vide ET ne contient pas d'espace
# Test si $RefCM est: defini ET n'est pas une chaine vide ET ne contient pas d'espace
if ((defined $RefPC) && ($RefPC ne "") && !($RefPC =~ m/\s+/))
{   $NomFic="PC_".$RefPC.".txt";
}elsif((defined $RefCM) && ($RefCM ne "") && !($RefCM =~ m/\s+/)){
       $NomFic="CM_".$RefCM.".txt";
   }else{ 
       $NomFic="ERROR.txt";
}

# Enregistrement du tableau @ident dans le fichier de nom $NomFic
open(my $Fout, ">",$NomFic) or die "Ouverture du fichier $NomFic impossible\n";
#print ($Fout "TOTO\n");
#print "\n";
foreach(@ident){
#print ($Fout $_);
print("$_");
}
close ($Fout);


print "\n########## Nom fichier resultat: $NomFic ##########\n";
print "\n";
################################ FIN PROGRAMME ################################