#! /usr/bin/perl
#
# Copyright (C) 2008-2021 Alexis Bienvenüe <paamc@passoire.fr>
#
# This file is part of Auto-Multiple-Choice
#
# Auto-Multiple-Choice is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation, either version 2 of
# the License, or (at your option) any later version.
#
# Auto-Multiple-Choice is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Auto-Multiple-Choice.  If not, see
# <http://www.gnu.org/licenses/>.

use warnings;
use 5.012;

use File::Copy;
use File::Spec::Functions
  qw/splitpath catpath splitdir catdir catfile rel2abs tmpdir/;
use File::Temp qw/ tempfile tempdir /;

use Module::Load;

use Getopt::Long;

use AMC::Basic;
use AMC::Gui::Avancement;
use AMC::Data;
use AMC::DataModule::scoring ':question';

use_gettext;
use_amc_plugins();

my $cmd_pid      = '';
my @output_files = ();

sub catch_signal {
    my $signame = shift;
    debug "*** AMC-prepare : signal $signame, transfered to $cmd_pid...";
    kill 9, $cmd_pid if ($cmd_pid);
    if (@output_files) {
        debug "Removing files that are beeing built: "
          . join( " ", @output_files );
        unlink(@output_files);
    }
    die "Killed";
}

$SIG{INT} = \&catch_signal;

# PARAMETERS

my $mode     = "mbs";
my $data_dir = "";
my $calage   = '';

my $latex_engine    = 'latex';
my @engine_args     = ();
my $engine_topdf    = '';
my $prefix          = '';
my $filter          = '';
my $filtered_source = '';
my $codedigit       = '';

my $latex_stdout = '';

my $n_procs          = 0;
my $number_of_copies = 0;

my $progress    = 1;
my $progress_id = '';

my $out_calage        = '';
my $out_sujet         = '';
my $out_corrige       = '';
my $out_corrige_indiv = '';
my $out_catalog       = '';

my $jobname = "amc-compiled";

my $f_tex;

my $epoch = '';

unpack_args();

GetOptions(
    "mode=s"              => \$mode,
    "with=s"              => \$latex_engine,
    "data=s"              => \$data_dir,
    "calage=s"            => \$calage,
    "out-calage=s"        => \$out_calage,
    "out-sujet=s"         => \$out_sujet,
    "out-corrige=s"       => \$out_corrige,
    "out-corrige-indiv=s" => \$out_corrige_indiv,
    "out-catalog=s"       => \$out_catalog,
    "latex-stdout!"       => \$latex_stdout,
    "progression=s"       => \$progress,
    "progression-id=s"    => \$progress_id,
    "prefix=s"            => \$prefix,
    "n-procs=s"           => \$n_procs,
    "n-copies=s"          => \$number_of_copies,
    "filter=s"            => \$filter,
    "filtered-source=s"   => \$filtered_source,
    "codedigit=s"         => \$codedigit,
    "epoch=s"             => \$epoch,
);

debug("AMC-prepare / DEBUG") if (get_debug());

my %global_opts = (qw/NoWatermarkExterne 1 NoHyperRef 1/);

# Split the LaTeX engine string, to get
#
# 1) the engine command $latex_engine (eg. pdflatex)
#
# 2) the engine arguments @engine_args to be passed to this command
#
# 3) the command used to make a PDF file from the engine output
# (eg. dvipdfmx)
#
# The LaTeX engine string is on the form
#   <latex_engine>[+<pdf_engine>] <engine_args>
#
# For exemple:
#
# pdflatex
# latex+dvipdfmx
# platex+dvipdfmx
# lualatex --shell-escape
# latex+dvipdfmx --shell-escape

sub split_latex_engine {
    my ($engine) = @_;

    $latex_engine = $engine if ($engine);

    if ( $latex_engine =~ /([^ ]+)\s+(.*)/ ) {
        $latex_engine = $1;
        @engine_args  = split( / +/, $2 );
    }

    if ( $latex_engine =~ /(.*)\+(.*)/ ) {
        $latex_engine = $1;
        $engine_topdf = $2;
    }
}

split_latex_engine();

