use strict;
use iterd;
use filtreur;
use tagger;
use pms;

use XML::LibXML;
use XML::Parser;
use Data::Dumper;
#
<<DOC; 
Votre Nom :  Yannick LAM
JANVIER 2006
 usage : perl parcours-arborescence-fichiers repertoire-a-parcourir
 Le programme prend en entrée le nom du répertoire contenant les fichiers
 à traiter
perl projet.pl /tmp/proj /home/yan/treetager/cmd/tree-tagger-french "NOM ADJ"
 Le programme construit en sortie un fichier structuré contenant sur chaque
 ligne le nom du fichier et le résultat du filtrage :
<FICHIER><NOM>du fichier</NOM></FICHIER><CONTENU>du filtrage</CONTENU></FICHIER>
DOC
#
my $rep="$ARGV[0]";  # Nom du répertoir à parcourir
$rep=~ s/[\/]$//;    # on s'assure que le nom du répertoire ne se termine pas par un "/"
#
# Nom de la commande à lancer pour tree-tagger
#
my $tagcmd="$ARGV[1]"; 
if ( ! (-f $tagcmd && -x $tagcmd ) )  {
    print "Fichier $tagcmd introuvable ou non executable \n ";
    exit;
}
#
# 1. On ouvre le fichier qui va cumuler le texte à étiqueter
#
my $tagfile = "/tmp/tagfile" . $$ ;
open (HANDLETAG,">:utf8",$tagfile) or die("$!");
my $refhand = \*HANDLETAG ;
#
# 2. On initialise une map pour la correspondance texte => fichier xml
#
my $mapfromfile = {} ;
#
# NBR sert de compteur pour indexer les fichiers
# ( oui, je sais .. c'est une variable globale .. )
#
my $NBR = 0 ; 
#
# 2. On crée un itérateur ( voir classe iterd ci joint ) pour parcourir l'arborescence.
#    il appellera la fonction extract ( ci dessous ) sur chaque fichier
#    en lui passant l'info dont elle a besoin.
#
print "Parcours et extraction de $rep ..\n";
my $walker = new iterd();
$walker->setFunction ( \&extract ) ;
my $data = {'tagfile' => $refhand , 'fromfile' => $mapfromfile };
$walker->setData ($data) ;
$walker->traverse($rep) ;
close ($refhand) ;
#
# 3. Envoyer l'étiquetage sur le résultat. Pour Cordial, il faudrait une version automatique..
#
print "Etiquetage.. \n";
my $tagger = new tagger();
$tagger->setCommand ( $tagcmd );
$tagger->setTextAsFile ($tagfile);
$tagger->process();
#unlink($tagfile);
#
# 4. Lire le résultat et fabriquer le document final.
#
print "Ecriture des résultats.. \n";
$tagger->trimChars();
my $refarr = $tagger->getMotTagLemme();

#
my $dom = XML::LibXML::Document->createDocument( "1.0", "UTF-8" );
my $root = $dom->createElement( "PARCOURS" );
$dom->setDocumentElement( $root );
my $nom = $dom->createElement( "nom" );
$nom->appendTextNode( "Yannick LAM" );
$root->appendChild($nom);
my $filtrage = $dom->createElement( "ETIQUETAGE" );
$root->appendChild($filtrage);
#
#
my $hook ;
foreach my $v (@$refarr) {
    my $mot = $v->[0];
    if ( $mot =~ m/__\{FROMFILE[0-9]+\}__/ ) {
	if ( exists ( $mapfromfile->{$mot} ) ) {
	    # 
	    # On est sur un indicateur de fichiers
	    # On récupère son nom et on crée la balise <file>
	    # on met le nom dans l'attribut "nom"
	    $hook = $dom->createElement("file");
	    $hook->setAttribute("nom",$mapfromfile->{$mot});
	    $filtrage->appendChild($hook) ;
	} else {
	    print "Erreur : Un mot du texte a la forme d'une clé : $mot  \n";
	}
    } else {
	# $hook est le noeud auquel il faut accrocher les résultats
	#
	#print " mot = $v->[0] tag = $v->[1] lem = $v->[2]\n"; 
	my $word = $dom->createElement("w");
	if ( $v->[2] =~ m/<unknown>/ ) {
	    $word->setAttribute("lemma","unknown");
	} else {
	    $word->setAttribute("lemma",$v->[2]);
	}
	$word->setAttribute("type",$v->[1]);
	$word->appendTextNode( $v->[0] );
	$hook->appendChild($word);
    }
}
#
# Ecrire le fichier de résultats.
#
$dom->toFile("SORTIE.xml", 2);
#
# Exemple de récup des patrons morpho-syntaxique. 
# dans la sortie de tree-tagger ( tableau @$refarr )
# $ARGV[2] "NOM ADJ"
#
if ( defined ($ARGV[2]) ) {
    my $pms = new pms ( $refarr ) ;

    $pms->search($ARGV[2]);

    my $nompropres = '\b[^\Wa-z0-9_][^\WA-Z0-9_]*\b';
    $pms->filterBoth($nompropres);
    $pms->getPMSAsDocument("patronsAsXML.xml" , "UTF-8");
    $pms->getPMSAsGraphML("patronsgraphML.xml", "iso-8859-1");
    $pms->getPMSAsText("patronsAsText.txt" , "UTF-8");
    $pms->getPMSAsPajek("patronsAsPajek.net");
}
#
#
#FIN
#########################################################################################
#
# Fonction extract:
# 
# Elle est appelée sur chaque fichier xml de l'arborescence. 
# Elle recoit 2 arguments :
# file est le nom du fichier à traiter
# data est une map de 2 éléments: 
# intag : un descripteur qui point sur le fichier dans lequel elle ecrit
# fromfile : une map faisant correspondre une clé au nom du fichier d'où provient le texte
#
sub extract {

    my ($file,$data) = @_;
    my $tagfile = $data->{tagfile};
    my $fromfile = $data->{fromfile};
    #
    # 1.On crée un filtreur  pour $file
    #
    my $flt = new filtreur();
    $flt->reset();
    $flt->setFile($file);
    #
    # 2.On veut les balises qui s'appellent "description" 
    # ( en fait faudrait utiliser XPath .. )
    #
    $flt->setElementName("description");
    # Go...
    $flt->process();
    # OK..
    my @tabres = $flt->getStuffAsArray();
    #
    # le tableau tabres contient autant d'éléments
    # que de balises "description".
    # On écrit tout ça dans $tagfile
    #
    $NBR++ ;
    my $key = "__{"."FROMFILE"."${NBR}"."}__" ;
    $fromfile->{$key}=$file;
    print $tagfile "$key\n";
    foreach my $v (@tabres) {
	print $tagfile "$v\n"
    }

    return ;
}
