package org.paneris.bibliomania;

 import java.io.BufferedReader;

 import java.io.CharArrayWriter;

 import java.io.FilterWriter;

 import java.io.IOException;

 import java.io.InputStreamReader;

 import java.io.OutputStreamWriter;

 import java.io.StreamTokenizer;

 import java.io.Writer;

 import java.net.InetAddress;

 import java.net.ServerSocket;

 import java.net.Socket;

 import java.util.Hashtable;

 import java.util.Vector;

 import org.melati.poem.util.ArrayUtils;

 public class CommandServer extends Thread {

   private ServerSocket serverSocket;

   private Hashtable interpreters;

   private int maxInterpreterThreads;

   public CommandServer(int port, int maxInterpreterThreads) throws IOException {

     this.maxInterpreterThreads = maxInterpreterThreads;

     interpreters = new Hashtable();

     serverSocket = new ServerSocket(port);

   }

   public void run() {

     for (;;) {

       try {

         while (interpreters.size() >= maxInterpreterThreads)

           synchronized (interpreters) {

             interpreters.wait();

           }

         Socket socket = serverSocket.accept();

         if (socket.getInetAddress().equals(InetAddress.getLocalHost()) ||

             socket.getInetAddress().getHostAddress().equals("127.0.0.1"))

           new Loop(DelegatingInterpreter.it, socket).start();

         else {

           socket.getOutputStream().write(

               ("You are " + socket.getInetAddress() + " not " +

                InetAddress.getLocalHost() + "\n").getBytes());

           socket.close();

         }

       }

       catch (Exception e) {

         System.err.println("CommandServer: " + e);

       }

     }

   }

   public static interface Interpreter {

     void interpret(String[] args, Writer output, Writer errors)

         throws Exception;

   }

   public static class DelegatingInterpreter implements Interpreter {

     public static final DelegatingInterpreter it = new DelegatingInterpreter();

     public void interpret(String[] args, Writer output, Writer errors)

         throws Exception {

       ((Interpreter)Class.forName(args[0]).newInstance()).

           interpret((String[])ArrayUtils.section(args, 1, args.length),

                     output, errors);

     }

   }

   public static class CarConWriter extends FilterWriter {

     private String prefix;

     private CharArrayWriter buffer = new CharArrayWriter();

     public CarConWriter(Writer w, String prefix) {

       super(w);

       this.prefix = prefix;

     }

     private void shift() throws IOException {

       synchronized (out) {

         out.write(prefix);

         buffer.writeTo(out);

       }

       out.flush();

       buffer.reset();

     }

     public void write(int c) throws IOException {

       buffer.write(c);

       if (c == '\n')

         shift();

     }

     public void write(char cbuf[], int off, int len)

         throws IOException {

       int end = off + len;

       for (int i = off; i < end; ++i) {

         if (cbuf[i] == '\n') {

           buffer.write(cbuf, off, i + 1 - off);

           shift();

           off = i + 1;

         }

       }

       if (off < end)

         buffer.write(cbuf, off, end - off);

     }

     public synchronized void write(String str, int off, int len)

         throws IOException {

       int end = off + len;

       for (;;) {

         int i = str.indexOf('\n', off);

         if (i == -1) {

           buffer.write(str, off, end - off);

           break;

         }

         else {

           buffer.write(str, off, i + 1 - off);

           shift();

           off = i + 1;

         }

       }

     }

   }

   public class Loop extends Thread {

     private Interpreter interpreter;

     private Socket socket;

     private StreamTokenizer in;

     private Writer out;

     private Writer outputs;

     private Writer errors;

     private Loop(Interpreter interpreter, Socket socket) throws IOException {

       this.interpreter = interpreter;

       this.socket = socket;

       in = new StreamTokenizer(new BufferedReader(

                                new InputStreamReader(socket.getInputStream())));

       in.ordinaryChars(33, 127);

       in.wordChars(33, 127);

       in.quoteChar('"');

       in.quoteChar('\'');

       in.slashSlashComments(false);

       in.slashStarComments(false);

       in.eolIsSignificant(true);

       out = new OutputStreamWriter(socket.getOutputStream());

       outputs = new CarConWriter(out, ".");

       errors = new CarConWriter(out, "!");

     }

     public void run() {

       interpreters.put(this, Boolean.TRUE);

       try {

         Vector args = new Vector();

         out.write(">\n");

         out.flush();

         handle: for (;;) {

           switch (in.nextToken()) {

             case StreamTokenizer.TT_EOL:

               String[] theArgs = new String[args.size()];

               args.copyInto(theArgs);

               args.removeAllElements();

               try {

                 interpreter.interpret(theArgs, outputs, errors);

               }

               catch (Exception e) {

                 errors.write(e + "\n");

               }

               out.write(">\n");

               out.flush();

               break;

             case StreamTokenizer.TT_EOF:

               break handle;

             default:

               args.addElement(in.sval);

           }

         }

       }

       catch (Exception e) {

         System.err.println("CommandServer.Loop.run: " + e);

       }

       finally {

         try { out.close(); } catch (Exception e) {}

         try { socket.close(); } catch (Exception e) {}

         interpreters.remove(this);

         synchronized (interpreters) {

           interpreters.notifyAll();

         }

       }

     }

   }

 }