#/usr/bin/perl
#--------------------------------------------------------------------------------------------
# --- BAO 1 --- Version: RegEx---------------------------------------------------------------
#--------------------------------------------------------------------------------------------
# Entrée: le programme prend le nom du répertoire contenant les fichiers
# 		  à traiter. 
# Sortie: Le programme construit en sortie:
# 		  --> Un fichier en format du texte brut.
# 		  --> Un fichier en format structuré contenant sur chaque ligne 
#		      le nom du fichier et le résultat du filtrage.
# Mode de lancement:
# 	perl5.28.1.exe bao1_version_regex.pl NOM_REPERTOIRE_A_PARCOURIR NOM_RUBRIQUE_A_EXTRAIRE
#--------------------------------------------------------------------------------------------

#On sauvegarde dans les variables deux arguments qui prend notre programme:
my $rep="$ARGV[0]";
my $rubrique="$ARGV[1]";
#NB! En générale, quand on e automatiquement strings  les arguments,comme ça: p.ex ( fichier repertoir, fichier. txt) - c’est un liste qui s’appellent scalaire. En général, c’est une chaine de caractères ou des valeurs numériques.Cette liste est indexé de 0 (le premier argument va avoir index 0).Donc, on dit va me chercher ce liste $ARGV[0]- avec référence au premier index de la liste.

# On s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;

#On initialise aussi un compteur et une table de hachage pour eventuellement regler les doublons  (un dictionnaire dans les autres langues).
my $i=0;
my %doublons;

#------------------------------------

# On va déclarer les fichiers de sortie:
open(OUT, ">:encoding(utf-8)", "BAO1-SORTIE-$rubrique-REGEX.txt"); # Variabilisation de la rubrique choisie.
open(OUTXML, ">:encoding(utf-8)", "BAO1-SORTIE-$rubrique-REGEX.xml");

# On écrit ici la tête pour le fichier XML:
print OUTXML "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";

print OUTXML "<premiere_boite>\n"; # Déclaration de la racine.
print OUTXML "<entete>\n";
print OUTXML "\t<bao n=\"1\">Extraction de données</bao>\n"; # Phase du traitement.

# Et les auteurs:
print OUTXML "\t<auteur id=\"LOG\">Lucía ORMAECHEA GRIJALBA</auteur>\n"; 
print OUTXML "\t<auteur id=\"VS\">Veronika SOLOPOVA</auteur>\n";

print OUTXML "</entete>\n";

print OUTXML "<fichiers rubrique=\"$rubrique\">\n"; # L'ensemble des fichiers.
#----------------------------------------------

#Après on initialise un sous-programme qui va parcourir l’arborescence d’une manière récursive. Ça veut dire que quand l’algorithme atteint le bout de l’arbre, il va sortir et entrer dans la ramification suivante. Le sous-programme prend comme argument notre variable associé au répertoire des fichiers.
&parcoursarborescencefichiers($rep); # On fait appel à une fonction récursive pour parcourir l'arborescence de fichiers.

# Fermeture des fichiers:
close OUT;

print OUTXML "</fichiers>\n";
print OUTXML "</premiere_boite>\n";
close OUTXML;
exit;

#----------------------------------------------