sub set_filtered_source {
    my ($filtered_source) = @_;

    # change directory where the $filtered_source is, and set $f_base to
    # the $filtered_source without path and without extension

    my ( $v, $d, $f_base );

    ( $v, $d, $f_tex ) = splitpath($filtered_source);
    chdir( catpath( $v, $d, "" ) );
    $f_base = $f_tex;
    $f_base =~ s/\.tex$//i;

    # AMC usualy sets $prefix to "DOC-", but if $prefix is empty, uses
    # the base name

    $prefix = $f_base . "-" if ( !$prefix );
}

# Uses an AMC::Gui::Avancement object to tell regularly the calling
# program how much work we have done so far.

my $avance = AMC::Gui::Avancement::new( $progress, id => $progress_id );

# Get and test the source file

my $source = $ARGV[0];

die "Nonexistent source file: $source" if ( !-f $source );

# $base is the source file base name (with the path but without
# extension).

my $base = $source;
$base =~ s/\.[a-zA-Z0-9]{1,4}$//gi;

# $filtered_source is the LaTeX fil made from the source file by the
# filter (for exemple, LaTeX or AMC-TXT).

$filtered_source = $base . '_filtered.tex' if ( !$filtered_source );

# default $data_dir value (hardly ever used):

$data_dir = "$base-data" if ( !$data_dir );

# make these filenames global

for ( \$data_dir, \$source, \$filtered_source ) {
    $$_ = rel2abs($$_);
}

my $data = AMC::Data->new($data_dir);

set_filtered_source($filtered_source);

# set environment variables for reproducible output

if ($epoch) {
    $ENV{SOURCE_DATE_EPOCH}                = $epoch;
    $ENV{SOURCE_DATE_EPOCH_TEX_PRIMITIVES} = 1;
    $ENV{FORCE_SOURCE_DATE}                = 1;
}

# These variables are used to track errors from LaTeX compiling

my $a_errors;    # the number of errors
my @errors_msg   = ();    # errors messages (questions specifications problems)
my @latex_errors = ();    # LaTeX compilation errors

sub flush_errors {
    debug(@errors_msg);
    print join( '', @errors_msg );
    @errors_msg = ();
}

# %info_vars collects the variables values that LaTeX wants to give us

my %info_vars = ();

sub relay_info_vars {

    # Relays variables to calling process

    print "Variables :\n";
    for my $k ( keys %info_vars ) {
        print "VAR: $k=" . $info_vars{$k} . "\n";
    }
}

sub exit_with_error {
    relay_info_vars();
    exit(1);
}

# check_question checks that, if the question question is a simple
# one, the number of correct answers is exactly one.

sub check_question {
    my ($q) = @_;

    my $t = $q->{etu} . ":" . $q->{titre};

    # if postcorrection is used, this check cannot be made as we will
    # only know which answers are correct after having captured the
    # teacher's copy.
    return () if ( $info_vars{postcorrect} );

    # if is_alias is true, the questions has already been checked...
    return if ( $q->{is_alias} );

    $q = $q->{q};

    if ($q) {

        # For multiple questions, no problem. $q->{partial} means that
        # all the question answers have not yet been parsed (this can
        # happen when using AMCnumericChoices or AMCOpen, because the
        # answers are only given in the separate answer sheet).
        if ( !( $q->{mult} || $q->{partial} ) ) {
            my $n_correct = 0;
            my $n_total   = 0;
            for my $i ( grep { /^R/ } ( keys %$q ) ) {
                $n_total++;
                $n_correct++ if ( $q->{$i} );
            }
            if ( $n_correct != 1 && !$q->{indicative} ) {
                $a_errors++;
                push @errors_msg,
                  "ERR: "
                  . sprintf(
                    __("%d/%d good answers not coherent for a simple question")
                      . " [%s]\n",
                    $n_correct, $n_total, $t );
            }
        }
    }
}

# analyse_cslog get the chars written in the boxes from the catalog
# build, and updates the layout_char database accordingly

sub analyse_cslog {
    my ($cslog_file) = @_;

    my $layout = $data->module('layout');

    $layout->begin_transaction('Char');
    $layout->clear_char();
    open( CSLOG, $cslog_file ) or die "Unable to open $cslog_file: $!";
    while (<CSLOG>) {
        if (/\\answer\{.*:(\d+),(\d+)\}\{(.*)\}$/) {
            my $question = $1;
            my $answer   = $2;
            my $char     = $3;
            $layout->char( $question, $answer, $char );
        }
    }
    close(CSLOG);
    $layout->end_transaction('Char');
}

