/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
/*
 * @(#)SVM_Light.java      0.1 00/01/15
 *
 * By Thomas Down <td2@sanger.ac.uk>
 */

package org.biojava.stats.svm.tools;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.StringTokenizer;

import org.biojava.stats.svm.CachingKernel;
import org.biojava.stats.svm.PolynomialKernel;
import org.biojava.stats.svm.RadialBaseKernel;
import org.biojava.stats.svm.SVMClassifierModel;
import org.biojava.stats.svm.SVMKernel;
import org.biojava.stats.svm.SimpleSVMClassifierModel;
import org.biojava.stats.svm.SparseVector;

/**
 * @author Thomas Down
 * @author Greg Cox
 */

public class SVM_Light {
    public static class LabelledVector {
	private SparseVector v;
	private double label;
	private String comment = null;

	public LabelledVector(SparseVector v, double label) {
	    this.v = v;
	    this.label = label;
	}

	public LabelledVector(SparseVector v, double label, String comment) {
	    this.v = v;
	    this.label = label;
	    this.comment = comment;
	}

	public SparseVector getVector() {
	    return v;
	}

	public double getLabel() {
	    return label;
	}

	public String getComment() {
	    return comment;
	}
    }

    public static LabelledVector parseExample(String ex)
	throws NumberFormatException
    {
	String comment = null;
	int hashPos = ex.indexOf('#');
	if (hashPos >= 0) {
	    comment = ex.substring(hashPos + 1);
	    ex = ex.substring(0, hashPos);
	}

	StringTokenizer toke = new StringTokenizer(ex);
	double label = Double.parseDouble(toke.nextToken());

  	int size = toke.countTokens();
	SparseVector v = new SparseVector(size);
	while (toke.hasMoreTokens()) {
	    String dim = toke.nextToken();
	    int cut = dim.indexOf(':');
	    if (cut < 0) {
		throw new NumberFormatException("Bad dimension "+dim);
	    }
	    int dnum = Integer.parseInt(dim.substring(0, cut));
	    double dval = Double.parseDouble(dim.substring(cut + 1));
	    v.put(dnum, dval);
	}

	return new LabelledVector(v, label, comment);
    }

    public static String vectorToString(SparseVector v) {
	StringBuffer sb = new StringBuffer();
	boolean first = true;

	for (int i = 0; i < v.size(); ++i) {
	    double x = v.getValueAtIndex(i);

	    if (first) {
		first = false;
	    } else {
		sb.append(' ');
	    }

	    sb.append(v.getDimAtIndex(i));
	    sb.append(':');
	    sb.append(x);
	}
	return sb.substring(0);
    }

    public static SVMClassifierModel readModelFile(String fileName)
	throws IOException
    {
	BufferedReader r = new BufferedReader(new FileReader(fileName));
	r.readLine(); // format
	String kType = firstToken(r.readLine());
	String dParam = firstToken(r.readLine());
	String gParam = firstToken(r.readLine());
	r.readLine(); // s
	r.readLine(); // r
	r.readLine(); // u
	r.readLine(); // numSV
	String threshString = firstToken(r.readLine());

	SVMKernel kernel = null;
	try {
	    switch (Integer.parseInt(kType)) {
	    case 0:
		kernel = SparseVector.kernel;
		break;
	    case 1:
		int order = Integer.parseInt(dParam);
		PolynomialKernel k = new PolynomialKernel();
		k.setOrder(order);
		k.setNestedKernel(SparseVector.kernel);
		kernel = k;
		break;
  	    case 2:
		RadialBaseKernel rbk = new RadialBaseKernel();
		double width = Double.parseDouble(gParam);
		rbk.setWidth(width);
		rbk.setNestedKernel(SparseVector.kernel);
		kernel = rbk;
		break;
  	    default:
		throw new IOException("Couldn't create kernel");
	    }

	    SimpleSVMClassifierModel model = new SimpleSVMClassifierModel(kernel);
	    model.setThreshold(Double.parseDouble(threshString));
	    String line;
	    while ((line = r.readLine()) != null) {
		LabelledVector ex = parseExample(line);
		model.addItemAlpha(ex.getVector(), ex.getLabel());
	    }
	    r.close();

	    return model;
	} catch (NumberFormatException ex) {
	    throw new IOException("Couldn't parse model file");
	}
    }

  public static void writeModelFile(SVMClassifierModel model, String fileName)
  throws IOException {
    SVMKernel k = model.getKernel();

    int kType = 0;
    int d = 3;
    double g = 1;
    double s = 1;
    double r = 1;
    String u = "empty";

    while(k instanceof CachingKernel) {
      k = ((CachingKernel) k).getNestedKernel();
    }
    
    if (k == SparseVector.kernel) {
      kType = 0;
    } else if (k instanceof PolynomialKernel) {
      kType = 1;
      d = (int) ((PolynomialKernel) k).getOrder();
    } else if (k instanceof RadialBaseKernel) {
      kType = 2;
      g = ((RadialBaseKernel) k).getWidth();
    } else {
      throw new IOException("Can't write SVM_Light file with kernel type " + k.getClass().toString());
    }


    PrintWriter pw = new PrintWriter(new FileWriter(fileName));
    pw.println("SVM-light Version V3.01");
    pw.println("" + kType + " # kernel type");
    pw.println("" + d + " # kernel parameter -d");
    pw.println("" + g + " # kernel parameter -g");
    pw.println("" + s + " # kernel parameter -s");
    pw.println("" + r + " # kernel parameter -r");
    pw.println(u + " # kernel parameter -u");

    int numSV = 0;
    for(Iterator i = model.items().iterator(); i.hasNext(); ) {
      Object item = i.next();
      if (model.getAlpha(item) != 0) {
        numSV++;
      }
    }

    pw.println("" + numSV + " # number of support vectors");
    pw.println("" + model.getThreshold() + " # threshold b");

    for(Iterator i = model.items().iterator(); i.hasNext(); ) {
      Object item = i.next();
      if (model.getAlpha(item) == 0) {
        continue;
      }
      pw.print(model.getAlpha(i));

      SparseVector v = (SparseVector) item;
      for (int j = 0; j <= v.maxIndex(); ++j) {
        double x = v.get(j);
        if (x != 0.0)
        pw.print(" " + j + ":" + x);
      }
      pw.println("");
    }

    pw.close();
  }

  public static String firstToken(String s) {
    int ndx = s.indexOf(" ");
    if (ndx < 0) {
	    return s;
    } else {
      return s.substring(0, ndx);
    }
  }
}