#/usr/bin/perl
#--------------------------------------------------------------------------------------------
# --- BAO 2 --- Version: Module XML::RSS ----------------------------------------------------
#--------------------------------------------------------------------------------------------
# Entrée: le programme prend le nom du répertoire contenant les fichiers
# 		  à traiter. 
# Sortie: Le programme construit en sortie:
#			-- Un fichier structuré qui contient l'étiquetage de chaque phrase par TreeTagger.
#			-- Un fichier TXT qui contient l'étiquetage fait par Talismane.
# Mode de lancement:
# 	perl5.28.1.exe bao2_version_xmlrss.pl NOM_REPERTOIRE_A_PARCOURIR NOM_RUBRIQUE_A_EXTRAIRE
#--------------------------------------------------------------------------------------------

use utf8;		
		
# Usage du module suivant:
use XML::RSS;

# Variable qui contient le dossier à parcourir:
my $rep="$ARGV[0]";

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

# Numérotation des fichiers:
my $i=0;

# On crée le hash afin de supprimer les doublons:
my %doublons;

# On va créer une rubrique pour mémoriser (3208, 3210...). On y gardera l'information de la rubrique où je vais travailler:
my $rubrique = "$ARGV[1]";

# On va déclarer les fichiers de sortie:
open(OUTXML, ">:encoding(utf-8)", "BAO2-SORTIE-$rubrique-TREETAGGER.xml");
#open(TALISMANE, ">:encoding(utf8)", "BAO2-SORTIE-$rubrique-TALISMANE.txt");

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

print OUTXML "<deuxieme_boite>\n"; # Déclaration de la racine.
print OUTXML "<entete>\n";
print OUTXML "\t<bao n=\"2\">Étiquetage 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.
#----------------------------------------------

&parcoursarborescencefichiers($rep);	# On fait appel à une fonction récursive pour parcourir l'arborescence de fichiers.

# Fermeture des fichiers:
print OUTXML "</fichiers>\n";;
print OUTXML "</deuxieme_boite>\n";
close OUTXML;
#close TALISMANE;
exit;

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

# Déclaration et initialisation de la variable où l'on gardera le contenu textuel à analyser par Talismane:
my $pourtalismane="";

# Définition de la fonction récursive:
sub parcoursarborescencefichiers {
	# On récupère l'ensemble de ressources dans une liste:
	my $path = shift(@_);
	
	# Fonction Perl qui me permet d'ouvrir un répertoire:
    opendir(DIR, $path) or die "Can't open $path: $!\n";
    my @files = readdir(DIR); # Fonction Perl qui me permet de lire le contenu d'un répertoire.
    closedir(DIR);
    foreach my $file (@files) {
	
		# Quand on examine une liste, 'next' me permet de passer au suivant si l'élément sur lequel on pointe vérifie l'expression régulière courante:
		next if $file =~ /^\.\.?$/; # Si on ne fait pas ça, ça va boucler sur le répertoire courant.
	
		# On récrée une variable avec le chemin où on est avec le ressource qu'on veut examiner:
		$file = $path."/".$file; # La ressource file me permet d'accéder à la ressource que je suis en train d'examiner.
	
		# On va demander si c'est un dossier ou un fichier:
		if (-d $file) { # --> Dossier
			print "\t--> On entre dans : \"$file\"\n";
			&parcoursarborescencefichiers($file);	# Fonction récursive --> Je recommence la boucle. On le fait jusqu'à épuiser toute l'arborescence.
		}
		if (-f $file) { # --> Fichier
			next if $file =~ /fil.+\.xml$/; # On ne traite pas les fichiers qui commencent par fil...
			# On va capturer les fichiers:
			if ($file=~/$rubrique.+\.xml$/) {
			
			# Traitement à réaliser sur chaque fichier --> Filtrage:
				print $i++,": \"$file\" \n";
				print "-------------------------------------------------------\n";
				
				# Spécification du fichier:
				print OUTXML "\t<fichier n=\"$i\" chemin=\"$file\">\n";
				
				# Dans Talismane:
				#print TALISMANE "## chemin : \"$file\"\n";
				
				# Initialisation du compteur de 'items':
				my $n=1;
				
				# Usage du module XML::RSS:
				my $rss=new XML::RSS;
				eval {$rss->parsefile($file); }; # On parse le fichier.
				if( $@ ) {
					$@ =~ s/at \/.*?$//s; # Remove module line number
					print STDERR "\nERROR in '$file':\n$@\n";
				}
				else {
					foreach my $item (@{$rss->{'items'}}) {
						my $titre=$item->{'title'}; # Extraction du titre.
						my $description=$item->{'description'}; # Extraction de la description.
						#my $pubDate = $item->{'pubDate'}; # Extraction de la date.
						
						# Nettoyage des éléments précédents (on les garde dans une nouvelle variable):
						my ($titre_nettoye,$description_nettoyee) = &nettoyage($titre,$description);

						if (exists $doublons{$titre_nettoye}) {
							$doublons{$titre_nettoye}++;
						}
						else {
							$doublons{$titre_nettoye}=1;
							
							# On affecte le titre et la description nettoyé pour Talismane:
							$pourtalismane = $pourtalismane . "\n" . "\n££debuttitre££ " . "\n" . $titre_nettoye . "§" . "\n" ."££fintitre££\n" . "\n" . "\n££debutdescription££" . "\n". $description_nettoyee . "§" . "\n" . " ££findescription££\n";
							
							# Écriture des fichiers de sortie:
							#-------------- VERSION XML------------------------------------
							print OUTXML "\t\t<item n=\"$n\">\n";

							#-----------ETIQUETAGE TREE-TAGGER-----------------------------
							# On va créer 2 nouvelles variables pour ne pas écraser leur contenu:
							my ($titre_tt, $desc_tt) = &etiquetageTreeTagger($titre_nettoye, $description_nettoyee);
							
							print OUTXML "\t\t\t<titre>$titre_tt\t\t\t</titre>\n";
							print OUTXML "\t\t\t<description>$desc_tt\t\t\t</description>\n";
							print OUTXML "\t\t</item>\n";
							#--------------------------------------------------------------
							
							$n++;
						}
					}
				print OUTXML "\t</fichier>\n";
				
				#-------------TALISMANE-------------------------------------------
				#my $et_Talismane = &etiquetageTalismane($pourtalismane);
				#print TALISMANE "$et_Talismane";
				#-----------------------------------------------------------------
				}
			}
		}
    }
}

