// a wrapper for LIBLINEAR
public class Classifier {

  private HashMap<String, Integer> featureMap;
  private Model[] models;
  private HashMap<String, Integer> cache;
  private BufferedWriter cacheWriter;

  public Classifier(String installDir, String[] emotions) {
    models = new Model[emotions.length];
    cache = new HashMap<String, Integer>();
    try {
      ArrayList<String> lines = new ArrayList<String>();
      // load feature index map
      InputStream instream;
      if (installDir.startsWith("http:")) {
        instream = new URL(installDir + "/data/features.txt").openStream();
      } else {
//      instream = new FileInputStream(new File(installDir + "/data/features-short.txt"));
        instream = new FileInputStream(new File(installDir + "/data/features.txt"));
      }
      BufferedReader reader = new BufferedReader(new InputStreamReader(instream));
      String inLine;
      while ((inLine = reader.readLine()) != null) {
        lines.add(inLine);
      }
      reader.close();
      featureMap = new HashMap<String, Integer>();
      for (String line : lines) {
        String[] f = line.split("\\t");
        featureMap.put(f[1].trim(), new Integer(f[0].trim()));
      }
      // load classifier models
      for (int i=0; i<models.length; i++) {
        if (installDir.startsWith("http:")) {
          instream = new URL(installDir + "/data/" + emotions[i] + "-demo-model").openStream();
          models[i] = Linear.loadModel(new InputStreamReader(instream));
        } else {
//        models[i] = Linear.loadModel(new File(installDir + "/data/emo-" + emotions[i] + "-short-model"));
          models[i] = Linear.loadModel(new File(installDir + "/data/" + emotions[i] + "-demo-model"));
        }
      }
      // load cache if exists
      File cacheFile = new File(installDir + "/cache.txt");
      if (cacheFile.exists()) {
        lines.clear();
        if (installDir.startsWith("http:")) {
          instream = new URL(installDir + "/cache.txt").openStream();
        } else {
          instream = new FileInputStream(cacheFile);
        }
        reader = new BufferedReader(new InputStreamReader(instream));
        while ((inLine = reader.readLine()) != null) {
          lines.add(inLine);
        }
        reader.close();
        for (String line : lines) {
          String[] f = line.split("\\t");
          cache.put(f[1].trim(), new Integer(f[0].trim()));
        }
      }
      if (!installDir.startsWith("http:")) {
        cacheWriter = new BufferedWriter( new FileWriter( cacheFile, true ) );
      }
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      System.exit(0);
    }
  }

  public double[] predict(String sentence) {

    sentence = sentence.trim().toLowerCase();
    FeatureNode[] sample = getFeatures(sentence);
    double[] val = new double[sample.length];
    double[] res = new double[models.length];

    if ((sentence.length() > 0) && cache.containsKey(sentence)) {
      Integer iCached = cache.get(sentence);
      for (int i=0; i<models.length; i++) {
        res[i] = ( (i==iCached) ? 1.0 : 0.0 );
      }
      return res;
    }
    
    if (sample.length > 0) {
      for (int i=0; i<models.length; i++) {
        int r = Linear.predictValues(models[i], sample, val);
//      System.out.println(i + " res " + r + " vals " + Arrays.toString(val));
        res[i] = val[0];
      }
    }
    return res;
  }

  public void addCache(String sentence, int iClass) {
    sentence = sentence.trim().toLowerCase();
    if (sentence.length() > 0) {
      cache.put(sentence,iClass);
    }
    if (cacheWriter != null) {
      try {
        cacheWriter.write(iClass + "\t" + sentence + "\n");
        cacheWriter.flush();
      } catch (IOException e) {
        e.printStackTrace();
        System.exit(0);
      }
    }
  }

  private FeatureNode[] getFeatures(String s) {
    s = s.toLowerCase().replaceAll("(\\w)([.,;:!?'\"])","$1 $2");
    String[] f = s.split("\\s+");
//    println("feature vector " + Arrays.toString(f));
    HashMap<Integer, Double> featMap = new HashMap<Integer, Double>();
    for (String feat : f) {
      Integer i = featureMap.get(feat);
      if (i != null) {
        if (!featMap.containsKey(i)) {
          featMap.put(i, new Double(0.0));
        }
        featMap.put(i, new Double(featMap.get(i) + 1.0));
      }
    }
    // normalize, sort
    double sum = 0.0;
    for (Integer i : featMap.keySet()) {
      sum += featMap.get(i);
    }
    ArrayList<Integer> indices = new ArrayList<Integer>(featMap.keySet());
    Collections.sort(indices);
    FeatureNode[] fn = new FeatureNode[indices.size()];
    for (int i = 0; i < fn.length; i++) {
      fn[i] = new FeatureNode(indices.get(i), featMap.get(indices.get(i)) / sum);
//      System.out.println("fn " + i + "=" + fn[i]);
    }
    return fn;
  }
  
}