#Voilà le sous-procès :
sub parcoursarborescencefichiers {
	#Shift prend le premier élément de la liste et le enlève et le renvoie.
    my $path = shift(@_);
    #Pour ouvrir contenue du répertoire (en bash c’est ls-la)  et lire tous les fichiers mêmes s’ils sont cachés:
    opendir(DIR, $path) or die "can't open $path: $!\n";
    #Cela nous renvoie la liste de ressources de mon répertoire:
    my @files = readdir(DIR);
    closedir(DIR);
    
	#La boucle « pour chacun » permet à passer à l’élément suivant si l’élément précédente que le programme a trouvé contient ça et ça (dans notre cas un anti-slash avec de n’importe quelle chaine de caractères après).
    foreach my $file (@files) {
		next if $file =~ /^\.\.?$/;
		$file = $path."/".$file;
		#Donc on recrée la variable , reconstruit le chemin relatif à ou nous sommes.Donc file est chemin qui nous permet aller et demander est-ce que c’est un répertoire ou fichier. Si c’est un dossier on écrit dans la console qu’on y entre.
		if (-d $file) {
		    print "\t--> On entre dans : \"$file\" \n";
		    #Si nous sommes dans un répertoire on recommence tout le precedure avec un nouveau paramètre:
			&parcoursarborescencefichiers($file);	#recurse!
			#NB -d - dossier; -f - file. Si c’est un fichier on cherche un fichier avec l’extension xml et la rubrique qui on a passer comme argument au programme, on modifie le compteur.
		}
		if (-f $file) {
		    if ($file=~/$rubrique.+\.xml$/) {			
				print $i++,": \"$file\" \n";
				print "-------------------------------------------------------\n";
				
				# Spécification du fichier:
				print OUTXML "\t<fichier n=\"$i\" chemin=\"$file\">\n";
				
				# Initialisation du compteur de 'items':
				my $n=1;
				
				#On ouvre ce fichier avec encodage UTF-8 pour lire:
				open(FIC, "<:encoding(utf-8)", $file);
				
				#On initialise une nouvelle variable qui est une chaine de caractères vide, qui on va remplir avec les titres et les descriptions.
				my $tout_le_texte="";
				
				#Dans cette boucle while on extraire les titres et les descriptions, on ajoute  un retour à la ligne et on ferme le fichier.
				while (my $ligne = <FIC>) {
					chomp $ligne;
					$tout_le_texte = $tout_le_texte . $ligne . " ";
				}
				close FIC;
				#ici on a ajouté aux titres et descriptions, les expressions reguliers pour capturer la date de publication
				while ($tout_le_texte =~ /<item>.*?<title>([^<]*)<\/title>.*?<description>([^<]*)<\/description>.*?<pubDate>([^<]*)<\/pubDate>.*?<\/item>/g) {
					#On initialise de variable pour y garder les titres,les dates et les descriptions par séparé.
					my $titre = $1;
					my $description = $2;
					my $pubDate = $3;
					#Avec un nouveau sous-programme on va nettoyer les cochonneries des contenus textuelles qu’on a extrait.
					my ($titrenettoye,$descriptionnettoye) = &nettoyage($titre,$description);
					#Ici on gère le cas des doublons (si jamais l’article n’avait pas modifié quelques jours et donc le même texte va se répéter).ça nous suffit verifier les titres
					if (exists $doublons{$titrenettoye}) {
						$doublons{$titrenettoye}++;
					}
					else {
						#S’il n’y a pas de doublons on transmette ce contenu textuel à nos fichiers de sortie
						$doublons{$titrenettoye}=1;
						
						# Écriture des fichiers de sortie:
						#-------------- VERSION TXT----------------
						print OUT "$titrenettoye\n";
						print OUT "$descriptionnettoye\n\n";

						#------------------------------------------
							
						#-------------- VERSION XML----------------
						print OUTXML "\t\t<item n=\"$n\">\n";
						print OUTXML "\t\t\t<date>$pubDate</date>\n";
						print OUTXML "\t\t\t<titre>$titrenettoye</titre>\n";
						print OUTXML "\t\t\t<description>$descriptionnettoye</description>\n";
						print OUTXML "\t\t</item>\n";
						#------------------------------------------
							
						# Incrémentation du compteur:
						$n++;
					}
				}
				print OUTXML "\t</fichier>\n";
			}
		}
    }
}

sub nettoyage {
	
	# Pour accéder aux éléments: --> Une éventuelle solution:
	my $var1 = $_[0];
	my $var2 = $_[1];
	
	# Une autre solution: my($st, $d) = @_;
	# Encore une autre: my $t = shift(@_); // my $d = shift(@_);
	
	#------------------------------------
	# On va rajouter un point final à la fin du titre:
	$var1 = $var1 . ".";
	# $var2 = $var2 . "."; --> Pas à la description.
	
	# On remplace par les guillemets simples:
	$var1 =~ s/&#39;/'/g;
	$var2 =~ s/&#39;/'/g;
	
	# On remplace par les guillemets doubles:
	$var1 =~ s/&#34;/\"/g;
	$var2 =~ s/&#34;/\"/g;
	
	#$var1 =~ s/&lt;br clear.+ border=...\/&gt;\./ /g;
	#$var2 =~ s/&lt;br clear.+ border=...\/&gt;\./ /g;
	
	# Squeeze des espaces:
	$var1 =~ s/    / /g;
	$var2 =~ s/    / /g;
	
	# On remplace les & par 'et':
	$var1 =~ s/&(amp;)?/et/g;
	$var2 =~ s/&(amp;)?/et/g;

	# Cet appel va renvoier:	
	return $var1, $var2
}
#----------------------------------------------
#---------------FIN DU SCRIPT------------------