# Fonction --> Nettoyage:
sub nettoyage {
	
	# Pour accéder aux éléments: --> Une éventuelle solution:
	my $var1 = $_[0];
	my $var2 = $_[1];
	
	# On va rajouter un point final à la fin du titre:
	$var1 = $var1 . ".";

	# 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;
	
	# Squeeze des espaces:
	$var1 =~ s/    / /g;
	$var2 =~ s/    / /g;
	
	# On remplace les & par 'et':
	$var1 =~ s/&(amp;)?/et/g;
	$var2 =~ s/&(amp;)?/et/g;

	# Normalisation des apostrophes:
	$var1 =~ s/’/'/g;
	$var2 =~ s/’/'/g;
			
	# Cet appel va renvoyer:	
	return $var1, $var2
	
}
#----------------------------------------------

# On convertit le lancement de TreeTagger en procédure:
sub invocation1_TT # Première invocation.
{
	system("perl5.28.1.exe tokenise_utf8_edited.pl -f temp_tt.txt | tree-tagger.exe -token -lemma -no-unknown french-utf8.par > temp_tag.txt" );
}

sub invocation2_TT # Deuxième invocation.
{
	system("perl5.28.1.exe treetagger2xml_utf8_edited.pl temp_tag.txt utf8");
}

sub etiquetageTreeTagger {
	my $var1 = $_[0]; # Titre.
	my $var2 = $_[1]; # Description.
	
	my $titre_tagge;
	my $desc_taggee;
	
	# On va créer un fichier pour ces deux variables.
	open (my $TMP_TT, ">:encoding(utf-8)", "temp_tt.txt");
	print $TMP_TT $var1;
	
	# Fermeture du fichier:
	close $TMP_TT;
	
	# Première invocation:
	&invocation1_TT($TMP_TT);
	
	# Deuxième invocation:
	&invocation2_TT($TMP_TT);

	local $/=undef; # Par défaut, on va lire tout le fichier.
	open(FIC1, "<:encoding(utf8)", "temp_tag.txt.xml");
	$titre_tagge = <FIC1>;
	close FIC1;
	$titre_tagge =~ s/<\?xml.+?>//;
	
	open ($TMP_TT, ">:encoding(utf-8)", "temp_tt.txt");
	print $TMP_TT $var2;
	
	# Fermeture du fichier:
	close $TMP_TT;
	
	# Première invocation:
	&invocation1_TT($TMP_TT);
	
	# Deuxième invocation:
	&invocation2_TT($TMP_TT);
	
	#local $=/undef; # Par défaut, on va lire tout le fichier.
	open(FIC1, "<:encoding(utf8)", "temp_tag.txt.xml");
	$desc_taggee = <FIC1>;
	$desc_taggee =~ s/<\?xml.+?>//;
	close FIC1;
	
	print "$titre_tagge\n";
	#my $rep = <STDIN>;
	
	# On va faire un return des deux:
	return $titre_tagge, $desc_taggee;
}

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

sub etiquetageTalismane {

my $var = shift @_;
	open (TMP, ">:encoding(utf8)", "bao2_test.txt" );
	print TMP $var;
	close TMP;
	system ("java -Xmx1G -Dconfig.file=../TALISMANE/talismane-fr-5.0.4.conf -jar ../TALISMANE/talismane-core-5.1.2.jar --analyse --sessionId=fr --encoding=UTF8 --inFile=bao2_test.txt --outFile=bao2_test.tal");
	my $fil;
	{
	local $/=undef;
	open(FIC1, "<:encoding(utf8)", "bao2_test.tal");
	$fil = <FIC1>;
	close FIC1;
	}
	return $fil;
}

#---------------FIN DU SCRIPT------------------