package liblinear;

import static liblinear.Linear.NL;
import static liblinear.Linear.atof;
import static liblinear.Linear.atoi;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;


public class Train {

   public static void main( String[] args ) throws IOException, InvalidInputDataException {
      new Train().run(args);
   }

   private double    bias             = 1;
   private boolean   cross_validation = false;
   private String    inputFilename;
   private String    modelFilename;
   private int       nr_fold;
   private Parameter param            = null;
   private Problem   prob             = null;

   private void do_cross_validation() {
      int[] target = new int[prob.l];

      long start, stop;
      start = System.currentTimeMillis();
      Linear.crossValidation(prob, param, nr_fold, target);
      stop = System.currentTimeMillis();
      System.out.println("time: " + (stop - start) + " ms");

      int total_correct = 0;
      for ( int i = 0; i < prob.l; i++ )
         if ( target[i] == prob.y[i] ) ++total_correct;

      System.out.printf("correct: %d" + NL, total_correct);
      System.out.printf("Cross Validation Accuracy = %g%%\n", 100.0 * total_correct / prob.l);
   }

   private void exit_with_help() {
      System.out.println("Usage: train [options] training_set_file [model_file]" + NL //
         + "options:" + NL//
         + "-s type : set type of solver (default 1)" + NL//
         + "   0 -- L2-regularized logistic regression" + NL//
         + "   1 -- L2-loss support vector machines (dual)" + NL//
         + "   2 -- L2-loss support vector machines (primal)" + NL//
         + "   3 -- L1-loss support vector machines (dual)" + NL//
         + "   4 -- multi-class support vector machines by Crammer and Singer" + NL//
         + "-c cost : set the parameter C (default 1)" + NL//
         + "-e epsilon : set tolerance of termination criterion" + NL//
         + "   -s 0 and 2" + NL//
         + "       |f'(w)|_2 <= eps*min(pos,neg)/l*|f'(w0)|_2," + NL//
         + "       where f is the primal function, (default 0.01)" + NL//
         + "   -s 1, 3, and 4" + NL//
         + "       Dual maximal violation <= eps; similar to libsvm (default 0.1)" + NL//
         + "-B bias : if bias >= 0, instance x becomes [x; bias]; if < 0, no bias term added (default 1)" + NL//
         + "-wi weight: weights adjust the parameter C of different classes (see README for details)" + NL//
         + "-v n: n-fold cross validation mode" + NL//
      );
      System.exit(1);
   }


   Problem getProblem() {
      return prob;
   }

   double getBias() {
      return bias;
   }

   Parameter getParameter() {
      return param;
   }

   void parse_command_line( String argv[] ) {
      int i;

      // eps: see setting below
      param = new Parameter(SolverType.L2LOSS_SVM_DUAL, 1, Double.POSITIVE_INFINITY);
      // default values
      bias = 1;
      cross_validation = false;

      int nr_weight = 0;

      // parse options
      for ( i = 0; i < argv.length; i++ ) {
         if ( argv[i].charAt(0) != '-' ) break;
         if ( ++i >= argv.length ) exit_with_help();
         switch ( argv[i - 1].charAt(1) ) {
         case 's':
            param.solverType = SolverType.values()[atoi(argv[i])];
            break;
         case 'c':
            param.setC(atof(argv[i]));
            break;
         case 'e':
            param.setEps(atof(argv[i]));
            break;
         case 'B':
            bias = atof(argv[i]);
            break;
         case 'w':
            ++nr_weight;
            {
               int[] old = param.weightLabel;
               param.weightLabel = new int[nr_weight];
               System.arraycopy(old, 0, param.weightLabel, 0, nr_weight - 1);
            }

            {
               double[] old = param.weight;
               param.weight = new double[nr_weight];
               System.arraycopy(old, 0, param.weight, 0, nr_weight - 1);
            }

            param.weightLabel[nr_weight - 1] = atoi(argv[i - 1].substring(2));
            param.weight[nr_weight - 1] = atof(argv[i]);
            break;
         case 'v':
            cross_validation = true;
            nr_fold = atoi(argv[i]);
            if ( nr_fold < 2 ) {
               System.err.print("n-fold cross validation: n must >= 2\n");
               exit_with_help();
            }
            break;
         default:
            System.err.println("unknown option");
            exit_with_help();
         }
      }

      // determine filenames

      if ( i >= argv.length ) exit_with_help();

      inputFilename = argv[i];

      if ( i < argv.length - 1 )
         modelFilename = argv[i + 1];
      else {
         int p = argv[i].lastIndexOf('/');
         ++p; // whew...
         modelFilename = argv[i].substring(p) + ".model";
      }

      if ( param.eps == Double.POSITIVE_INFINITY ) {
         if ( param.solverType == SolverType.L2_LR || param.solverType == SolverType.L2LOSS_SVM ) {
            param.setEps(0.01);
         } else if ( param.solverType == SolverType.L2LOSS_SVM_DUAL || param.solverType == SolverType.L1LOSS_SVM_DUAL
            || param.solverType == SolverType.MCSVM_CS ) {
            param.setEps(0.1);
         }
      }
   }