# analyse_amclog checks common errors in LaTeX about questions:
#
# * same question ID used multiple times for the same paper, or same
# answer ID used multiple times for the same question
#
# * simple questions with number of good answers != 1
#
# * answer given outside a question
#
# These errors can be detected parsing the *.amc log file produced by
# LaTeX compilation, through AUTOQCM[...] messages.

sub analyse_amclog {
    my ($amclog_file) = @_;

    my $analyse_data = { etu => 0, titre => '', qs => {} };
    my %titres       = ();
    @errors_msg = ();

    debug("Check AMC log : $amclog_file");

    open( AMCLOG, $amclog_file ) or die "Unable to open $amclog_file: $!";
    while (<AMCLOG>) {

        # AUTOQCM[Q=N] tells that we begin with question number N

        if (/AUTOQCM\[Q=([0-9]+)\]/) {

            # first check that the previous question is ok:
            check_question($analyse_data);

            # then clear current question data:
            $analyse_data->{q} = {};

            # if this question has already be seen for current student...
            if ( $analyse_data->{qs}->{$1} ) {

                if ( $analyse_data->{qs}->{$1}->{partial} ) {

                    # if the question was partial (answers was not given in the
                    # question, but are now given in the answer sheet), it's
                    # ok. Simply get back the data already processed, and clear
                    # 'partial' and 'closed' flags:

                    $analyse_data->{q} = $analyse_data->{qs}->{$1};
                    for my $flag (qw/partial closed/) {
                        delete( $analyse_data->{q}->{$flag} );
                    }
                } else {

                    # if the question was NOT partial, this is an error!

                    $a_errors++;
                    push @errors_msg,
                      "ERR: "
                      . sprintf(
                        __(
"question ID used several times for the same paper: \"%s\""
                          )
                          . " [%s]\n",
                        $titres{$1},
                        $analyse_data->{etu}
                      );
                }
            }

            # register question data
            $analyse_data->{titre} = $titres{$1};
            $analyse_data->{titre} = 'unknown'
              if ( !defined( $analyse_data->{titre} ) );
            $analyse_data->{qs}->{$1} = $analyse_data->{q};
        }

        # AUTOQCM[QPART] tells that we end with a question without having
        # given all the answers

        if (/AUTOQCM\[QPART\]/) {
            $analyse_data->{q}->{partial} = 1;
        }

        # AUTOQCM[FQ] tells that we have finished with the current question

        if (/AUTOQCM\[FQ\]/) {
            $analyse_data->{q}->{closed} = 1;
        }

        # AUTOQCM[ETU=N] tells that we begin with student number N.

        if (/AUTOQCM\[ETU=([0-9]+)\]/) {
            my $student = $1;

            # first check the last question from preceding student is ok:

            check_question($analyse_data);

            # then clear all $analyse_data to begin with this student:

            $analyse_data = { etu => $student, titre => '', qs => {} };
        }

        # AUTOQCM[BR=N] tells that this student is a replicate of student N

        if (/AUTOQCM\[BR=([0-9]+)\]/) {
            my $alias = $1;

            $analyse_data->{is_alias} = 1;
            $analyse_data->{alias}    = $alias;    # unused ;)
        }

        # AUTOACM[NUM=N=ID] tells that question number N (internal
        # question number, not the question number shown on the sheet)
        # refers to ID (question name, string given as an argument to
        # question environment)

        if (/AUTOQCM\[NUM=([0-9]+)=(.+)\]/) {

            # stores this association (two-way)

            $titres{$1} = $2;
            $analyse_data->{titres}->{$2} = 1;
        }

        # AUTOQCM[MULT] tells that current question is a multiple question

        if (/AUTOQCM\[MULT\]/) {
            $analyse_data->{q}->{mult} = 1;
        }

        # AUTOQCM[INDIC] tells that current question is an indicative
        # question

        if (/AUTOQCM\[INDIC\]/) {
            $analyse_data->{q}->{indicative} = 1;
        }

        # AUTOQCM[REP=N:S] tells that answer number N is S (S can be 'B'
        # for 'correct' or 'M' for wrong)

        if (/AUTOQCM\[REP=([0-9]+):([BM])\]/) {
            my $rep = "R" . $1;

            if ( $analyse_data->{q}->{closed} ) {

                # If current question is already closed, this is an error!

                $a_errors++;
                push @errors_msg,
                  "ERR: "
                  . sprintf(
                    __(
"An answer appears to be given outside a question environment, after question \"%s\""
                      )
                      . " [%s]\n",
                    $analyse_data->{titre},
                    $analyse_data->{etu}
                  );
            }

            if ( defined( $analyse_data->{q}->{$rep} ) ) {

                # if we already saw an answer with the same N, this is an error!

                $a_errors++;
                push @errors_msg,
                  "ERR: "
                  . sprintf(
                    __(
"Answer number ID used several times for the same question: %s"
                      )
                      . " [%s]\n",
                    $1,
                    $analyse_data->{titre}
                  );
            }

            # stores the answer's status
            $analyse_data->{q}->{$rep} = ( $2 eq 'B' ? 1 : 0 );
        }

        # AUTOQCM[VAR:N=V] tells that variable named N has value V

        if (/AUTOQCM\[VAR:([0-9a-zA-Z.:-]+)=([^\]]+)\]/) {
            $info_vars{$1} = $2;
        }

    }
    close(AMCLOG);

    # check that the last question from the last student is ok:

    check_question($analyse_data);

    # Send error messages to the calling program through STDOUT

    flush_errors();

    debug("AMC log $amclog_file : $a_errors errors.");
}

