package cquest.utils;

import java.io.*;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;

/** class InputReader.
 * class to read parameter from a program from a stream
 * (stdin or a file).
 *
 * the input format is :
 * -- help
 * -- end
 * -- key = value
 * -- # comments
 * 
 * @author Michael Sdika 
 */
public class InputReader
{

/** constructor
 * @param 
 */
public InputReader()
{ table = new Hashtable();
}



/** add a new key.
 * the key must not contains =.
 * */
public void addKey(String key, Callback cb) throws Exception
{ if (key.indexOf('=')!=-1)
    { throw new Exception("The key ("+key+") must not contains '='.");
    } 
  if (key.charAt(0)=='#')
    { throw new Exception("The key ("+key+") must not begin with '#'.");
    }
  if (key.equals(help) || key.equals(run) || key.equals(quit) )
    { throw new Exception("The key must be different from "+help+", "+quit+" and "+run+".");
    }
  if (table.containsKey(key))
    { throw new Exception("The key "+key+" is already in the table.");
    }
  table.put(key,cb);
}


/** clear the object. */
public void clear()
{ table.clear();
}

/** behaviour of the read function in case of failure. */
public void setRetryIfFail(boolean on)
{ retryIfFail = on;
}

/** read.
 * @return true if run, false if quit. 
 *  */
public boolean read(BufferedReader reader, int nbVox) throws IOException
{
  do 
    { 
      // read next line
      String line;
      do
	{ line = reader.readLine();
           if(line!=null &&  line.length()>0 ){
                if(line.contains("Pixel"))
                    { 
                       for (int k=0;k<nbVox; k++){
                       line = reader.readLine(); 
                       }        

	           line = reader.readLine(); 
                    }  
             }
	}
      while (line!=null && ( line.length()==0 || line.charAt(0)=='#') );

      // end of stream
      if (line==null) 
	{ return (true);
	}
      
      // find key and value (key is before first '=')
      String[] lineSplitted = line.split("=",2);
      String key = lineSplitted[0].trim();   
       if (lineSplitted.length==1) // 
	    { 
               // find key and value (key is before first ':') for SV file
              lineSplitted = line.split(":",2);
              key = lineSplitted[0].trim();

            }

      // treat keys
      if (key.equals(run)) // run
	{ return (true);
	}
      
      if (key.equals(quit)) // quit
	{ return (false);
	}
      
      if (key.equals(help)) // help
	{ System.out.println (" allowed keys are :");
	  for (Enumeration e = table.keys() ; e.hasMoreElements() ;)
	    { System.out.println("  * "+e.nextElement());
	    }
	}
      else

     { 
	  if (lineSplitted.length==1) // 
	    { System.out.println ("wrong format : '=' is missing for key "+key);
	      printUsage();
              if (retryIfFail) continue; else return (false);
	    }
	  Callback cb = (Callback)table.get(key);
	  if (cb==null)
	    { System.out.println ("unknown key : " + key);
	      printUsage();
              if (retryIfFail) continue; else return (false);
	    }
	  
	  if (!cb.ok(lineSplitted[1]))
	    { System.out.println (cb.getMessage());
              if (retryIfFail) continue; else return (false);
	    }
	  else
	    { if (!cb.callback(lineSplitted[1]))
		{ if (retryIfFail) continue; else return (false);
		}
	    }
	}
 }
  while (true);
}

/** print the usage. */
private void printUsage()
{ System.out.println ("type \"" + help + "\" for the list of the keys,");
  System.out.println ("type \"" + run  + "\" to begin the program");
  System.out.println ("type \"" + quit + "\" to abandon");
  System.out.println ("type \"key = value\" to give a value");
  System.out.println ("line beginning by \"#\" are comment");
}

/** contains the keys and the read values. */
private Hashtable table;

/** behaviour of the read function in case of failure. */
boolean retryIfFail = false;

/** key to get some help. */
private static String help="help";

/** key to finish. */
private static String run="run";

/** key to finish. */
private static String quit="quit";





/* ---------------------------------------------------------- */
/* ---     Callback functions abstract classes  ------------- */
/* ---------------------------------------------------------- */

/** function called when a key is found. */
public static abstract class Callback
{ /** error message printed when !ok(). */
  protected String message = "";
  /** number of requested item.
   * if negative : any number accepted.
   * */
  protected int nbEltReq = -1;

  /** the last value splitted around space by ok. */
  protected String[] strValues;
  
  /** Constructor. */
  protected Callback(int nbEltReq_) { nbEltReq = nbEltReq_; }
  
  /** Constructor. */
  protected Callback() {}
  
  /** error message if !ok(). */
  public String getMessage()
    { return (message);
    }