   /**
    * reads a problem from LibSVM format
    * @param filename the name of the svm file
    * @throws IOException obviously in case of any I/O exception ;)
    * @throws InvalidInputDataException if the input file is not correctly formatted
    */
   void readProblem( String filename ) throws IOException, InvalidInputDataException {
      BufferedReader fp = new BufferedReader(new FileReader(filename));
      List<Integer> vy = new ArrayList<Integer>();
      List<FeatureNode[]> vx = new ArrayList<FeatureNode[]>();
      int max_index = 0;

      int lineNr = 0;

      try {
         while ( true ) {
            String line = fp.readLine();
            if ( line == null ) break;
            lineNr++;

            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
            String token = st.nextToken();

            try {
               vy.add(atoi(token));
            }
            catch ( NumberFormatException e ) {
               throw new InvalidInputDataException("invalid label: " + token, filename, lineNr, e);
            }

            int m = st.countTokens() / 2;
            FeatureNode[] x;
            if ( bias >= 0 ) {
               x = new FeatureNode[m + 1];
            } else {
               x = new FeatureNode[m];
            }
            int indexBefore = 0;
            for ( int j = 0; j < m; j++ ) {

               token = st.nextToken();
               int index;
               try {
                  index = atoi(token);
               }
               catch ( NumberFormatException e ) {
                  throw new InvalidInputDataException("invalid index: " + token, filename, lineNr, e);
               }

               // assert that indices are valid and sorted
               if ( index < 0 ) throw new InvalidInputDataException("invalid index: " + index, filename, lineNr);
               if ( index <= indexBefore ) throw new InvalidInputDataException("indices must be sorted in ascending order", filename, lineNr);
               indexBefore = index;

               token = st.nextToken();
               try {
                  double value = atof(token);
                  x[j] = new FeatureNode(index, value);
               }
               catch ( NumberFormatException e ) {
                  throw new InvalidInputDataException("invalid value: " + token, filename, lineNr);
               }
            }
            if ( m > 0 ) {
               max_index = Math.max(max_index, x[m - 1].index);
            }

            vx.add(x);
         }

         prob = constructProblem(vy, vx, max_index);
      }
      finally {
         fp.close();
      }
   }

   private Problem constructProblem( List<Integer> vy, List<FeatureNode[]> vx, int max_index ) {
      Problem prob = new Problem();
      prob.bias = bias;
      prob.l = vy.size();
      prob.n = max_index;
      if ( bias >= 0 ) {
         prob.n++;
      }
      prob.x = new FeatureNode[prob.l][];
      for ( int i = 0; i < prob.l; i++ ) {
         prob.x[i] = vx.get(i);

         if ( bias >= 0 ) {
            assert prob.x[i][prob.x[i].length - 1] == null;
            prob.x[i][prob.x[i].length - 1] = new FeatureNode(max_index + 1, bias);
         } else {
            assert prob.x[i][prob.x[i].length - 1] != null;
         }
      }

      prob.y = new int[prob.l];
      for ( int i = 0; i < prob.l; i++ )
         prob.y[i] = vy.get(i);

      return prob;
   }

   private void run( String[] args ) throws IOException, InvalidInputDataException {
      parse_command_line(args);
      readProblem(inputFilename);
      if ( cross_validation )
         do_cross_validation();
      else {
         Model model = Linear.train(prob, param);
         Linear.saveModel(new File(modelFilename), model);
      }
   }
}