#/usr/bin/perl
<<DOC;
PROJET ENCADRÉ 2:
PACHECO Léo & TINARRAGE Valentin 
JANVIER 2018
 usage : perl BAO_2_Regex.pl repertoire-a-parcourir nom_rubrique
 Le programme prend en entrée le nom du répertoire contenant les fichiers
 à traiter
 Le programme construit en sortie un fichier structuré contenant sur chaque
 ligne le nom du fichier et le résultat du filtrage :

 dans ce programme, Treetagger va enrichir la sortie xml, Talismane va générer une sortie avec tout le texte étiqueté.
<FICHIER><NOM>du fichier</NOM></FICHIER><CONTENU>du filtrage</CONTENU></FICHIER>
DOC
use Unicode::String; #qw(utf8);
binmode STDOUT, ":utf8";
use Time::HiRes qw(gettimeofday tv_interval);
my $timepg = [gettimeofday];
#use strict; # oblige à déclarer les variables
#-----------------------------------------------------------
my $rep="$ARGV[0]"; # on récup la racine de l'arborescence
my $rubrique="$ARGV[1]"; # on rend la rubrique.
$rep =~ s/[\/]$//; # on s'assure que le nom du répertoire ne se termine pas par un "/"
my %doublon = {};
my $output1="SORTIE.xml";

my $compteurfile = 1;
my $compteuritem = 0;

# on créer un tableau de hash afin de faire correspondre les rubriques avec leur nom correspondant.
my %nomsRubrique = ("une"=>"3208","internationnal"=>"3210","europe"=>"3214","société"=>"3224","idées"=>"3232","économie"=>"3234","médias"=>"3236","vous"=>"3238","sport"=>"3242","planète"=>"3244","culture"=>"3246","livres"=>"3260","cinéma"=>"3476","voyage"=>"3546","technologies"=>"651865","politique"=>"823353","sciences"=>"env_sciences");

#print "$nomsRubrique{$rubrique}\n"

if (exists $nomsRubrique{$rubrique}) # si la rubrique est reconnue alors:
{   
    #initialisation / écriture fichier OUT TXT puis XML
    open(OUT, ">:encoding(utf8)","./OUTPUTS/sortie-$rubrique.txt");
    open(OUTXML, ">:encoding(utf8)","./OUTPUTS/sortie-$rubrique.xml");
    print OUTXML "<?xml version=\'1.0\' encoding=\'utf8\'?>\n"; # écriture en tête XML
    print OUTXML "<racine>\n"; # écriture élément racine ouverture XML

    open(TALISMANE, ">:encoding(utf8)","./OUTPUTS/sortie-$rubrique-talismane.txt");

    &parcoursArborescenceFichiers($rep);

    close OUT;
    print OUTXML "</racine>\n"; # écriture élément racine fermeture XML
    close OUTXML;
    close TALISMANE;
}
else #sinon on indique que la rurbique est inconnue.
{
    print "rubrique inconnue\n";
}
print "\nScript execution time: " . tv_interval($timepg) . " seconds.";
exit;
#-----------------------------------------------------------
#fonctions:

sub parcoursArborescenceFichiers 
{
    my $path = shift(@_);
    opendir(DIR, $path) or die "can't open $path: $!\n";   #ouverture répertoire (équivalent de ls)
    my @files = readdir(DIR);   #récupération contenu répertoire, readdir est associée à opendir. renvoie liste des ressources du répertoire (résultat de ls -l)
    closedir(DIR);
    foreach $file (@files) 
    {     #pour chacun des éléments dans le répetoire, on vérifie si c'est un dossier ou un fichier
	    next if $file =~ /^\.\.?$/; #si on obtient . ou .., on ne fait rien, on passe à l'élément suivant pour ne pas boucler ou remonter dans l'arbo. attention les fichiers cachés commencent par un '.'
	    $file = $path."/".$file; #écriture du chemin complet de l'élément, on recréer une var qui prend le nom du rep dans lequel on est entré suivit du nom de la ressource qu'on veut examiner (à partir de la racine). On peut intéroger si cette ressource est un dossier ou un fichier (commandes suivantes).
	    if (-d $file) 
        {
            print "on entre dans: $file \n"; # juste histoire d'afficher le répertoire dans lequel on entre
	        &parcoursArborescenceFichiers($file);	#Si l'élément est un dossier, on reclance les étapes ci-dessus. ici file est le nouveau répertoire.            
	    }
        
	    if (-f $file) #si l'élément est un fichier, on lance le traitement de filtrage.
        {
            if ($file=~/$nomsRubrique{$rubrique}.*\.xml$/) # de plus, on teste si notre fichier correspond à la rubrique passé en argument 2, si oui on lance les traitements.
            {
                &extractTitleAndDesc($file); #TRAITEMENT à réaliser sur chaque fichier
            }
	    }
	}
}

