#! /usr/bin/perl
#
# Copyright (C) 2008-2017 Alexis Bienvenue <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 utf8;

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

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 $debug='';
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='';

@ARGV=unpack_args(@ARGV);

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,
	   "convert-opts=s"=>\$convert_opts,
	   "debug=s"=>\$debug,
	   "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,
           "epoch=s"=>\$epoch,
	   );

set_debug($debug);

debug("AMC-prepare / DEBUG") if($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

  ($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($$_);
}

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,$t)=@_;

    # 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($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 $data=AMC::Data->new($data_dir);
  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,qs=>{}};
  my $analyse_data_s0={}; # backup for student 0
  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->{q},$analyse_data->{etu}.":".$analyse_data->{titre});

      # 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->{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;

      # backup

      $analyse_data_s0=$analyse_data if($analyse_data->{etu}==0);

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

      check_question($analyse_data->{q},$analyse_data->{etu}.":".$analyse_data->{titre});

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

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

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

    if(/AUTOQCM\[BR=([0-9]+)\]/) {
      my $alias=$1;
      die "Unimplemented positive student alias" if($alias!=0);

      my $student=$analyse_data->{etu};
      $analyse_data=Clone::clone($analyse_data_s0);
      $analyse_data->{etu}=$student;
    }

    # 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->{q},$analyse_data->{etu}.":".$analyse_data->{titre});

  # 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($engine_topdf,"$jobname.dvi","$jobname.pdf");
	    } else {
	      system($engine_topdf,"-o","$jobname.pdf","$jobname.dvi");
	    }
	    debug_and_stderr "ERROR $engine_topdf: $?" if($?);
	  } 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 $f_base;
  my $v;
  my $d;
  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'});

  }

  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("\\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. 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);

    return($latex_engine,
	   "--jobname=".$jobname,
	   @engine_args,
	   "\\nonstopmode"
	   .join('',map { "\\def\\".$_."{".$o{$_}."}"; } (keys %o) )
           .($epoch ? latex_reproducible_commands($latex_engine) : "")
	   ."\\input{\"$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

  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;

    # Launches the LaTeX engine

    execute('command_opts'=>[qw/ScoringExterne 1 NoHyperRef 1/],
	    'once'=>1);

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

    # Opens a connection with the database

    my $data=AMC::Data->new($data_dir);
    my $scoring=$data->module('scoring');
    my $capture=$data->module('capture');

    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;
          die "Unimplemented positive student alias" if($alias!=0);
	  $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();