# execute(%oo) launches the LaTeX engine with the right arguments, call it
# again if needed (for exemple when a second run is necessary to get
# references right), and then produces a PDF file from LaTeX output.
#
# $oo{command_opts} should be the options to be passed to latex_cmd, to
# build the LaTeX command to run, with all necessary arguments

my $filter_engine;

sub execute {
    my %oo   = (@_);
    my $errs = 0;

    prepare_filter();

    # gives the processing command to the filter
    $oo{command}  = [ latex_cmd( @{ $oo{command_opts} } ) ];
    $ENV{AMC_CMD} = join( ' ', @{ $oo{command} } );

    if ($filter) {
        if (  !$filter_engine->get_filter_result('done')
            || $filter_engine->get_filter_result('jobspecific') )
        {
            $errs = do_filter();
            $filter_engine->set_filter_result( 'done', 1 ) if ( !$errs );
        }
    }

    # first removes previous run's outputs

    for my $ext (qw/pdf dvi ps/) {
        if ( -f "$jobname.$ext" ) {
            debug "Removing old $ext";
            unlink("$jobname.$ext");
        }
    }

    exit_with_error() if ($errs);

    # the filter could have changed the latex engine, so update it
    $oo{command}  = [ latex_cmd( @{ $oo{command_opts} } ) ];
    $ENV{AMC_CMD} = join( ' ', @{ $oo{command} } );

    check_engine();

    my $min_runs = 1;     # minimum number of runs
    my $max_runs = 2;     # maximum number of runs
    my $n_run    = 0;     # number of runs so far
    my $rerun    = 0;     # has to re-run?
    my $format   = '';    # output format

    do {

        $n_run++;

        # clears errors from previous run

        $a_errors     = 0;
        @latex_errors = ();

        debug "%%% Compiling: pass $n_run";

        # lauches the command

        debug "COMMAND: $ENV{AMC_CMD}";

        $cmd_pid = open( EXEC, "-|", @{ $oo{command} } );
        die "Can't exec " . join( ' ', @{ $oo{command} } ) if ( !$cmd_pid );

        # parses the output

        while (<EXEC>) {

            # LaTeX Warning: Label(s) may have changed. Rerun to get
            # cross-references right. -> has to re-run

            $rerun = 1
              if (/^LaTeX Warning:.*Rerun to get cross-references right/);
            $min_runs = 2
              if (/Warning: .*run twice/);

            # Output written on jobname.pdf (10 pages) -> output
            # format is pdf

            $format = $1 if (/^Output written on .*\.([a-z]+) \(/);

            # Lines beginning with '!' are errors: collect them

            if (/^\!\s*(.*)$/) {
                my $e = $1;
                $e .= "..." if ( $e !~ /\.$/ );
                push @latex_errors, $e;
            }

            # detect style file path

            if (m=\(((?:[^\)]+/)?automultiplechoice.sty)(\)|$)=) {
                $info_vars{stypath} = $1;
            }

            # detect style file version

            if (/^AMC version: (.*)/) {
                $info_vars{styversion} = $1;
            }

            # Relays LaTeX log to calling program

            print STDERR $_ if (/^.+$/);
            print $_ if ( $latex_stdout && /^.+$/ );
        }
        close(EXEC);
        $cmd_pid = '';

    } while ( ( ( $n_run < $min_runs ) || ( $rerun && $n_run < $max_runs ) )
        && !$oo{once} );

    # For these engines, we already know what is the output format:
    # override detected one

    $format = 'dvi' if ( $latex_engine eq 'latex' );
    $format = 'pdf' if ( $latex_engine eq 'pdflatex' );
    $format = 'pdf' if ( $latex_engine eq 'xelatex' );

    print "Output format: $format\n";
    debug "Output format: $format\n";

    # Now converts output to PDF. Output format can be DVI or PDF. If
    # PDF, nothing has to be done...

    if ( $format eq 'dvi' ) {
        if ( -f "$jobname.dvi" ) {

            # default DVI->PDF engine is dvipdfmx

            $engine_topdf = 'dvipdfm'
              if ( !$engine_topdf );

            # if the choosend DVI->PDF engine is not present, try to get
            # another one

            if ( !commande_accessible($engine_topdf) ) {
                debug_and_stderr "WARNING: command $engine_topdf not available";
                $engine_topdf =
                  choose_command( 'dvipdfmx', 'dvipdfm', 'xdvipdfmx',
                    'dvipdf' );
            }

            if ($engine_topdf) {

                # Now, convert DVI to PDF

                debug "Converting DVI to PDF with $engine_topdf ...";
                if ( $engine_topdf eq 'dvipdf' ) {
                    system_debug( cmd =>
                          [ $engine_topdf, "$jobname.dvi", "$jobname.pdf" ] );
                } else {
                    system_debug(
                        cmd => [
                            $engine_topdf,  "-o",
                            "$jobname.pdf", "$jobname.dvi"
                        ]
                    );
                }
            } else {

                # No available DVI->PDF engine!

                debug_and_stderr
                  "ERROR: I can't find dvipdf/dvipdfm/xdvipdfmx command !";
            }
        } else {
            debug "No DVI";
        }
    }

}