  /** check that the value is correct.
   * if nbEltReq positive, value must have nbEltReq field.
   * */
  public boolean ok(String value)
    { strValues = value.trim().split("\\s+");
      if (nbEltReq>0 && strValues.length!=nbEltReq)
	{ message = "the value must have "+nbEltReq+" fields";
	  return (false);
	}
      else
	{ return (true);
	}
    }
  public abstract boolean callback(String value);
  //public abstract boolean callback(BufferedReader read);
}




/** callback function for double value.
 * accept input if it is an sequence of double.
 * you can specifie the number of element (nbElt)
 * or not (nbElt negative)
 *  */
public static abstract class CallbackDouble extends Callback
{ protected double[] doubleValues;
  protected CallbackDouble(int nbElt) { super(nbElt); }
  public boolean ok(String value)
    { if (super.ok(value))
	{ try
	    { doubleValues = new double[strValues.length];
	      for (int i=0;i<doubleValues.length;i++)
		{ doubleValues[i] = Double.valueOf(strValues[i]).doubleValue();
		}
	      return (true);
	    }
	  catch (NumberFormatException e)
	    { message = value+" must contains only doubles";
	      return (false);
	    }
	  
	}
      return (false);
    }
}

/** callback function for int value. */
public static abstract class CallbackInteger extends Callback
{ protected int intValues[];
  protected CallbackInteger(int nbElt) { super(nbElt); }
  public boolean ok(String value)
    { if (super.ok(value))
	{ try
	    { intValues = new int[strValues.length];
	      for (int i=0;i<intValues.length;i++)
		{ intValues[i] = Integer.valueOf(strValues[i]).intValue();
		}
	      return (true);
	    }
	  catch (NumberFormatException e)
	    { message = value+" must contains only integer";
	      return (false);
	    }
	  
	}
      return (false);
    }
}


/** callback function for boolean value. */
public static abstract class CallbackBool extends Callback
{ protected boolean[] boolValues;
  protected CallbackBool(int nbElt) { super(nbElt); }
  public boolean ok(String value)
    { if (super.ok(value))
	{ try
	    { boolValues = new boolean[strValues.length];
	      for (int i=0;i<boolValues.length;i++)
		{ 
	System.out.println("Boolean str values="+strValues[i]);
		  boolValues[i] = Boolean.valueOf(strValues[i]);
	System.out.println("Boolean str values2="+boolValues[i]);
		}
	      return (true);
	    }
	  catch (NumberFormatException e)
	    { message = value+" must contains only boolean";
	      return (false);
	    }
	  
	}
      return (false);
    }
}



/** callback function for enum value.
 * return index of the enum value found in the names given to the constructor.
 *  */
public static abstract class CallbackEnum extends Callback
{ protected String[] enumNames;
  protected int[]    enumValues;
  protected CallbackEnum(int nbElt, String[] ev) { super(nbElt); enumNames=ev; }
  public boolean ok(String value)
    { if (super.ok(value))
	{ enumValues = new int[strValues.length];
	  for (int i=0;i<enumValues.length;i++)
	    { enumValues[i] = -1;
	      for (int j=0;j<enumNames.length;j++)
		{ if (strValues[i].equals(enumNames[j]))
		    { enumValues[i] = j;
		      break;
		    } 
		}
	      if (enumValues[i] == -1)
		{ message = "illegal value : "+strValues[i] + " must be one of ";
		  for (int j=0;j<enumNames.length;j++)
		    { message += enumNames[j]+" , ";
		    }
		  return (false);
		}
	    }
	  return (true);
	}
      return (false);
    }
}


/** callback function for a table of parameter.
 * return index of the enum value found in the names given to the constructor.
 *  */
/*public static abstract class CallbackTable extends Callback
{ protected double[][] enumValues;
  //protected int[]    enumValues;
  protected CallbackTable(int nbVox, double[][] ev) { super(nbElt); enumValues=ev; }
  public boolean ok(String value)
    { if (super.ok(value))
	{ enumValues = new int[strValues.length];
	  for (int i=0;i<enumValues.length;i++)
	    { enumValues[i] = -1;
	      for (int j=0;j<enumNames.length;j++)
		{ if (strValues[i].equals(enumNames[j]))
		    { enumValues[i] = j;
		      break;
		    } 
		}
	      if (enumValues[i] == -1)
		{ message = "illegal value : "+strValues[i] + " must be one of ";
		  for (int j=0;j<enumNames.length;j++)
		    { message += enumNames[j]+" , ";
		    }
		  return (false);
		}
	    }
	  return (true);
	}
      return (false);
    }
}


}*/

}