#fonction qui extrait les titres et descriptions. 1 argument en in et 2 en out.
sub extractTitleAndDesc
{
    open(FIC,"<:encoding(utf8)",$file);
    my $fullText="";
    while (my $ligne = <FIC>) #concaténation du fichier pour éviter d'avoir balises sur 2 lignes
    {
        chomp $ligne; #on enleve la fin de ligne.
        $fullText = $fullText . $ligne . " ";
    }
    close FIC;
    my $fullTalismane="";
    while ($fullText =~ /<item>.*?<title>([^<]*)<\/title>.*?<description>([^<]*)<\/description>.*?<\/item>/g) #isole chaque couple titre / description. Pour TALISMANE il faudra recoller ces couples pour tout mettre dans un grand fichier.
    {
        my $titre = $1;
        my $description = $2;
        my ($titreClean,$descriptionClean) = &nettoyage($titre,$description);

        if (exists $doublon{$titreClean})
        {
            $doublon{$titreClean}++;
        }
        else
        {
            $doublon{$titreClean}=1;
            my $titreCleanTALISM = $titreClean;
            my $descriptionCleanTALISM = $descriptionClean;
            $titreCleanTALISM =~ s/[\.|…\?\!]+/\.\n/g;
            $descriptionCleanTALISM =~ s/[\.|…\?\!]+/\.\n/g;
            $fullTalismane = $fullTalismane . $titreCleanTALISM . "\n\n" . $descriptionCleanTALISM . "\n\n"; # on concatène les couples titres desc les uns à la suite des autres.
            # TXT
            # print OUT "$titreClean\n";
            # print OUT "$descriptionClean\n\n";
            # XML
            # print OUTXML "\t<item>\n";
            # my ($titre_etiq_TTG, $description_etiq_TTG) = &etiquetageTreeTagger($titreClean,$descriptionClean);
            # print OUTXML "\t\t<titre>$titre_etiq_TTG</titre>\n";
            # print OUTXML "\t\t<description>$description_etiq_TTG</description>\n";
            # print OUTXML "\t</item>\n";
        }

    }
    my $etiq_Talismane = &etiquetageTALISMANE($fullTalismane);
    print TALISMANE "$etiq_Talismane";
    return $titreClean,$descriptionClean;
}
#fonction qui nettooie les titres et descriptions. prends 2 arguments et en retourne deux aussi.
sub nettoyage
{
    my $titre = shift(@_);
    my $desc = shift(@_);

    $titre =~ s/&lt;/</g;
    $titre =~ s/&gt;/>/g;
    $titre =~ s/<a href[^>]+>//g;
    $titre =~ s/<img[^>]+>//g;
    $titre =~ s/<\/a>//g;
    $titre =~ s/&#38;#39;/'/g;
    $titre =~ s/&#38;#34;/"/g;
    $titre =~ s/<[^>]+>//g;
    $titre =~ s/&amp;/&/g;
    #$titre. =~ ".";
    $titre =~ s/\?\.$/\?/;

    $desc =~ s/&lt;/</g;
    $desc =~ s/&gt;/>/g;
    $desc =~ s/<a href[^>]+>//g;
    $desc =~ s/<img[^>]+>//g;
    $desc =~ s/<\/a>//g;
    $desc =~ s/&#38;#39;/'/g;
    $desc =~ s/&#38;#34;/"/g;
    $desc =~ s/<[^>]+>//g;
    $desc =~ s/&amp;/&/g;
    $desc =~ s/\?\.$/\?/;
    
    return $titre,$desc;
}

