package javacodebook.net.socket.threadserver;

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

/**
 * Dieser kleine "Datums-Server" empfängt auf Port 5000 über TCP/IP gesendete
 * Nachrichten. Wird "date" gesendet, übermittelt der Server dem Sender das
 * Datum, bei "help" wird eine Kurzbeschreibung der verfügaren Befehle über-
 * tragen, und bei "end" wird die Verbindung unterbrochen. Bei allen anderen
 * Eingaben wird eine Fehlermeldung zurückgeschickt.
 * Dadurch, dass bei jeder Anfrage ein neuer Thread gestartet wird, können
 * mehrere Anfragen parallel beantwortet werden.
 */
public class TCPThreadServer extends Thread {

    private Socket client;
    private BufferedReader clientIn;
    private PrintWriter clientOut;
    private String cRemoteClient;

    /**
     * Konstruktor von TCPThreadServer. Ihm wird eine Referenz von dem Socket
     * des verbundenen Clients übergeben.
     */
    public TCPThreadServer(Socket client) {
        try {
            this.client= client;

            // getInetAddress() liefert die IP-Addresse des Clients
            System.out.println("Client verbunden von "
                    + client.getInetAddress());

            // Der InputStream vom Socket wird geholt, und an einen
            // BufferedReader weitergeleitet. So können Client-Meldungen
            // leicht ausgelesen werden.
            clientIn = new BufferedReader(
                    new InputStreamReader(client.getInputStream()));

            // Ein PrintWriter leitet sämtliche Eingaben, an den OutputStream
            // des Clients weiter. Über Ihn können einfach Meldungen an den
            // Client übertragen werden.
            clientOut = new PrintWriter(client.getOutputStream(),true);

        }
        catch(Exception err) {
            err.printStackTrace();
        }
     }

     /**
      * "run" wird aufgerufen, wenn der Thread gestartet wird. Hier findet
      * die gesamte Abhandlung des Clients statt.
      */
    public void run() {
         try {
               // Befehl vom Client
            String command;

            // Befehl vom Client wird ausgelesen und dem String command
            // zugewiesen, die while()-Schleife wird solange ausgeführt,
            // solange command nicht "end" ist.
            while(!(command=clientIn.readLine()).equalsIgnoreCase("end")) {
                // wird beim Befehl "date" ausgeführt
                if(command.equals("date")) {
                    clientOut.println("Das Datum im Java Format: "
                        + new java.util.Date());
                }
                // wird beim Befehl "help" ausgeführt
                else if(command.equals("help")) {
                    clientOut.println("Befehle: \"date\" liefert Datum,"
                            +" \"help\" fuer Hilfe, "
                            +"\"end\" fuer Verbindungsende");
                }
                // wird bei allen anderen Fällen ausgeführt.
                else {
                    clientOut.println("Sorry, \""+command
                            +"\" ist falscher Befehl!");
                }
            }
         }
         catch (Exception err) {
              err.printStackTrace();
         }
         finally {
              try {
                   System.out.println("Verbindung zu "+ client.getInetAddress()
                           +" wird beendet.");
                   client.close();
              }
              catch (IOException err2) {
                  err2.printStackTrace();
              }
         }
    }

    /**
     * main-Methode
     */
    public static void main(String [] args) {
        try {
            // Ein ServerSocket wird am Port 5000 angemeldet
            ServerSocket servSock = new ServerSocket(5000);

            System.out.println("Warte auf Verbindung...");

            // Der Server wartet endlos auf Anfragen. Sobald eine eintrifft,
            // wird ein neuer Thread gestartet, der sich um alles weitere
            // kümmert.
            while(true) {
                // Durch accept() wird der Server in Warteposition gebracht.
                // In dieser Methode verweilt er, bis ein Client auf diesem
                // Port ein Request abgibt. Erst dann wird das Socket Objekt,
                // welches eine Repräsentation des Clients darstellt,
                // zurückgegeben.
                Socket client = servSock.accept();

                // Der Thread, der alles weitere erledigt, ist eine Instanz
                // dieser Klasse. Es wird jedesmal eine Instanz gebaut und
                // gestartet, wenn ein Client sich mit diesem Server
                // verbindet. Übergeben wird das SocketObjekt.
                new TCPThreadServer(client).start();
            }
          }
         catch(IOException err) {
              err.printStackTrace();
          }
     }
}