# do_filter() converts the source file to LaTeX format, using the
# right AMC::Filter::* module

sub prepare_filter {
    if ($filter) {
        if ( !$filter_engine ) {
            load("AMC::Filter::$filter");
            $filter_engine = "AMC::Filter::$filter"->new( jobname => $jobname );
            $filter_engine->pre_filter($source);

            # sometimes the filter says that the source file don't need to
            # be changed

            set_filtered_source($source)
              if ( $filter_engine->unchanged );
        }
    } else {

        # Empty filter: the source is already a LaTeX file
        set_filtered_source($source);
    }
}

sub do_filter {
    my $n_err = 0;

    if ($filter) {

        # Loads and call appropriate filter to convert $source to
        # $filtered_source

        prepare_filter();
        $filter_engine->filter( $source, $filtered_source );

        # show conversion errors

        for ( $filter_engine->errors() ) {
            print "ERR: $_\n";
            $n_err++;
        }

        # sometimes the filter asks to override the LaTeX engine

        split_latex_engine(
            $filter_engine->{project_options}->{moteur_latex_b} )
          if ( $filter_engine->{project_options}->{moteur_latex_b} );

        # or to set the number of copies to a particular value

        $number_of_copies =
          $filter_engine->{project_options}->{'nombre_copies'}
          if (
            exists(
                $filter_engine->{project_options}->{'nombre_copies'}
            )
          );

    }

    return ($n_err);
}

# give_latex_errors($context) Relay suitably formatted LaTeX errors to
# calling program (usualy AMC GUI). $context is the name of the
# document we are building.

