// base class for colserver
// Match function to be instantiated by meta compiler's generated subclass

import java.io.*;
import java.net.*;

public class colserver   
{
  protected static serverfun[] Match; /* to be instantiated in subclass */

  public static int ctermToint(cterm t) 
    {
	if (t instanceof CIC) return ((CIC)t).val;
	else return ctermToint(dispatch(t));
    }

  public static double ctermTodouble(cterm t)
    {
	if (t instanceof CRC) return ((CRC)t).val;
	else return ctermTodouble(dispatch(t));
    }

  public static String ctermToString(cterm t)
    {   
	if (t instanceof CSC) return ((CSC)t).val;
	else return ctermToString(dispatch(t));
    }

  public static cterm intToCterm(int i)
    {
	return new CIC(i);
    }

  public static cterm doubleToCterm(double d)
    {
	return new CRC(d);
    }

  public static cterm StringToCterm(String s)
    {
	return new CSC(s);
    }

  public static cterm idToCterm(int i)
    {
	return new ID(i);
    }

    // only for spine terms:
  protected static cterm nthterm(cterm t, int n)
    {
	if (t==null || n<1) return t; else return nthterm(t.next,n-1);
    }

   
    // transform curried to spine form
  private static cterm spineterm(cterm t)
    { 
	cterm cur, ax;
	cur = t;  ax = null;
	if (cur == null) return cur;
	while (cur instanceof CAPP)
	    {   
		((CAPP)cur).right.next = ax;
		ax = ((CAPP)cur).right;
		cur = ((CAPP)cur).left;
	    } // while is capp term
	if (!(cur instanceof ID)) return null; 
	cur.next = ax; 
	return cur;
    } // spineterm
  

  public static cterm dispatch(cterm t)  // main dispatch
    {
	serverfun myf = null;;
	if (!((t instanceof ID) || (t instanceof CAPP))) return t;
	cterm pt = spineterm(t);
	ID head = (ID)nthterm(pt,0);
	//	System.out.println("id is "+head.val);
	//	System.out.println(Match);
	// System.out.println("first arg is "+nthterm(pt,1));
	myf = Match[head.val];
	return myf.fun(pt);
    }


  public static cterm parseterm(String s)
    {
	Tokens tk = new Tokens(s," \t\n\r\f()$");
	//	System.out.println("tokens: "+tk);
	return parseit(tk);
    } 

   private static cterm parseit(Tokens tk)
    {
	if (!tk.hasMoreTokens()) return null;
	String token = tk.nextToken();
	if (token.equals("cic"))
	    {
		return new CIC(Integer.parseInt(tk.nextToken()));
	    } // CIC
	if (token.equals("crc"))
	    {
		double d = 0;
		try { d = Double.parseDouble(tk.nextToken()); }
		catch (Exception ee) {ee.printStackTrace();}
		return new CRC(d);
	    } // CRC
	if (token.equals("csc"))
	    {
		return new CSC(tk.nextToken()); // special tokenizer
	    } // CSC
	if (token.equals("id"))
	    {
		return new ID(Integer.parseInt(tk.nextToken()));
	    }
	if (token.equals("capp"))
  	   {
	       cterm l, r;
	       l = parseit(tk);
	       r = parseit(tk);
	       return new CAPP(l,r);
	   }
	return null;  // default
    } //parseit aux


	// warning: inverse spine term not defined
  public static String writeCterm(cterm t) // don't worry about apps too much
    {
	String s = "";
	if (t instanceof CIC)
	    s = "(cic " + ((CIC)t).val + ")";
	if (t instanceof CRC)
	    s = "(crc " + ((CRC)t).val + ")";
	if (t instanceof CSC)
	    s = "(csc \"" + ((CSC)t).val + "\")";
	if (t instanceof ID)
	    s = "(id "+((ID)t).val +")";
	if (t instanceof CAPP)
	    {
		CAPP ta = (CAPP)t;
	        s = "(capp " + writeCterm(ta.left) + " ";
		s = s + writeCterm(ta.right) + ")";
	    } // capp
	return s;
    } // later

  public static void serve()
      {
	  byte[] buffer = new byte[2048];
	  int n = 0;
	  try
	  {
	      ServerSocket sfd= new ServerSocket(20027);
	      sfd.setReuseAddress(true);
	      Socket cfd;
	      System.out.println("col server started");
	      while(true)
		  {
		      cfd = sfd.accept();
		      DataInputStream din = new DataInputStream
			  (cfd.getInputStream());

		      PrintWriter pw = new PrintWriter(
			new OutputStreamWriter(cfd.getOutputStream()),true);
		      String request = "";
		      String response = "";
		      n = din.read(buffer,0,2048);
		      while (n>0)
			  {
			      buffer[n] = 0;
			      request = new String(buffer,0,n);      
			      System.out.println("got request  "+request);
			      cterm pterm = parseterm(request);
			      // System.out.println(writeCterm(pterm));
			      cterm answer = dispatch(pterm);
			      response = writeCterm(answer);
			      System.out.println("response is  "+response);
			      pw.println(response+".$\0"); pw.flush();
			      n = din.read(buffer,0,2048);
			  }
		      cfd.close();
		  } // server loop
	      
	  } catch (Exception e) {e.printStackTrace(); System.exit(1);}
	  
      } // serve

} // colserver base class