/**
 * Extract features and score statistics from nvest file, optionally merging with
 * those from the previous iteration.
 * Developed during the 2nd MT marathon.
 **/

#include <iostream>
#include <string>
#include <vector>

#include <getopt.h>

#include "Data.h"
#include "Scorer.h"
#include "ScorerFactory.h"
#include "Timer.h"
#include "Util.h"

using namespace std;

void usage()
{
  cerr<<"usage: extractor [options])"<<endl;
  cerr<<"[--sctype|-s] the scorer type (default BLEU)"<<endl;
  cerr<<"[--scconfig|-c] configuration string passed to scorer"<<endl;
  cerr<<"\tThis is of the form NAME1:VAL1,NAME2:VAL2 etc "<<endl;
  cerr<<"[--reference|-r] comma separated list of reference files"<<endl;
  cerr<<"[--binary|-b] use binary output format (default to text )"<<endl;
  cerr<<"[--nbest|-n] the nbest file"<<endl;
  cerr<<"[--scfile|-S] the scorer data output file"<<endl;
  cerr<<"[--ffile|-F] the feature data output file"<<endl;
  cerr<<"[--prev-ffile|-E] comma separated list of previous feature data" <<endl;
  cerr<<"[--prev-scfile|-R] comma separated list of previous scorer data"<<endl;
  cerr<<"[-v] verbose level"<<endl;
  cerr<<"[--help|-h] print this message and exit"<<endl;
  exit(1);
}


static struct option long_options[] = {
  {"sctype",required_argument,0,'s'},
  {"scconfig",required_argument,0,'c'},
  {"reference",required_argument,0,'r'},
  {"binary",no_argument,0,'b'},
  {"nbest",required_argument,0,'n'},
  {"scfile",required_argument,0,'S'},
  {"ffile",required_argument,0,'F'},
  {"prev-scfile",required_argument,0,'R'},
  {"prev-ffile",required_argument,0,'E'},
  {"verbose",required_argument,0,'v'},
  {"help",no_argument,0,'h'},
  {0, 0, 0, 0}
};
int option_index;

int main(int argc, char** argv)
{


  ResetUserTime();

  /*
   Timer timer;
   timer.start("Starting...");
   */

  //defaults
  string scorerType("BLEU");
  string scorerConfig("");
  string referenceFile("");
  string nbestFile("");
  string scoreDataFile("statscore.data");
  string featureDataFile("features.data");
  string prevScoreDataFile("");
  string prevFeatureDataFile("");
  bool binmode = false;
  int verbosity = 0;
  int c;
  while ((c=getopt_long (argc,argv, "s:r:n:S:F:R:E:v:hb", long_options, &option_index)) != -1) {
    switch(c) {
      case 's':
        scorerType = string(optarg);
        break;
      case 'c':
        scorerConfig = string(optarg);
        break;
      case 'r':
        referenceFile = string(optarg);
        break;
      case 'b':
        binmode = true;
        break;
      case 'n':
        nbestFile = string(optarg);
        break;
      case 'S':
        scoreDataFile = string(optarg);
        break;
      case 'F':
        featureDataFile = string(optarg);
        break;
      case 'E':
        prevFeatureDataFile = string(optarg);
        break;
      case 'R':
        prevScoreDataFile = string(optarg);
        break;
      case 'v':
        verbosity = atoi(optarg);
        break;
      default:
        usage();
    }
  }
  try {
    // check whether score statistics file is specified
    if (scoreDataFile.length() == 0) {
      throw runtime_error("Error: output score statistics file is not specified");
    }

    // check wheter feature file is specified
    if (featureDataFile.length() == 0) {
      throw runtime_error("Error: output feature file is not specified");
    }

    // check whether reference file is specified when nbest is specified
    if ((nbestFile.length() > 0 && referenceFile.length() == 0)) {
      throw runtime_error("Error: reference file is not specified; you can not score the nbest");
    }

    vector<string> nbestFiles;
    if (nbestFile.length() > 0) {
      Tokenize(nbestFile.c_str(), ',', &nbestFiles);
    }

    vector<string> referenceFiles;
    if (referenceFile.length() > 0) {
      Tokenize(referenceFile.c_str(), ',', &referenceFiles);
    }

    vector<string> prevScoreDataFiles;
    if (prevScoreDataFile.length() > 0) {
      Tokenize(prevScoreDataFile.c_str(), ',', &prevScoreDataFiles);
    }

    vector<string> prevFeatureDataFiles;
    if (prevFeatureDataFile.length() > 0) {
      Tokenize(prevFeatureDataFile.c_str(), ',', &prevFeatureDataFiles);
    }

    if (prevScoreDataFiles.size() != prevFeatureDataFiles.size()) {
      throw runtime_error("Error: there is a different number of previous score and feature files");
    }


    if (binmode) cerr << "Binary write mode is selected" << endl;
    else cerr << "Binary write mode is NOT selected" << endl;

    TRACE_ERR("Scorer type: " << scorerType << endl);
    // ScorerFactory sfactory;
    Scorer* scorer = ScorerFactory::getScorer(scorerType,scorerConfig);

    // load references
    if (referenceFiles.size() > 0)
      scorer->setReferenceFiles(referenceFiles);

    PrintUserTime("References loaded");

    Data data(*scorer);

    // load old data
    for (size_t i=0; i < prevScoreDataFiles.size(); i++) {
      data.load(prevFeatureDataFiles.at(i), prevScoreDataFiles.at(i));
    }

    PrintUserTime("Previous data loaded");

    // computing score statistics of each nbest file
    for (size_t i=0; i < nbestFiles.size(); i++) {
      data.loadnbest(nbestFiles.at(i));
    }

    PrintUserTime("Nbest entries loaded and scored");

    if (binmode)
      cerr << "Binary write mode is selected" << endl;
    else
      cerr << "Binary write mode is NOT selected" << endl;

    data.save(featureDataFile, scoreDataFile, binmode);
    PrintUserTime("Stopping...");

    // timer.stop("Stopping...");

    delete scorer;

    return EXIT_SUCCESS;
  } catch (const exception& e) {
    cerr << "Exception: " << e.what() << endl;
    return EXIT_FAILURE;
  }

}