/*

Program Code ------ | S. Cartwright
Program Description | The Server acts as a network hub, and bridge
                    | between the clients and the database.
Version ----------- | 1
Creation Date ----- | 5/01

*/

//*****************************************************************************
//State the name of the Package these classes are a part

package Server;

//*****************************************************************************
//Import the required utility packages

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

//*****************************************************************************
//Declare the ServerNetworkCore class

public class ServerNetworkCore
  {

//*****************************************************************************
// Decalre the global data
  private MessagePacket SMP=new MessagePacket();
  private int expectedClients;
  private String[] clientName;
  private int[] clientID;
  private int connectedClients=0;
  private Socket client[];
  private OutputStream clientOutput[];
  private InputStream clientInput[];
  private ServerSocket serverSocket;
  private TextArea display;
  private int clientScan=0;
  public boolean _RESET=false;

//*****************************************************************************
// Close all the server's client connections

  public void closeServer()
    {
    try
      {
//Close the server socket
      serverSocket.close();
//Close the client streams
      for(int t=0;t<client.length;t++) client[t].close();
      }
    catch(Exception e)
      {
      e.printStackTrace();
      }
    }

//*****************************************************************************
// Construct the ServerNetworkCore, passing it the client names,
// and also the TextArea to display messages onto

  public ServerNetworkCore(String[] clientNames,TextArea display)
    {
    expectedClients=clientNames.length;
    clientName=clientNames;
    clientID=new int[expectedClients];
    display.append("Opening socket for remote clients...");
    try
      {
      serverSocket=new ServerSocket(5000,expectedClients);
      }
    catch(Exception e){e.printStackTrace();}
    display.append("DONE");
    this.display=display;
//Create arrays to hold references to client I/O streams for this socket
    clientOutput=new OutputStream[expectedClients];
    clientInput=new InputStream[expectedClients];
//Create an array to hold client cocket connections
    client=new Socket[expectedClients];
    try
      {
//Listen for connection requests from all expected clients
      grabClients();
      }
    catch(Exception e){e.printStackTrace();}
    }

//*****************************************************************************
// Return the number of expected clients to this Server

  public int getExpectedClients()
    {
    return(expectedClients);
    }

//*****************************************************************************
// Return the clients ID number, given its name
// Not found returns -1

  public int getClientID(String name)
    {
    for(int index=0; index<expectedClients; index++)
      if(clientName[index].equals(name)) return(clientID[index]);
    return(-1);
    }

//*****************************************************************************
// Store the clients ID number, given ID and name

  public void setClientID(String name,int ID)
    {
    for(int index=0; index<expectedClients; index++)
      if(clientName[index].equals(name)) clientID[index]=ID;
    }

//*****************************************************************************
// Sends a message to the named client, multiple clients with the
// same name should be enumerated, as only the first client found
// is sent the message

  public void sendMessage(String message, String clientName) throws Exception
    {
    OutputStream OPS=clientOutput[getClientID(clientName)];
    for(int index=0; index<message.length(); index++)
        OPS.write((int)message.charAt(index));
    OPS.write((int)8);//Character 8 terminates the transmisison
    }

//*****************************************************************************
// Sends a message using a MessagePacket object, multiple clients with the
// same name should be enumerated, as only the first client found
// is sent the message

  public void sendMessage(MessagePacket mp) throws Exception
    {
    if(mp==null) return;
    OutputStream OPS=clientOutput[mp.messageID];
    for(int index=0; index<mp.message.length(); index++)
        OPS.write((int)mp.message.charAt(index));
    OPS.write((int)8);//Character 8 terminates the transmisison
    }

//*****************************************************************************
// Sends a message to the OutputStream, multiple clients with the
// same name should be enumerated, as only the first client found
// is sent the message

  public void sendMessage(String message, OutputStream OPS) throws Exception
    {
    for(int index=0; index<message.length(); index++)
        OPS.write((int)message.charAt(index));
    OPS.write((int)8);//Character 8 terminates the transmisison
    }

//*****************************************************************************
// Get a message from the given client, identified by its name

  public String getMessage(String clientName) throws Exception
    {
    String message="";
    char c;
    InputStream OPS=clientInput[getClientID(clientName)];
    while((c=(char)OPS.read())!=8)//Character 8 terminates the transmisison
      message+=c;
    return (message);
    }

//*****************************************************************************
// Get a message from the given client, identified by its InputStream

  public String getMessage(InputStream OPS) throws Exception
    {
    String message="";
    char c;
    while((c=(char)OPS.read())!=8)//Character 8 terminates the transmisison
      message+=c;
    return (message);
    }

//*****************************************************************************
// This method halts the thread until all clients have connected

  public void grabClients() throws Exception
    {
    int noTills=0;
    String response;
    display.append("\n");
    for(int c=0;c<50;c++) display.append("_"); display.append("\n");
    display.append("\nWaiting for client connection requests...\n");
    do
      {
      //Wait for next client...
      display.append("\nWaiting for client "+(connectedClients+1)+" out of "+expectedClients+" expected clients.\n");
      client[connectedClients]=serverSocket.accept();
      //Setup IO streams for client...
      clientOutput[connectedClients]=client[connectedClients].getOutputStream();
      clientInput[connectedClients]=client[connectedClients].getInputStream();
      //Get clients ID, and assign it an ID number
      display.append("Client connection request received, querying clients ID now...\n");
      sendMessage("Hello client! Please Send your ID now...\n",clientOutput[connectedClients]);
      display.append("Waiting for clients response...\n");
      response=getMessage(clientInput[connectedClients]);
      display.append("The new client is identified as the: "+response+"\n");
      //Send new enumarated ID if this is a Till
      if(response.equals("Till"))
        {
        response+=" "+(++noTills);
        display.append("A till has been found! Sending the till it's ID number now,\n");
        display.append("ID sent to Till is: "+response+"\n");
        sendMessage(response,clientOutput[connectedClients]);
        }
      //Using the clients name, add it to the list of known clients for this
      //session
      setClientID(response,connectedClients);
      connectedClients++;
      }
    while(connectedClients<expectedClients);
    for(int c=0;c<50;c++) display.append("_"); display.append("\n\n");
    //Clients wait until the server has connected all of them, when it has
    //we notify all the clients of successfull connection...
    for(int index=0;index<connectedClients;index++)
      sendMessage(new MessagePacket(index,"SERVER IS READY!"));
    }

//*****************************************************************************
// This method returns TRUE if all the clients are connected

  public boolean allConnected()
    {
    return(connectedClients==expectedClients);
    }

//*****************************************************************************
// This method

  public MessagePacket getNextClientMessage() throws Exception
    {
    String message="";
    while(!_RESET)
      {
      for(int index=clientScan;index<connectedClients;index++)
        {
        if(clientInput[getClientID(clientName[index])].available()!=0)
          {
          message=getMessage(clientName[index]);
          display.append(clientName[index]+":"+message+" = pending | ");
          return(SMP.newMessagePacket(getClientID(clientName[index]),message));
          }
        if(++clientScan==connectedClients) clientScan=0;
        }
      }
    _RESET=false;return null;
    }

  }