package liblinear;

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 String    weightFilename;
    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%n", total_correct);
        System.out.printf("Cross Validation Accuracy = %g%%%n", 100.0 * total_correct / prob.l);
    }

    private void exit_with_help() {
        System.out.printf("Usage: train [options] training_set_file [model_file]%n" //
            + "options:%n"
            + "-s type : set type of solver (default 1)%n"
            + "   0 -- L2-regularized logistic regression (primal)%n"
            + "   1 -- L2-regularized L2-loss support vector classification (dual)%n"
            + "   2 -- L2-regularized L2-loss support vector classification (primal)%n"
            + "   3 -- L2-regularized L1-loss support vector classification (dual)%n"
            + "   4 -- multi-class support vector classification by Crammer and Singer%n"
            + "   5 -- L1-regularized L2-loss support vector classification%n"
            + "   6 -- L1-regularized logistic regression%n"
            + "   7 -- L2-regularized logistic regression (dual)%n"
            + "-c cost : set the parameter C (default 1)%n"
            + "-e epsilon : set tolerance of termination criterion%n"
            + "   -s 0 and 2%n"
            + "       |f'(w)|_2 <= eps*min(pos,neg)/l*|f'(w0)|_2,%n"
            + "       where f is the primal function and pos/neg are # of%n"
            + "       positive/negative data (default 0.01)%n"
            + "   -s 1, 3, 4 and 7%n"
            + "       Dual maximal violation <= eps; similar to libsvm (default 0.1)%n"
            + "   -s 5 and 6%n"
            + "       |f'(w)|_inf <= eps*min(pos,neg)/l*|f'(w0)|_inf,%n"
            + "       where f is the primal function (default 0.01)%n"
            + "-B bias : if bias >= 0, instance x becomes [x; bias]; if < 0, no bias term added (default -1)%n"
            + "-wi weight: weights adjust the parameter C of different classes (see README for details)%n"
            + "-v n: n-fold cross validation mode%n"
            + "-q : quiet mode (no outputs)%n"
            + "-W weight_file: set weight file%n"
        );
        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.L2R_L2LOSS_SVC_DUAL, 1, Double.POSITIVE_INFINITY);
        // default values
        bias = -1;
        cross_validation = false;
        weightFilename = null;

        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.println("n-fold cross validation: n must >= 2");
                        exit_with_help();
                    }
                    break;
                case 'q':
                    Linear.disableDebugOutput();
                    break;
                case 'W':
                    weightFilename = argv[i];
                    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.L2R_LR || param.solverType == SolverType.L2R_L2LOSS_SVC) {
                param.setEps(0.01);
            } else if (param.solverType == SolverType.L2R_L2LOSS_SVC_DUAL || param.solverType == SolverType.L2R_L1LOSS_SVC_DUAL
                || param.solverType == SolverType.MCSVM_CS || param.solverType == SolverType.L2R_LR_DUAL) {
                param.setEps(0.1);
            } else if (param.solverType == SolverType.L1R_L2LOSS_SVC || param.solverType == SolverType.L1R_LR) {
                param.setEps(0.01);
            }
        }
    }

    /**
     * reads a problem from LibSVM format and additionally reads instance weights
     * @throws IOException obviously in case of any I/O exception ;)
     * @throws InvalidInputDataException if the input file is not correctly formatted
     */
    public static Problem readProblem(File file, double bias, File weightFile) throws IOException, InvalidInputDataException {
        Problem prob = readProblem(file, bias);
        BufferedReader fp = new BufferedReader(new FileReader(weightFile));
        try {
            int lineNr = 0;
            int i = 0;
            while (true) {
                String line = fp.readLine();
                if (line == null) break;
                lineNr++;

                line = line.trim();

                double weight;
                try {
                    weight = atof(line);
                } catch (NumberFormatException e) {
                    throw new InvalidInputDataException("invalid weight: " + line, file, lineNr, e);
                }

                if (weight < 0) throw new InvalidInputDataException("invalid weight: " + weight, file, lineNr);
                if (i >= prob.l) throw new InvalidInputDataException("read too many weights", file, lineNr);
                prob.W[i] = weight;
                i++;
            }

            if (i != prob.l) {
                throw new InvalidInputDataException("invalid number of weights: got " + i + " but require " + prob.l, file, lineNr);
            }

            return prob;
        }
        finally {
            fp.close();
        }
    }

    /**
     * reads a problem from LibSVM format
     * @throws IOException obviously in case of any I/O exception ;)
     * @throws InvalidInputDataException if the input file is not correctly formatted
     */
    public static Problem readProblem(File file, double bias) throws IOException, InvalidInputDataException {
        BufferedReader fp = new BufferedReader(new FileReader(file));
        try {
            List<Integer> vy = new ArrayList<Integer>();
            List<FeatureNode[]> vx = new ArrayList<FeatureNode[]>();
            int max_index = 0;
            int lineNr = 0;

            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, file, 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, file, lineNr, e);
                    }

                    // assert that indices are valid and sorted
                    if (index < 0) throw new InvalidInputDataException("invalid index: " + index, file, lineNr);
                    if (index <= indexBefore) throw new InvalidInputDataException("indices must be sorted in ascending order", file, 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, file, lineNr);
                    }
                }
                if (m > 0) {
                    max_index = Math.max(max_index, x[m - 1].index);
                }

                vx.add(x);
            }

            return constructProblem(vy, vx, max_index, bias);
        }
        finally {
            fp.close();
        }
    }

    void readProblem(String filename) throws IOException, InvalidInputDataException {
        prob = Train.readProblem(new File(filename), bias);
    }

    void readProblem(String filename, String weightFilename) throws IOException, InvalidInputDataException {
        prob = Train.readProblem(new File(filename), bias, new File(weightFilename));
    }

    private static Problem constructProblem(List<Integer> vy, List<FeatureNode[]> vx, int max_index, double bias) {
        Problem prob = new Problem();
        prob.bias = bias;
        prob.l = vy.size();
        prob.n = max_index;
        prob.W = new double[prob.l];
        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);
            prob.W[i] = 1;

            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);
            }
        }

        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, weightFilename);
        if (cross_validation)
            do_cross_validation();
        else {
            Model model = Linear.train(prob, param);
            Linear.saveModel(new File(modelFilename), model);
        }
    }
}