sub give_latex_errors {
    my ($context) = @_;
    if (@latex_errors) {
        print "ERR: <i>"
          . sprintf( __("%d errors during LaTeX compiling") . " (%s)</i>\n",
            ( 1 + $#latex_errors ), $context );
        for (@latex_errors) {
            print "ERR>$_\n";
        }
        exit_with_error();
    }
}

# transfer($orig,$dest) moves $orig to $dest, removing $dest if $orig
# does not exist

sub transfer {
    my ( $orig, $dest ) = @_;
    if ( -f $orig ) {
        debug "Moving $orig --> $dest";
        move( $orig, $dest );
    } else {
        debug "No source: removing $dest";
        unlink($dest);
    }
}

# latex_reprocucible_commands($engine) returns commands suitable for
# the given engine to get reproducible output.

sub latex_reproducible_commands {
    my ($engine) = @_;
    if ( $engine eq 'pdflatex' ) {
        return ("\\pdfinfo{ /Producer (LaTeX) /Creator () }\\pdfsuppressptexinfo=-1\\pdftrailerid{}");
    } else {
        return ("");
    }
}

# latex_cmd(%o) builds the LaTeX command and arguments to be passed to
# the execute command, using the engine specifications and extra
# options %o to pass to LaTeX: for each name=>value from %o, a LaTeX
# command '\def\name{value}' is passed to LaTeX through the
# jobname-config.tex, that will be read by the automultiplechoice
# package. This allows to relay some options to LaTeX (number of
# copies, document needed for exemple).

sub latex_cmd {
    my (%o) = @_;

    $o{AMCNombreCopies} = $number_of_copies if ( $number_of_copies > 0 );

    # build a configuration tex file, that will be read by the
    # autoultiplechoice LaTeX package, from the %o options:
    open( CONFIG, ">:utf8", "$jobname-config.tex" )
      or die "Unable to open config file: $!";
    print CONFIG latex_reproducible_commands($latex_engine) if ($epoch);
    for my $k ( keys %o ) {
        print CONFIG "\\def\\" . $k . "{" . $o{$k} . "}";
    }
    print CONFIG "\n";
    close(CONFIG);

    return ( $latex_engine, "--jobname=" . $jobname,
        "-interaction=nonstopmode", @engine_args, $f_tex );
}

# check_engine() checks that the requeted LaTeX engine is available on
# the system

sub check_engine {
    if ( !commande_accessible($latex_engine) ) {
        print "ERR: "
          . sprintf(
            __(
"LaTeX command configured is not present (%s). Install it or change configuration, and then rerun."
            ),
            $latex_engine
          ) . "\n";
        exit_with_error();
    }
}

# the $mode option passed to AMC-prepare contains characters that
# explains what is to be prepared...

my %to_do = ();
while ( $mode =~ s/^[^a-z]*([a-z])(\[[a-z]*\])?//i ) {
    $to_do{$1} = ( defined($2) ? $2 : 1 );
}

############################################################################
# MODE f: filter source file to LaTeX format
############################################################################

if ( $to_do{f} ) {

    # FILTER
    do_filter();
}

############################################################################
# MODE S: builds the solution
############################################################################

sub build_solution {
    execute( command_opts => [ %global_opts, CorrigeExterne => 1 ] );
    transfer( "$jobname.pdf", $out_corrige );
    give_latex_errors( __ "solution" );
}

if ( $to_do{S} ) {
    build_solution();
}

############################################################################
# MODE C: builds the catalog
############################################################################

sub build_catalog {
    execute( command_opts => [ %global_opts, CatalogExterne => 1 ] );
    transfer( "$jobname.pdf", $out_catalog );
    analyse_cslog("$jobname.cs");
    give_latex_errors( __ "catalog" );
}

if ( $to_do{C} ) {
    build_catalog();
}

############################################################################
# MODE s: builds the subject and a solution (with all the answers for
# questions, but with a different layout)
############################################################################

if ( $to_do{s} ) {
    $to_do{s} = '[sc]' if ( $to_do{s} eq '1' );

    @output_files = ( $out_sujet, $out_calage, $out_corrige, $out_catalog );

    $out_calage  = $prefix . "calage.xy"   if ( !$out_calage );
    $out_corrige = $prefix . "corrige.pdf" if ( !$out_corrige );
    $out_catalog = $prefix . "catalog.pdf" if ( !$out_catalog );
    $out_sujet   = $prefix . "sujet.pdf"   if ( !$out_sujet );

    for my $f ( $out_calage, $out_corrige, $out_corrige_indiv, $out_sujet,
        $out_catalog )
    {
        if ( -f $f ) {
            debug "Removing already existing file: $f";
            unlink($f);
        }
    }

    # 1) SUBJECT

    my $report = $data->module('report');

    $report->begin_transaction("prtX");
    $report->printed_clear();
    $report->end_transaction("prtX");

    execute( command_opts => [ %global_opts, SujetExterne => 1 ] );
    analyse_amclog("$jobname.amc");
    give_latex_errors( __ "question sheet" );

    if ( $a_errors > 0 ) {
        debug("$a_errors errors detected: EXIT");
        exit_with_error();
    }

    transfer( "$jobname.pdf", $out_sujet );
    transfer( "$jobname.xy",  $out_calage );

    # Looks for accents problems in question IDs...

    my %qids        = ();
    my $unknown_qid = 0;
    if ( open( XYFILE, $out_calage ) ) {
        binmode(XYFILE);
        while (<XYFILE>) {
            if ( !utf8::decode($_) || /\\IeC/ ) {
                if (
/\\tracepos\{[^:]*:[^:]*:(.+):[^:]*\}\{([+-]?[0-9.]+[a-z]*)\}\{([+-]?[0-9.]+[a-z]*)\}(?:\{([a-zA-Z]*)\})?$/
                  )
                {
                    $qids{$1} = 1;
                } else {
                    $unknown_qid = 1;
                }
            }
        }
        close(XYFILE);
        if (%qids) {
            push @errors_msg, map {
                "WARN: "
                  . sprintf(
                    __(
"please remove accentuated or non-standard characters from the following question ID: \"%s\""
                    ),
                    $_
                  )
                  . "\n"
            } ( sort { $a cmp $b } ( keys %qids ) );
        } elsif ($unknown_qid) {
            push @errors_msg,
              "WARN: "
              . __(
"some question IDs seems to have accentuated or non-standard characters. This may break future processings."
              ) . "\n";
        }
    }
    flush_errors();

    # 2) SOLUTION

    if ( $to_do{s} =~ /s/ ) {
        build_solution();
    } else {
        debug "Solution not requested: removing $out_corrige";
        unlink($out_corrige);
    }

    # 3) CATALOG

    if ( $to_do{s} =~ /c/ ) {
        build_catalog();
    } else {
        debug "Catalog not requested: removing $out_catalog";
        unlink($out_catalog);
    }
}

############################################################################
# MODE k: builds individual corrected answer sheets (exactly the same
# sheets as for the students, but with correct answers ticked).
############################################################################

if ( $to_do{k} ) {

    my $of = $out_corrige_indiv;
    $of = $out_corrige            if ( !$of && !$to_do{s} );
    $of = $prefix . "corrige.pdf" if ( !$of );

    if ( -f $of ) {
        debug "Removing already existing file: $of";
        unlink($of);
    }

    @output_files = ($of);

    execute( command_opts => [ %global_opts, qw/CorrigeIndivExterne 1/ ] );
    transfer( "$jobname.pdf", $of );
    give_latex_errors( __ "individual solution" );
}

############################################################################
# MODE b: extracts the scoring strategy to the scoring database,
# parsing the AUTOQCM[...] messages from the LaTeX output.
############################################################################

if ( $to_do{b} ) {

    print "********** Making marks scale...\n";

    my %bs     = ();
    my %titres = ();

    my $quest         = '';
    my $rep           = '';
    my $outside_quest = '';
    my $etu           = 0;

    my $delta = 0;

    # Opens a connection with the database

    my $scoring = $data->module('scoring');
    my $capture = $data->module('capture');

    # Launches the LaTeX engine

    my @opts = (qw/ScoringExterne 1 NoHyperRef 1/);

    if ( !$codedigit ) {

        # if not explicitly given, uses the same codedigit convention
        # as recorded from the 'extract layout' phase
        my $layout = $data->module('layout');
        $codedigit = $layout->variable_transaction('build:codedigit');
        $codedigit = 'dot' if ( !$codedigit );    # old AMC versions
    }
    if ($codedigit) {
        push @opts, "codeDigitExterne", $codedigit;
    }

    execute(
        command_opts => [@opts],
        once         => 1
    );

    open( AMCLOG, "$jobname.amc" ) or die "Unable to open $jobname.amc : $!";

    my $qs                    = {};
    my $qs0                   = {}; # memory for student 0 (when using AMCformS)
    my $current_q             = {};
    my $qs0_count             = 0;
    my $finished_with_student = 0;

    # and parse the log...

    $scoring->begin_transaction('ScEx');
    annotate_source_change($capture);
    $scoring->clear_strategy;

  PARSELOG: while (<AMCLOG>) {
        debug($_) if ($_);

        # AUTOQCM[TOTAL=N] tells that the total number of sheets is
        # N. This will allow us to relay the progression of the
        # process to the calling process.

        if (/AUTOQCM\[TOTAL=([\s0-9]+)\]/) {
            my $t = $1;
            $t =~ s/\s//g;
            if ( $t > 0 ) {
                $delta = 1 / $t;
            } else {
                print "*** TOTAL=$t ***\n";
            }
        }

        if (/AUTOQCM\[ETU=([0-9]+)\]/) {

            # save if student 0
            $qs0 = $qs if ( $etu == 0 );

            # beginning of student sheet
            $avance->progres($delta) if ( $etu ne '' );
            $etu = $1;
            print "Sheet $etu...\n";
            debug "Sheet $etu...\n";
            $qs                    = {};
            $finished_with_student = 0;
        }

        next PARSELOG if ($finished_with_student);

        if (/AUTOQCM\[FQ\]/) {

            # end of question: register it (or update it)
            $scoring->new_question(
                $etu,
                $quest,
                ( $current_q->{multiple} ? QUESTION_MULT : QUESTION_SIMPLE ),
                $current_q->{indicative},
                $current_q->{strategy}
            );
            $qs->{$quest}  = $current_q;
            $outside_quest = $quest;
            $quest         = '';
            $rep           = '';
        }

        if (/AUTOQCM\[Q=([0-9]+)\]/) {

            # beginning of question
            $quest = $1;
            $rep   = '';
            if ( $qs->{$quest} ) {
                $current_q = $qs->{$quest};
            } else {
                $current_q = {
                    multiple   => 0,
                    indicative => 0,
                    strategy   => '',
                };
            }
        }

        if (/AUTOQCM\[NUM=([0-9]+)=(.+)\]/) {

            # association question-number<->question-title
            $scoring->question_title( $1, $2 );
        }

        if (/AUTOQCM\[MULT\]/) {

            # this question is a multiple-style one
            $current_q->{multiple} = 1;
        }

        if (/AUTOQCM\[INDIC\]/) {

            # this question is an indicative one
            $current_q->{indicative} = 1;
        }

        if (/AUTOQCM\[REP=([0-9]+):([BM])\]/) {

            # answer
            $rep = $1;
            my $qq = $quest;
            if ( $outside_quest && !$qq ) {
                $qq = $outside_quest;
                debug_and_stderr
"WARNING: answer outside questions for student $etu (after question $qq)";
            }
            $scoring->new_answer( $etu, $qq, $rep, ( $2 eq 'B' ? 1 : 0 ), '' );
        }

        # AUTOQCM[BR=N] tells that this student is a replicate of student N

        if (/AUTOQCM\[BR=([0-9]+)\]/) {
            my $alias = $1;

            $scoring->replicate( $alias, $etu );
            $etu                   = $alias;
            $qs                    = $qs0 if ( $etu == 0 );
            $finished_with_student = 1 if ( $qs0_count > 0 );
            $qs0_count++;
        }

        if (/AUTOQCM\[B=([^\]]+)\]/) {

            # scoring strategy string
            if ($quest) {
                if ($rep) {

                    # associated to an answer
                    $scoring->add_answer_strategy( $etu, $quest, $rep, $1 );
                } else {

                    # associated to a question
                    $current_q->{strategy} = (
                          $current_q->{strategy}
                        ? $current_q->{strategy} . ','
                        : ''
                    ) . $1;
                }
            } else {

                # global scoring strategy, associated to a student if
                # $etu>0, or to all students if $etu==0
                $scoring->add_main_strategy( $etu, $1 );
            }
        }

        # AUTOQCM[BDS=string] gives us the default scoring stragety
        # for simple questions
        # AUTOQCM[BDM=string] gives us the default scoring stragety
        # for multiple questions

        if (/AUTOQCM\[BD(S|M)=([^\]]+)\]/) {
            $scoring->default_strategy(
                ( $1 eq 'S' ? QUESTION_SIMPLE : QUESTION_MULT ), $2 );
        }

        if (/AUTOQCM\[VAR:([0-9a-zA-Z.-]+)=([^\]]+)\]/) {

            # variables
            my $name  = $1;
            my $value = $2;
            $name = 'postcorrect_flag' if ( $name eq 'postcorrect' );
            $scoring->variable( $name, $value );
        }
    }
    close(AMCLOG);

    $scoring->end_transaction('ScEx');
}

relay_info_vars();

$avance->fin();
