//mylaiza.java
// an eliza, in java
import java.awt.*;
import java.io.*;
import java.net.*;
import java.applet.*;
import java.util.*;

public class mylaiza extends Applet{
/** a simple rule-based eliza clone, (cf. my lai massacre) 
  parameter name "datafile" = filename with rules info*/
TextArea transcript;
TextField inbox;
String rules;
matcher reply,preprocess,switchviewpoint;


	private String nextfileline(DataInputStream d) {
/** returns next non comment in inputstream  comment = starts with ; */
String line=new String("");
try {	line=d.readLine();
	while (line.charAt(0) ==';') line=d.readLine();}
catch (Exception e) { return "END";};
//if end of file return "END"  -- wouldn't you know, the docs don't explain EOF
//System.out.println(line);
return line;};

	String getrules(DataInputStream f){
String s=new String("");
String line=new String(nextfileline(f));
while (!line.equals("END")){s=(s+line+"\n");line=nextfileline(f);};
return s;}


	public void init(){
//**  read in rules from file, create editboxes
DataInputStream f;
URL f1;  
int i,j,cot;
StringTokenizer sit;
String line="";
String rules,separators,matchchars;

setBackground(new Color(180,180,255));
String filename=getParameter("datafile");

try {f1=new URL(getDocumentBase(),filename);
	f=new DataInputStream(f1.openStream());}
catch (IOException e) {System.out.println("File not available");return;}

line=nextfileline(f); //input wildcard separator char  (#|)
matchchars=line.substring(0,1); //wildcard char  #
separators=line.substring(1,3)+"\n"; //separator char |


//input preprocessing rules
// the way this works, the last one is the destination, 
// convert to canonical form,  correct mispellings
// and all previous words get translated to the last one
// this puts all the intial words to the final class
rules=getrules(f);
preprocess=new matcher(rules,0,separators,matchchars);

//input context switch rules
//two rules, from to,  eg. you|me
rules=getrules(f);
switchviewpoint=new matcher(rules,0,separators,matchchars);

//input replies rules
// match the first element, with wildcards
// pick a random reply, substitute wildcard match, 
rules=getrules(f);
reply=new matcher(rules,1,separators,matchchars);

transcript=new TextArea(10, 80);
transcript.setEditable(false);
inbox=new TextField(80);
add(transcript);
add(inbox);
transcript.appendText("Hi. I am mylaiza.\n");
inbox.requestFocus();
matcher test=new matcher("wash=test");
d("Test"+test.match("this is a wash up"));
d(test.stuff("wash","test","this is a wash up"));
//d(match("test"+x,"this is a testing of match"));
}


	public boolean keyDown(Event evt, int key) {
if (key !='\n') return false;
String text = inbox.getText();
processinput(text);
inbox.setText("");
return true;}

/*
	public void start(){
cotton=new Thread(this);
cotton.start();}

	public void stop(){
cotton.stop();}
*/

	private void processinput(String in){
String matches;
String out=new String(in);
//substitute i,I
// for each element in the rules,  
// check test, pick replies, substitute matched pieces
// switch view point, 
// print question and reply to box reply to box
transcript.appendText(in+"\nMylaiza:");
out=preprocess.match(out);
out=reply.match(switchviewpoint.match(out));
transcript.appendText(out);}

	private void d(String line){
System.out.println(line); }

}

//************************************
//matcher.java

/**a class to do pattern matching
ops: 
constructor(string of all rules,string of
separators for rule,field,argument(s)/result(s)),
int type, 1=match once 0=match many (stop at 1 replacement, dont stop)
string of patten match characters for match all,
match 1 word, etc.  to be worked out later
contructor(string of all rules); using defaults "|=\n","*?",1
meant to be a basis for further pattern match work)

match(string to match) returns corresponding output

an obvious subclass is a singlerule match, 1 arg string, list of results
rule=1 arg string and list of result strings, or simply a list of strings
could have its own class, but...
ops, keyword{ longest, for hashlookup ), selector arg() pickone(), subst,
matches{list of matched sections.}  result, relaced into rule

a rule at this point is an array of String
pickone(rule), why to choose result from multiple choice
  it might be good for a learning procedure to override;
  prhaps not repeat last one

for optimization:
each arg of a rule has a keyword (longest),  do a hashtable lookup on 
each word in line for keyword,  then use slower more complete matcher
fastmatch(String word)=check each word, return rule if applies
*/


class matcher {
String rules[][];  //storing all rules, each array knows its length
Random ran=new Random();
int stopafter;// stop after this many replacements 1 or don't stop
String wildcars;// all the wildchar characters,  *****2b written
static String x="\033";// special code char for pattern matching

	public String[] parsetoarray(String rawlist,String separator){
//  break the string into an array of strings, which were separated by..
StringTokenizer sit=new StringTokenizer(rawlist, separator);
int c=sit.countTokens();
String[] stimpy=new String[c];
for (int i=0;i<c; i++) 
	stimpy[i]=new String(sit.nextToken()); 
return stimpy;}


