package Serfler;

//    Serfler - an Http server written in Java based on servlets
//    Copyright (c) 1998 by Douglas Harris <doug@mscs.mu.edu>
//    Distributed under the GNU General Public License
//    <http://www.fsf.org/coopyleft/gpl.html>
//    A copy is included with this software distribution.
//    The package is available from
//    http://spectral.mscs.mu.edu/javadev/src/serfler.zip
//    

import javax.servlet.*;
import java.net.*;
import java.io.*;
import java.util.*;

public class SerflerServer implements Runnable{
    Thread t;
    ServerSocket l=null;

static SerflerContext loader = new SerflerContext();
static    String           sServerRoot = "/server";
static    String           sServletRoot = "/servlets";
static    String           sServletCode = "/javadev/servletCode";
static    String           sImageRoot = "/images";
static    String           sDocumentRoot = "/";
static    String           sServerAdmin = "/Admin";
static    String           sServerInfo = "Servler0.5";;
static    String           sServerLogFileName=null;
static    PrintStream      sServerLogStream=System.out;
static    int sMinNumberOfHandlers = 3;
static    int sMaxNumberOfHandlers = 50;
static    int sServerPort;
static    String sServerPortString;
static    int sTimeout=5000;
static    int sBacklog=50;

    static boolean sVerbose;

    static Properties sDefaultProperties=new Properties();
    static Properties sStaticProperties=new Properties(sDefaultProperties);
    static Properties sFileProperties=new Properties(sStaticProperties);
    static Properties sProperties=new Properties(sFileProperties);

  static{
    sDefaultProperties.put("document.dir","/");
    sDefaultProperties.put("server.dir","/server");
    sDefaultProperties.put("servlet.dir","/servlet");
    sDefaultProperties.put("servlet.code","/javadev/servletCode");
    sDefaultProperties.put("images.dir","/images");
    sDefaultProperties.put("admin.dir","/Admin");
    sDefaultProperties.put("server.min.handlers","30");
    sDefaultProperties.put("server.max.handlers","50");
    sDefaultProperties.put("server.port","8989");
    sDefaultProperties.put("server.timeout","5000");
    sDefaultProperties.put("server.backlog","50");
    try{
      String propFileName=System.getProperty("java.home")+File.separator+
        "lib"+File.separator+"servler.properties";
      File propFile=new File(propFileName);
      if ((propFile!=null)&&propFile.exists()&&propFile.canRead()){
        InputStream propInputStream = 
          new BufferedInputStream(new FileInputStream(propFile));
        sStaticProperties.load(propInputStream);
        propInputStream.close();
      }
    } catch(IOException x){ }
  }

    SerflerServer(String[] args){
      sMinNumberOfHandlers = 50;
      sMaxNumberOfHandlers = 100;
      sServerPort=8989;
      t=new Thread(this);
    }

    public void log(String s){
      loader.log(s);
    }

    public static int getIntProperty(String s, int d){
      try{
	return (s==null)?d:Integer.parseInt(s);
      } catch(NumberFormatException x){
	return d;
      }
    }

    public void start(){
      loader.init(sProperties);
      t.start();
      log("======Serfler Started======");
    }

//The Server JDH


    public void run(){
      loader.loadSerflerServlets();
      log("======Serfler Servlets Loaded======");
      loader.setServlets();
      log("======Other Servlets Loaded======");
      SerflerHandler aHandler;
      try{
        initHandlerQueue(sMinNumberOfHandlers);
      }catch (Exception x){
        x.printStackTrace();
      }
      try{
        sServerPort=getIntProperty(sServerPortString,sServerPort);

        l=new ServerSocket(sServerPort);
      log("======Listener running at port: " +sServerPort+" ======");
        while(true){
          aHandler = pull();
          aHandler.startConnection(l.accept());
      log("======Connection accepted======");
        }
      }catch(Exception x){x.printStackTrace();}
    }

    public static void main(String[] args){
        for(int i=0;i+1<args.length;i++){
          String flag=args[i];
          String spec=args[++i];

          if ("-a".equals(flag)){
            sProperties.put("admin.dir", spec);
          }
          if ("-b".equals(flag)){
            sProperties.put("server.backlog", spec);
          }
          if ("-c".equals(flag)){
            sProperties.put("servlet.code", spec);
          }
          if ("-d".equals(flag)){
            sProperties.put("document.dir", spec);
          }
          if ("-i".equals(flag)){
            sProperties.put("image.dir", spec);
          }
          if ("-l".equals(flag)){
            sProperties.put("server.log", spec);
          }
          if ("-m".equals(flag)){
            sProperties.put("server.minNumberHandlers", spec);
          }
          if ("-M".equals(flag)){
            sProperties.put("server.maxNumberHandlers", spec);
          }
          if ("-n".equals(flag)){
            sProperties.put("server.name", spec);
          }
          if ("-p".equals(flag)){
            sProperties.put("server.port", spec);
          }
          if ("-r".equals(flag)){
            sProperties.put("server.dir", spec);
          }
          if ("-s".equals(flag)){
            sProperties.put("servlet.dir", spec);
          }
          if ("-t".equals(flag)){
            sProperties.put("server.timeout", spec);
          }
        }
      try{
      sServerRoot = sProperties.getProperty("server.dir",sServerRoot);
      sServletRoot = sProperties.getProperty("servlet.dir",sServletRoot);
      sServletCode =sProperties.getProperty( "servlet.code",sServletCode);
      sImageRoot = sProperties.getProperty("image.dir",sImageRoot);
      sDocumentRoot = sProperties.getProperty("document.dir",sDocumentRoot);
      sServerAdmin = sProperties.getProperty("admin.dir",sServerAdmin);
      sServerPortString = sProperties.getProperty("server.port",sServerPortString);
      sServerLogFileName = 
	sProperties.getProperty("server.log",sServerLogFileName);
      if (null!=sServerLogFileName){
        sServerLogStream=new PrintStream(new FileOutputStream(sServerLogFileName));
      }
      } catch(IOException x){
      }
      try{
        sProperties.list(System.out);
        new SerflerServer(args).start();
      }catch(Exception x){x.printStackTrace();}
    }

  SerflerHandler[] sHandlers=null;
  DataInputStream hi=null;
  PipedInputStream hp;
  DataOutputStream ho;
  int n;

  public void initHandlerQueue(int n){
    this.n=n;
    try{
      hp=new PipedInputStream();
      hi=new DataInputStream(hp);
      ho=new DataOutputStream(new PipedOutputStream(hp));
      sHandlers=new SerflerHandler[n];
      for (int i=0;i<n;i++){
        sHandlers[i]=new SerflerHandler(this,i);
        push(sHandlers[i]);
      }
    }catch(Exception x){x.printStackTrace();}
  }

  public SerflerHandler pull(){
    int index=0;
    try{
      index=hi.readInt();
    }catch(Exception x){}
    return (SerflerHandler)sHandlers[index];
  }

  public void push(SerflerHandler h){
    try{
        ho.writeInt(h.getIndex());
    }catch(Exception x){x.printStackTrace();}

  }
}