package tagger;

use Data::Dumper;
use IO::File;
use POSIX qw(tmpnam);
use strict;

# class tagger: Encapsule l'utilisation de tree-tagger
#
sub new {
    my ($class,$file) = @_ ;
    $class = ref($class) || $class ;
    my $this = {};
    bless($this, $class);
    $this->{COMMAND} = \&undef;
    $this->{TEXT} = [];      # Le texte
    $this->{MOTAGLEM} = () ; # table de références vers le triplet du tagger
    $this->{DUMPFILE} = 0  ; # faut il garder la sortie du tagger
    $this->{DUMPNAME} = "" ; # dans ce fichier
    $this->{TRIM}     = "" ; # faut il filtrer ?
    $this->{MTLTRIM}  = () ; # idem que MOTAGLEM mais filtrée 
    return $this;
}
#
# configure la commande ( full path ) pour lancer le tagger
# retournera un statut en fonction de xxx.
#
sub setCommand {
    my ($this,$command) = @_ ;
    # tester commande existe ou que le full path est OK.
    $this->{COMMAND}=$command;
    # créer un fichier temporaire pour le texte ici ??
    return ;
}
# 
# Stocke le texte à tagger
# ( reference sur un tableau : chaque elem est une ligne du texte )
#
sub setText {
    my ($this,$text) = @_ ; 
    $this->{TEXT} = $text;
    return ;
}
#
# idem que ci dessus mais prend un fichier texte en entrée.
#
sub setTextAsFile {
    my ($this,$infile) = @_ ; 
    open(FIC,"<$infile") ;
    my @tab = <FIC>;
    $this->{TEXT} = \@tab ; 
    close ( FIC ) ;
    return ;
}
#
# On veut garder le résultat de l'étiquetage dans $file
#
sub setTrace {
    my ($this,$file) = @_ ; 
    $this->{DUMPFILE} = 1;
    $this->{DUMPNAME} = $file ;
} 
#
# On ne veut pas des lignes pour lesquelles le mot 
# contient un caractère dans $string
# 
sub trimChars {
    my ($this) = @_ ;
    $this->{TRIM} = "word" ;
}
#
# Retourne le tableau des triplets mot.tag.lemme
# éventuellement filtré. pour l'instant QUE DES MOTS \w
# sauf si le mot commence par __ ( séparateur reconnu )
sub getMotTagLemme {
    my ($this) = @_ ; 
    if ( $this->{TRIM} eq "" ) {
	return $this->{MOTAGLEM};
    } else {
	foreach my $r (@{$this->{MOTAGLEM}}) {
	    my $mot = $r->[0] ;
	    if ( $mot =~ m/^\w+$/ || $mot =~ m/^__/) {
		push ( @{$this->{MTLTRIM}} , $r ) 
	    }
	}
	return $this->{MTLTRIM};
    }
}
#
# lance le traitement et remplit le champ MOTAGLEM
# en cas d'erreur retourne 0
# Pour l'instant , le traitement consiste à écrire le texte à tagger dans le fichier 
# temporaire et envoyer la commande qui va bien.
# Il faudrait faire ça avec une IPC. ( version suivante pour le projet )
#
sub process {
    my ($this) = @_ ; 
    # faudra faire ça proprement
    my $filout = "/tmp/tagout" . $$ ;
    my $filerr = "/tmp/tagerr" . $$ ;
    if ( ! open ( FIC , ">$filout" ) ) {
	return 0;
    }
    foreach my $lin (@{$this->{TEXT}}) {
	printf ( FIC "%s\n" , $lin ); 
    }
    close ( FIC ) ;
    my $cmd = $this->{COMMAND} . " < " . $filout . " 2> " . $filerr ;
    if ( $this->{DUMPFILE} == 1 ) {
	open(DUMP , ">$this->{DUMPNAME}") ;
    }
    open(TREETAG, "$cmd |" );
    my $l ;
    while ( defined( $l = <TREETAG> ) ) {
	chomp $l;
	my @tab = ();
	@tab = split (/\t/ , $l);
	push ( @{$this->{MOTAGLEM}} , \@tab ) ;
	if ( $this->{DUMPFILE} == 1 ) {
	    print DUMP "$l\n";
	}
    }
    if ( $this->{DUMPFILE} == 1 ) {
	close ( DUMP ) ;
    }
    unlink $filout;
    unlink $filerr;
    return 1 ;
}
#
# 
#
sub writeMTL {
    my ($this,$file) = @_ ;
    open (HANDLE,">:utf8",$file) or die("$!");
    print HANDLE Dumper($this->{MOTAGLEM});
    close ( HANDLE ) ;
}
#
#
#
sub readMTL {
    my ($this,$file) = @_ ;
    open (HANDLE,"<:utf8",$file) or die("$!");
    my $l = "" ;
    my $str = "" ;
    while ( defined( $l = <HANDLE> ) ) {
	$str .= $l;
    }
    close ( HANDLE ) ;
    $this->{MOTAGLEM} = eval $str  ;
}

1;