	matcher(String rawrules,int type,String separators, String matchchars){
/*string of all rules,string of
separators for rule,field,argument(s)/result(s)),
int type, 1=match once 0=match many (stop at 1 replacement, dont stop)
string of patten match characters for match all,
match 1 word, etc.  to be worked out later */
wildcars=new String(matchchars);
stopafter=type;
String siprule=separators.substring(2,3);
String sipside=separators.substring(1,2);
String sipfield=separators.substring(0,1);
String[] rawrulearray=parsetoarray(rawrules,siprule);
int countrawrule=rawrulearray.length; 
String rawresult,rawarg;
String[][] result=new String[countrawrule][];
String[][] arg=new String[countrawrule][];
int countarg=0;
String line;
// each argument gets its own rule, so there may be more rules than
//  rules lines in the data file

int i,j,k,l,p;
for (i=0;i<countrawrule;i++) {
	// parse pairs of rules
	line=rawrulearray[i];
	p=line.indexOf(sipside);
	if (p<0) continue; //no side separator in line
	rawarg=new String(line.substring(0,p));
	rawresult=new String(line.substring(p+1));
	arg[i]=parsetoarray(rawarg,sipfield);
	result[i]=parsetoarray(rawresult,sipfield);
	countarg += arg[i].length; }
rules=new String[countarg][];
k=0;
for (i=0;i<countrawrule;i++) //for each original rule
	for (j=0;j<arg[i].length;j++) {  //for each argument in the original rule
		rules[k]=new String[result[i].length+1];
		rules[k][0]=new String(arg[i][j]);
		for (l=0;l<result[i].length;l++)
			rules[k][l+1]=new String(result[i][l]);
		k++;}

d("rules length="+rules.length);
//for (i=0;i<rules.length;i++)
//	for (j=0;j<rules[i].length;j++)
//		d(i+","+j+rules[i][j]+"\t");

}

	matcher(String rule){ this(rule,0, "|=\n","*?");}

	matcher(String rule,int stopeat) { this(rule,stopeat,"|=\n","*?");}


	matcher add(String[] rule) {
String[][] rtemp=new String[rules.length+1][];
rtemp[rules.length]=rule;
rules=rtemp;
return this;} // add a rule; uses matche's


	matcher delete(String[] rule) {return this;}


	int randomint(int from, int to){
return (int)(ran.nextFloat()*(to-from+1))+from;}


	private String pickone(String[] rule) {
// a possible improvement would be to keep track of the choices
// and not repeat.  a learning algorithm would track the results
// and increase the chance of good options
return rule[randomint(1,rule.length-1)];}


	public String match(String in){
String matches;
String w=wildcars.substring(0,1);
String out=new String(in);
// check test, pick replies, substitute matched pieces
String choice;
for (int i=0;i<rules.length;i++) {
	matches=matched(rules[i][0],out);
	if (!matches.equals(x)) { //found it
d("match:"+matches+","+out+","+i+rules[i][0]);
		choice=new String(pickone(rules[i]));
		if (stopafter==1) { 
			out=(stuff(w,matches,choice)+"\n");
			break;}
		out=stuff(rules[i][0],choice,out);}}
d("Match output:"+out+"endmo");
return out;}


	protected String matched(String pattern,String source){
//returns the values to be substituted, not the finally substituted
//  or essentially if it matched
//this version assumes match variable is at end of pattern (pitiful, eh?)
// and ther is only one
//return X if not found
//match whole words
//maybe use stringTokenizer:
//break up input according to wildchars, find each literal in output
//  fail if not found, match intervening letters to wildchars 
// (fail if wrong type, ie not single word), fitswildchar(S wild,S pattern)
// substitute corresponding wildchars into output
String in=new String(source);
String out=new String("");
String chi= new String(wildcars.substring(0,1));
int pip,sip;
//*****redo to handle multiple wildchar entries
//for (i=0;i<wildchars.length;i++);//for each possible wildcards character
//chi=wildchars.substring(i,i+1);
String puretext=new String();

pip=pattern.indexOf(chi);

if (pip>=0) //found variable match it
	puretext=pattern.substring(0,pip);//before the wildchar
else	puretext=pattern; 

sip =findex(puretext,source);
d("matched:"+pattern+","+source+pip+","+sip);
if (sip<0) return x; //not found
if (pip<0) return (""); //found but no pat to return
else return(source.substring(sip+puretext.length())); }

	boolean isnotletter(char c){
if (!( ((c >= 'A') && (c<='Z')) || 
       ((c >= 'a') && (c<='z')) )) return true;
else return false;}

	int findex(String pat, String line) {
// would have used indexOf, but need only whole words, and case insensitive
String p=pat.toLowerCase();
if (p.length()==0) return 0;//automatch
String l=line.toLowerCase();
int ind;
char prevc,nextc;
ind=l.indexOf(p);
while (ind>=0) { // check matches for whole word
	if (p.equals(x)) return ind;  // special char
	prevc=((ind==0)?' ':l.charAt(ind-1));
	nextc=((ind+p.length()==l.length())?' ':l.charAt(ind+p.length()));
	if (isnotletter(prevc) && isnotletter(nextc)){
		return ind;}
	if (l.length()>=ind+p.length()) return -1; // at end
	ind=l.indexOf(p,ind+1); }
return -1; }//not found

	public String stuff(String from, String to,String line){
//put (ie stuff) the from in place of to in the line
String out=new String(line);
int pip=findex(from,out);
while (pip>=0) {
	out= out.substring(0,pip)+to+out.substring(pip+from.length());
	d("stuff:"+out+","+from+","+to);
	pip=findex(from,out);
	if (stopafter==1) break;}
return out;}


	private void d(String line){
//System.out.println(line); 
}
}