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


/**
 * Un serveur simpliste qui ne fait rien d'autre que d'ouvrir une socket
 * 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 ; modifie par Patrick Itey
 */

public class SimpleServer 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 SimpleServer() {
    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 SimpleServer(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 SimpleServer(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 socket 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 socketServeur = null;
    Socket socket = null;
    int client = 0;

    // crée une socket de type serveur rattachée au port, 
    // 5 personnes en attente maxi
    try {
      socketServeur = 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 {
        socket = socketServeur.accept();
        // tiens, un client !
        client++; 

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

        // et un flot en entrée. On utilise un InputStreamReader pour
        // Transformer un InputStream en Reader
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.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 socket : " + e);
      } finally {
        try {
          // on ferme cette connexion et on attend la suivante
          socket.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 SimpleServer(Integer.parseInt(args[0]), !AS_APPLET);
    } else {
      new SimpleServer(!AS_APPLET);
    }
  }
}