using System;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Net;

public class DemoServer
{
    private TcpListener m_listener;
    bool _started = false;

    public DemoServer()
    {
    }

    public void Start(IPEndPoint endpoint)
    {
        m_listener = new TcpListener(endpoint);
        m_listener.Start();
        _started = true;

        // On attend qu'un client se connecte
        m_listener.BeginAcceptTcpClient(HandleClient, null);
    }

    private void HandleClient(IAsyncResult res)
    {
        if(_started)
        {
            try
            {
                // Un client s'est connecté. On le récupère:
                TcpClient client = m_listener.EndAcceptTcpClient(res);

                // On se remet immédiatement à l'écoute d'un autre client qui pourrait arriver:
                m_listener.BeginAcceptTcpClient(HandleClient, null);

                // Et on engage en même temps la conversation avec le client connecté:
                this.ProcessClient(client);
            }
            catch(Exception ex)
            {
                Trace.TraceError("Server Error : {0}", ex.Message);
            }
        }
    }

    public void Stop()
    {
        _started = false;
        m_listener.Stop();
    }

    public void ProcessClient(TcpClient client)
    {
        // A ce stade la connexion est établie, 
        // le dialogue entre le client et le serveur peut commencer.
        try
        {
            // On suppose ici que c'est le client qui parle en premier.
            // On attend donc un message de sa part (qui est ici une string).
            // Le message reçu ne peut pas dépasser 5000 octets.

            StreamReader reader = new StreamReader(client.GetStream(), Encoding.UTF8);
            char[] buffer = new char[5000];
            int nbrBytesRead = reader.Read(buffer, 0, buffer.Length);
            string messageReceived = new string(buffer);

            // On traite le message d'une façon ou d'une autre.
            // Ici on lance un événement pour qu'il soit traité ailleurs:
            if(this.MessageReceived != null)
                this.MessageReceived(this, new MessageReceivedEventArgs() { Message = messageReceived });

            // On envoie une réponse au client avant de fermer la connexion.
            StreamWriter writer = new StreamWriter(client.GetStream());
            writer.Write("OK, bien reçu !");
            writer.Flush();	// ne pas oublier de flusher pour que le message parte !

        }
        catch(Exception ex)
        {
            Trace.TraceError("Server Error : {0}", ex.Message);
        }
        finally
        {
            client.GetStream().Close();
            client.Close();
        }
    }

    public event EventHandler<MessageReceivedEventArgs> MessageReceived;
}

public class MessageReceivedEventArgs : EventArgs
{
    public string Message { get; set; }
}

public class Program
{
    static void Main(string[] args)
    {
        DemoServer server = new DemoServer();
        server.MessageReceived += server_MessageReceived;

        // on écoute le port 666
        server.Start(new IPEndPoint(IPAddress.Loopback, 666));

        Console.WriteLine("En attente de messages. Presser Entrée pour quitter.");
        Console.ReadLine();

        server.Stop();
    }

    static void server_MessageReceived(object sender, MessageReceivedEventArgs e)
    {
        Console.WriteLine("Message reçu: " + e.Message);
    }
}

static void Connect(String server, String message) 
{
  try 
  {
    // Create a TcpClient.
    // Note, for this client to work you need to have a TcpServer 
    // connected to the same address as specified by the server, port
    // combination.
    Int32 port = 13000;
    TcpClient client = new TcpClient(server, port);

    // Translate the passed message into ASCII and store it as a Byte array.
    Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);         

    // Get a client stream for reading and writing.
   //  Stream stream = client.GetStream();

    NetworkStream stream = client.GetStream();

    // Send the message to the connected TcpServer. 
    stream.Write(data, 0, data.Length);

    Console.WriteLine("Sent: {0}", message);         

    // Receive the TcpServer.response.

    // Buffer to store the response bytes.
    data = new Byte[256];

    // String to store the response ASCII representation.
    String responseData = String.Empty;

    // Read the first batch of the TcpServer response bytes.
    Int32 bytes = stream.Read(data, 0, data.Length);
    responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
    Console.WriteLine("Received: {0}", responseData);         

    // Close everything.
    stream.Close();         
    client.Close();         
  } 
  catch (ArgumentNullException e) 
  {
    Console.WriteLine("ArgumentNullException: {0}", e);
  } 
  catch (SocketException e) 
  {
    Console.WriteLine("SocketException: {0}", e);
  }

  Console.WriteLine("\n Press Enter to continue...");
  Console.Read();
}