import java.io.IOException;
import java.util.*;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.conf.*;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.*;
import org.apache.hadoop.util.*;

// outputkey is going to be the condidate number
public class combinecounter extends Reducer<IntWritable,catval,IntWritable,catval>
{
  protected void reduce(IntWritable inkey, Iterable<catval> vals, Context collector) throws IOException, InterruptedException
  {
      Iterator<catval> values = vals.iterator();
      long ccount = 0;
      //      catval first = values.next();
      //      ccount += first.count;
      // int filenum = first.filenum;
      //      String suffix = first.suffix;
      //      String prefix = first.prefix;

      String[] Fix = new String[10000]; // evens for prefix, odd for suffix
      int maxfix = 0;
      
      while (values.hasNext())
	  {
	      catval current = values.next();
	      ccount += current.count;
	      Fix[current.linenum*2] = new String(current.prefix);
	      // at this point, check suffix+prefix for more cats
	      //	      ccount += mapcounter.countcats(suffix+prefix);
	      //	      suffix = current.suffix; // set new suffix
	      Fix[current.linenum*2+1] = new String(current.suffix); 
	      if (current.linenum*2+1 > maxfix) maxfix = current.linenum*2+1;
	  }
      // at this point most may not point to same object anymore
      
      for(int i=1;i<maxfix;i+=2)
	  {
	      logger.log(i+":"+Fix[i]+"---"+Fix[i+1]);
	      ccount += mapcounter.countcats(Fix[i]+Fix[i+1]);
	  }

      logger.log("inkey is "+inkey.get());

      IntWritable outkey = new IntWritable(-1);  // common key for reducer
      catval outval = new catval(ccount,"GG","GG",inkey.get());
      collector.write(outkey,outval); // output result
  }//combiner

}//combinecounter

/*
The combiner is also different from a reducer in that a combiner's input
key,value types must be the same as its output key,value types.  Note
that this doesn't mean that they can't output different keys, just not
keys of a different *type*.  To get around this artificial limitation,
use a superclass and several different subclasses. (I haven't tried this
trick though, so be careful. Because Hadoop uses reflection - code that
refers to itself - there's a chance that it may break the integrity of
dynamic dispatch.  I learned this because I had to define a dummy constructor
in the PrimeKey class - I shouldn't normally have to do that. )
*/