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();
         }
       }
     }
   }
 }