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


/**
 * Un serveur simpliste qui ne fait rien d'autre que d'ouvrir une soquette
 * et de rester à l'écoute de clients éventuels.
 * <P>
 * C'est une << appletication >> (marche aussi bien en applet qu'en application).
 *
 * @author Peter T. Sander
 * @version 1.1  15/11/97
 */

public class ServeurSimple extends java.applet.Applet {
  private static final boolean AS_APPLET = true;
  private static final int PORT = 6666;  // par défaut
  private int port;
	
  /**
    * No-args constructeur.  Utilise le port 6666 par défaut.
    * <P>
    * Seulement les applets passent par ici.
    */
  public ServeurSimple() {
    this(PORT, AS_APPLET);
  }
	
  /**
    * Constructeur.  Utilise le port 6666 par défaut.
    * <P>
    * Seulement les applications passent par ici.
    *
    * @param asApplet applet ou application ?
    */
  public ServeurSimple(boolean asApplet) {
    // Appel de l'autre constructeur
    this(PORT, asApplet);
  }
	
  /**
    * Constructeur.  Les applets et les applications passent par ici toutes
    * les deux.
    *
    * @param port le port où les clients viendront s'attacher
    * @param asApplet applet ou application ?
    */
  public ServeurSimple(int port, boolean asApplet) {
    super();

    this.port = port;

    if (!asApplet) {
      start();
    }

  }

  /**
    * Initialise l'applet.  Les applications ne passent pas par ici.
    */
  public void init() {
    try {
      port = Integer.parseInt(getParameter("port"));
    } catch (NumberFormatException e) {
      port = PORT;
    }
  }

  /**
    * La méthode qui fait le boulot.  Elle ouvre une soquette et y reste
    * à l'attente d'un client.  Ensuite elle lui envoie un message et écho
    * bêtement ce que ledit client dit (sur une ligne).  Ensuite elle ferme
    * la connexion et passe au client suivant.
    */
  public void start() {
    ServerSocket soquetteServeur = null;
    Socket soquette = null;
    int client = 0;

    // crée une soquette de type serveur rattachée au port, 
    // 5 personnes en attente maxi
    try {
      soquetteServeur = new ServerSocket(port, 5);
    } catch (IOException e) {
      System.err.println("Impossible de créer un ServerSocket");
      return;
    }

    // il ne reste qu'à attendre que quelqu'un veuille bien nous parler
    while (true) {
      try {
	soquette = soquetteServeur.accept();
        // tiens, un client !
	client++; 

	// associe un flot de caractères en sortie à la soquette
	PrintWriter out = new PrintWriter(soquette.getOutputStream());

	// et un flot en entrée. On utilise un InputStreamReader pour
	// Transformer un InputStream en Reader
	BufferedReader in = new BufferedReader(new InputStreamReader(soquette.getInputStream()));

	// envoie un message amical d'acceuil 
	out.println("Qu'es' tu veux, toé ?");
	out.flush();

	// et attend tranquillement la réponse...
	String reply = in.readLine();
	System.out.print("Le client no. " + client + " m'a dit : ");
	System.out.println(reply);
	System.out.flush();
      } catch (IOException e) {
	System.err.println("Opération foireuse sur la soquette : " + e);
      } finally {
	try {
	  // on ferme cette connexion et on attend la suivante
	  soquette.close();
	} catch (IOException e) {
	  e.printStackTrace();
	}
      }
    }
  }
	
  /**
    * La méthode principale d'une application.
    * <P>
    * Le no. du port est un argument optionel à l'application.
    *
    * @param args lezarguments
    */
  public static void main(String[] args) throws NumberFormatException {
    // ne fait aucune vérification des arguments
    if (args.length == 1) {
      new ServeurSimple(Integer.parseInt(args[0]), !AS_APPLET);
    } else {
      new ServeurSimple(!AS_APPLET);
    }
  }
}