sub etiquetageTreeTagger
{
    my $titre_TTG = shift(@_);
    my $desc_TTG = shift(@_);
    
    #--- traitement de titre------------------------
    open(TMP, ">:encoding(utf8)","titre_tmp.txt"); # vu que les scripts perl qu'on va invoquer pour tokenizer et treetagger prennent un fichier en argument (au lieu d'un flux de donné), il faut envoyer le contenu textuel des variables dans un fichier temporaire
    print TMP $titre_TTG;
    close TMP;
    system("perl ./ressources-outils-bao/TREETAGGER/tokenise-utf8.pl -f titre_tmp.txt | ./ressources-outils-bao/TREETAGGER/tree-tagger -lemma -token -no-unknown ./ressources-outils-bao/TREETAGGER/french-utf8.par > titre_tmp_tagged");
    system("perl ./ressources-outils-bao/TREETAGGER/treetagger2xml-utf8.pl titre_tmp_tagged utf8");
    local $/=undef; #variable qui permet localement de lire tout le fichier d'un coup (undef enlève le \n qui se trouve par défaut dans la vriable perl $/)
    open(FIC,"<:encoding(utf8)","titre_tmp_tagged.xml");
    my $titre_TTG_return = <FIC>;
    $titre_TTG_return =~ s/<\?xml.+?>//; #s/<\?xml version="1\.0" encoding="utf8" standalone="no"\?>\r\n//
    close FIC;

    #--- traitement de description------------------------
    print FIC;
    open(TMP, ">:encoding(utf8)","desc_tmp.txt");
    print TMP $desc_TTG;
    close TMP;
    system("perl ./ressources-outils-bao/TREETAGGER/tokenise-utf8.pl -f desc_tmp.txt | ./ressources-outils-bao/TREETAGGER/tree-tagger -lemma -token -no-unknown ./ressources-outils-bao/TREETAGGER/french-utf8.par > desc_tmp_tagged");
    system("perl ./ressources-outils-bao/TREETAGGER/treetagger2xml-utf8.pl desc_tmp_tagged utf8");
    local $/=undef;
    open(FIC, "<:encoding(utf8)","desc_tmp_tagged.xml");
    my $desc_TTG_return = <FIC>;
    $desc_TTG_return =~ s/<\?xml.+?>//;
    close FIC;
    return $titre_TTG_return, $desc_TTG_return;
}

sub etiquetageTALISMANE
{   #Attention aux sorties dont les dépendances peuvent être incorrectes, certains items différents ont des dépendances entre elles, ce qu'il faut evidemment corriger. il faut donc des frontières entre chaque item et chaque titre et description. Si plusieurs ph dans chaque titre / desc, bien vérfifier qu'il ne se trompe pas.
    my $txt_Talismane = shift (@_);
    open(TMP, ">:encoding(utf8)","in_Tal.txt");
    print TMP $txt_Talismane;
    close TMP;
    unlink('titre_temp.txt');
    unlink('titre_temp_tagged.xml.xml');
    unlink('desc_temp.txt');
    unlink('desc_temp_tagged.xml.xml');
    # spécifier les bons chemins pour les ressources, et déplacer le french.zip dans dossier où l'on travail.
    system("java -Xmx1G -Dconfig.file=./ressources-outils-bao/TALISMANE/TALISMANE-BAO2019-DISTRIB/talismane-fr-5.0.4.conf -jar ./ressources-outils-bao/TALISMANE/TALISMANE-BAO2019-DISTRIB/talismane-core-5.1.2.jar --analyse --sessionId=fr --encoding=UTF8 --inFile=in_Tal.txt --outFile=Out_Tal.tal");
    my $etiq_tal_txt;
    local $/=undef;
    open(FIC, "<:encoding(utf8)","Out_Tal.tal");
    $etiq_tal_txt = <FIC>;
    close FIC1;
    return $etiq_tal_txt;
}
#-------------
#bout de code bao-3
#-------------
# my $lg=0;
# while (my $pos=$POS[$lg]) {
# 	foreach my $patron (@{$listePatron}) {
# 		if ($pos eq $patron->[0] ) {
# 			my $indice=1;
# 			my $longueur=1;
# 			my $stop=1;
# 			while (($indice <= scalar @$patron) and ($stop == 1)) {
# 				if ($POS[$indice+$lg] eq $patron->[$indice]) {
# 					$longueur++;
# 					$indice++;
# 				}
# 				else {
# 					$stop=0;
# 				}
# 			}
# 			if ($longueur == scalar @$patron) {
# 				$dicoPatron{join(" ",@{$patron})}->{join(" ",@WORDS[$indice+$lg-scalar @$patron..$indice+$lg-1])}++;
# 				$nbTerme++;
# 			}
# 		}
# 	}
# 	$lg++;
# }
# open my $fileResu,">:encoding(utf8)","perlIsTheBigOneBis.txt";
# print $fileResu "$nbTerme éléments trouvés\n";
# foreach my $patron (keys %dicoPatron) {
# 	print $fileResu "\nType de pattern: ".$patron." \n\n";
# 	foreach my $terme (sort {$dicoPatron{$patron}->{$b} <=> $dicoPatron{$patron}->{$a} } keys %{$dicoPatron{$patron}}) {
# 		print $fileResu $dicoPatron{$patron}->{$terme}."\t".$terme."\n";
# 	}
# }
# print $fileResu "\nScript execution time: " . tv_interval($timepg) . " seconds.";
# close($fileResu);