package udpchatserver;

/**
 * Title:
 * Description:
 * Copyright:    Copyright (c) 2001
 * Company:
 * @author
 * @version 1.0
 */

import java.net.* ;
import java.io.* ;
import java.lang.* ;
import java.util.* ;

public class ChatServerThread extends Thread{

  static final int BUFFER_SIZE = 512;    //Sets Max Packet Size
  private DatagramPacket IncomingPacket;     //Socket to Communicate with
  ClientsTableEntry CTE;
  DatagramSocket OutToClientSocket;
  Hashtable ClientsTable;
  byte[] RecievedBuffer = new byte[BUFFER_SIZE];
  byte[] SendAllBuffer = new byte[BUFFER_SIZE];
  byte[] SendPrivateBuffer = new byte[BUFFER_SIZE];
  String SendPrivateString;
  String SendAllString;
  String Blank = " ";
  String Username;
  String RecieverName;
  String SenderName;
  String Message;
  InetAddress RecieverIPAddress;
  InetAddress ClientIPAddress;
  int RecieverPort;
  int ClientPort;



public ChatServerThread(DatagramPacket ArrivedPacket, Hashtable MasterClientsTable) {

    //Create buffers to hold incoming & outgoing messages
    IncomingPacket = ArrivedPacket;
    ClientsTable = MasterClientsTable;

}

public void run(){



      byte[] buf = new byte [BUFFER_SIZE];


      //Fill the recieved buffer with the data from incoming packet
      RecievedBuffer = IncomingPacket.getData();

      //Get Client IP/Port from incoming packet
      ClientIPAddress = IncomingPacket.getAddress();
      ClientPort = IncomingPacket.getPort();

      //Parse packet for the info contained within
      for (int i=0; i<RecievedBuffer.length; i++)
        System.out.print((int)RecievedBuffer[i] + " ") ;
      System.out.println("Parsing new Packet: ");
      String PacketString = new String(RecievedBuffer);
      System.out.println("Packet: " +PacketString + "\n" + "from address: " + ClientIPAddress.toString() + ", port: " + ClientPort);
      int PacketType = RecievedBuffer[0];
      System.out.println("PacketType: " + PacketType);
      String Resv = new String(RecievedBuffer,1,2);
      int ULength = RecievedBuffer[3];
      System.out.println("ULength: " + ULength);
      Username = new String(RecievedBuffer,4,ULength);
      System.out.println("Username: " + Username);
      int MLength = RecievedBuffer[4+ULength];
      System.out.println("MLength: " + MLength);
      Message = new String(RecievedBuffer,5+ULength,MLength);
      System.out.println("Message: " + Message);

      boolean SendAll = false;
      boolean SendPrivate = false;
      boolean PrivateTo = false;


//Incoming Packet is a Join Packet: Must Check username and validate user

      if (PacketType == 1) {

          System.out.println("client " + Username + " wants to join chat");
          boolean AvailableUsername = CheckNewUsername(Username);
            if(AvailableUsername){  //This is a new client wanting to join
                System.out.println("Username " + Username + " is available");
                boolean ActiveState = true;
                ClientsTableEntry NewClient = new ClientsTableEntry(Username, ClientIPAddress, ClientPort, ActiveState);
                ClientsTable.put(Username, NewClient);
                System.out.println("Username " + Username + " has been added to table");
                ListAll();
                SendPrivateBuffer = MakePacket(1, "Server", Username + ", welcome to the chat");
                SendAllBuffer = MakePacket(3, "Server", Username + " has joined");
                SendPrivate = true;
                SendAll = true;
            }
            else{
                boolean ClientExists = CheckSenderID(ClientIPAddress, ClientPort);
                if(ClientExists){  //Old Client wanting to Rejoin
                    System.out.println("Username " + Username + " is returning to the group");
                    boolean ActiveState = true;
                    UpdateClientState(Username, ClientIPAddress, ClientPort, ActiveState);
                    SendPrivateBuffer = MakePacket(1, "Server", Username + ", welcome to the chat");
                    SendAllBuffer = MakePacket(3, "Server", Username + " has joined");
                    SendPrivate = true;
                    SendAll = true;
                }
                else{   ///Username already taken by someone else
                    System.out.println("Username " + Username + " is already taken");
                    SendPrivateBuffer = MakePacket(3, "Server", Username + " is already taken");
                    SendError(SendPrivateBuffer);

                }
          }
      }


//Incoming Packet is a Leave Packet: Must validate user, update client state,
//and send Leave message to all Clients

      else if (PacketType == 2 ){

          boolean ClientExists = CheckSenderID(ClientIPAddress, ClientPort);
              System.out.println("ClientExists== " +ClientExists);
           if(ClientExists){
              System.out.println("Client " + GetUsername2(ClientIPAddress, ClientPort) + " leaving the group.");
              boolean ActiveState = false;
              UpdateClientState(Username, ClientIPAddress, ClientPort, ActiveState);
              SendAllBuffer = MakePacket(3, "Server", GetUsername2(ClientIPAddress, ClientPort) +" has left the chat");
              SendPrivate = false;
              SendAll = true;
           }
          else{
              System.out.println("Client " + GetUsername2(ClientIPAddress, ClientPort) +
                                " tyring to leave the group, but not found.");
              String FakeLeave = new String("Who's Sending Fake Leave Packets?");
              SendAllBuffer = MakePacket(3, "Server", FakeLeave);
              SendPrivate = false;
              SendAll = true;
          }
      }

//Incoming Packet is a Message Packet: Must validate Sender and Reciever,
//or decide if the message is to be broadcast

      else if (PacketType == 3){

          System.out.println("conversation between clients");
          if(ULength==0){
              System.out.println("Message is to be broadcast");
              if(CheckSenderID(ClientIPAddress, ClientPort)){
                  System.out.println("SenderID is Valid");
                  SendAllBuffer = MakePacket(3, GetUsername2(ClientIPAddress, ClientPort), Message);
                  SendPrivate = false;
                  SendAll = true;
              }
              else{
                  System.out.println("SenderID is inValid");
                  System.out.println("From user: " + GetUsername2(ClientIPAddress, ClientPort));
                  SendAllBuffer = MakePacket(3, "Unkown User", Message);
                  SendPrivate = false;
                  SendAll = true;
              }
          }
          else{
              System.out.println("Message is to be sent to " + Username);
              if((CheckSenderID(ClientIPAddress, ClientPort)) & (CheckRecieverID(Username))){
                  System.out.println("Sender and Reciever ID's are valid");
                  SendPrivateBuffer = MakePacket(3, SenderName, Message);
                  SendPrivate = true;
                  SendAll = false;
                  PrivateTo = true;

              }
              else{
                  System.out.println("Sender and Reciever ID's are invalid");
                  SendPrivateBuffer = MakePacket(3, "Server", "You are sending to an unknown user");
                  SendPrivate = true;
                  SendAll = false;
              }
          }
      }

//Package type has been determined, now choose to Send private message, Broadcast, or both

//Send Private message to one client
        if (SendPrivate){
            if(PrivateTo){
              SendPrivatePacket(SendPrivateBuffer, ClientIPAddress, RecieverName);
              System.out.println("SendPrivateTo == true");
            }
            else{
            System.out.println("SendPrivate == true");
            SendPrivatePacket(SendPrivateBuffer, ClientIPAddress, Username);
            }
        }

//Broadcast Message to All Clients
        if(SendAll){
            System.out.println("SendAll == true");
            SendAllPacket(SendAllBuffer);
        }
      }


public void SendAllPacket(byte [] sendBuffer){

//Method to Broadcast messages to all active clients

try {
        //Sets up DatagramSocket to send to Client on any available port
        OutToClientSocket = new DatagramSocket();

        //Cycle through the HashTable and send the same packet to all active clients
        Enumeration e = ClientsTable.elements();
        while(e.hasMoreElements()){
            CTE = (ClientsTableEntry)e.nextElement();
                if(CTE.GetActiveState() == true){
                    DatagramPacket PacketToClient = new DatagramPacket(sendBuffer, sendBuffer.length, CTE.GetClientIP(), CTE.GetClientPort());
                    OutToClientSocket.send(PacketToClient);

                    System.out.println("Sent" + sendBuffer +", to address: "
                                      + ClientIPAddress + ", port: " + ClientPort);
                    System.out.println("Sending Packet to all clients");
                    System.out.println("Client IP :" + ClientIPAddress);
                    System.out.println("Username: " + Username);
                    System.out.println("SendString: " + SendPrivateBuffer.toString() + "\n");

                }
        }
  } catch (SocketException e) {

      System.err.println("Can't open OutToClientSocket");
      e.printStackTrace ();
      System.exit (1);

  } catch (IOException e) {

      System.err.println("Communication error");
      e.printStackTrace ();

  } finally {

      OutToClientSocket.close();
  }
}

public void SendPrivatePacket(byte [] sendBuffer, InetAddress tempClientIPAddress, String tempUsername){

//Method to Send Message to a specific Client

  try {
        //Get the IP and Port of the desired client, Set up Socket, and Send Packet
        GetRecieverIPPort(tempUsername);
        OutToClientSocket = new DatagramSocket();

        System.out.println("Sending paket to " + tempUsername);
        System.out.println("send buffer: " +sendBuffer.toString());
        System.out.println("Reciever IP: " +ClientIPAddress);
        System.out.println("Reciever port: " +ClientPort);

        DatagramPacket PacketToClient = new DatagramPacket(sendBuffer, sendBuffer.length, RecieverIPAddress, RecieverPort);
        OutToClientSocket.send(PacketToClient);

        System.out.println("Sent" + sendBuffer + ", to address: " + ClientIPAddress + ", port: " + ClientPort + "\n");

  } catch (SocketException e) {

      System.err.println("Can't open OutToClientSocket");
      e.printStackTrace ();
      System.exit (1);

  } catch (IOException e) {

      System.err.println("Communication error");
      e.printStackTrace ();

  } finally {

      OutToClientSocket.close();

  }
}

 public void SendError( byte [] sendBuffer){

 //Method which send error messages to the client who sent the packet to the server

 try {
        //Get the IP and Port of the desired client, Set up Socket, and Send Packet
        OutToClientSocket = new DatagramSocket();

        System.out.println("Sending paket to " + Username);
        System.out.println("send buffer: " +sendBuffer.toString());
        System.out.println("Reciever IP: " +ClientIPAddress);
        System.out.println("Reciever port: " +ClientPort);

        DatagramPacket PacketToClient = new DatagramPacket(sendBuffer, sendBuffer.length, ClientIPAddress, ClientPort);
        OutToClientSocket.send(PacketToClient);

        System.out.println("Sent" + sendBuffer + ", to address: " + ClientIPAddress + ", port: " + ClientPort + "\n");

  } catch (SocketException e) {

      System.err.println("Can't open OutToClientSocket");
      e.printStackTrace ();
      System.exit (1);

  } catch (IOException e) {

      System.err.println("Communication error");
      e.printStackTrace ();

  } finally {

      OutToClientSocket.close();

  }
}


 public byte[] MakePacket(int PacketType, String Username, String Message){

 //Same makepacket method which creates the outgoing packets as in the client

          byte [] data = new byte[512];

          byte[] UsernameA = Username.getBytes();
          byte[] MessageA = Message.getBytes();

          int i = 0;
          data[i++] = (byte)PacketType;
          data[i++] = (byte)'R';
          data[i++] = (byte)'E';
          data[i++] = (byte)UsernameA.length;
          for(int n=0; n<UsernameA.length; n++)
                data[i++] = UsernameA[n];
          data[i++] = (byte)MessageA.length;
          for(int n=0; n<MessageA.length; n++)
                data[i++] = MessageA[n];

          return data;
  }

public void ListAll(){

//Testing method to simply output all current entries in the clientsTable
    Enumeration e = ClientsTable.keys();
        System.out.print("Current Users in Clients table: ");
        while(e.hasMoreElements()){
          System.out.print(e.nextElement() + ", ");
        }
        System.out.print("\n");
}

public boolean CheckNewUsername(String NewUsername){

//Method to Check if Username is in HashTable


     boolean Available = true;
        Enumeration e = ClientsTable.elements();
        System.out.println("\nChecking NewUSername " + NewUsername + " against clientsTableEntries: ");
        while(e.hasMoreElements()){
            CTE = (ClientsTableEntry)e.nextElement();
                System.out.print("TableEntry: " +CTE.GetUsername() + " vs NewUsername: " + NewUsername);
                if(NewUsername.equals((String)CTE.GetUsername())){
                  System.out.println(" -> Not Available");
                  Available = false;
                  break;
                }
                else{

                  Available = true;
                  System.out.println(" -> Available");
                }
        }
        return Available;
}


public String GetUsername2(InetAddress SenderIP, int SenderPort){

//Method to Get a Username given an IP and Port

        Enumeration e = ClientsTable.elements();
        System.out.println("\nGetting USername... SenderIP:  " + SenderIP +
                          " SenderPort: " + SenderPort);
            while(e.hasMoreElements()){
            CTE = (ClientsTableEntry)e.nextElement();
                System.out.print("TableEntry: " +CTE.GetUsername());
                System.out.print(" IP: " +CTE.GetClientIP());
                System.out.println(" Port: " +CTE.GetClientPort());
                if((SenderIP.equals((InetAddress)CTE.GetClientIP()))
                &(SenderPort==(int)CTE.GetClientPort())){
                     Username = CTE.GetUsername();
                     System.out.println("Username is: " + Username);
                     break;
                }
                else{
                    System.out.println("Username is not "+ CTE.GetUsername() + " for IP: " + SenderIP + " Port: " + SenderPort);
                }
        }
        return Username;
}

public boolean CheckSenderID(InetAddress SenderIP, int SenderPort){

//Method to Check the validity of a senders Identifiction
    System.out.println("\nChecking SenderID... SenderIP:  " + SenderIP +
                          " SenderPort: " + SenderPort);

    boolean ValidUser = true;
        Enumeration e = ClientsTable.elements();
        while(e.hasMoreElements()){
                CTE = (ClientsTableEntry)e.nextElement();
                System.out.print("TableEntry: " +CTE.GetUsername());
                System.out.print(" IP: " +CTE.GetClientIP());
                System.out.print(" Port: " +CTE.GetClientPort());
                if((SenderIP.equals((InetAddress)CTE.GetClientIP())) &
                   (SenderPort==(int)CTE.GetClientPort())){
                      ValidUser = true;
                      System.out.println(" -> Valid Sender");
                      SenderName = CTE.GetUsername();
                      System.out.println("SenderUsername has been set to: " + SenderName);

                      break;
                }
                else{
                      ValidUser = false;
                      System.out.println(" -> Invalid Sender");
                }

        }
        return ValidUser;
}

public boolean CheckRecieverID(String RecieverUsername){

//Method to Check the validity of a recievers Identifiction

     boolean valid = false;
        Enumeration e = ClientsTable.elements();
        System.out.println("\nChecking RecieverID for Reciever: " + RecieverUsername);
        while(e.hasMoreElements()){
            CTE = (ClientsTableEntry)e.nextElement();
                System.out.print("TableEntry: " +CTE.GetUsername());
                System.out.print(" IP: " +CTE.GetClientIP());
                System.out.print(" Port: " +CTE.GetClientPort());
                if(RecieverUsername.equals((String)CTE.GetUsername())){
                  valid = true;
                  System.out.println(" -> Valid Reciever");
                  RecieverName = (String)CTE.GetUsername();
                  System.out.println("ReciverUsername has been set to: " + RecieverName);
                  break;
                }
                else{
                  valid = false;
                  System.out.println(" -> inValid Reciever");
                }
        }
      return valid;
}

public void UpdateClientState(String Username, InetAddress ClientIPAddress, int ClientPort, boolean ActiveState){

//Method to set a user as active or inactive in the HashTable

        ClientsTable.remove(Username);
    //    ClientsTableEntry NewEntry  = new ClientsTableEntry(Username, ClientIPAddress, ClientPort, ActiveState);
    //    ClientsTable.put(Username, NewEntry);

}

public void GetRecieverIPPort(String RecieverUsername){

//Gets a users IP and Port given a username

     Enumeration e = ClientsTable.elements();
        while(e.hasMoreElements()){
            CTE = (ClientsTableEntry)e.nextElement();
                if(RecieverUsername.equals((String)CTE.GetUsername())){
                RecieverIPAddress = CTE.GetClientIP();
                RecieverPort = CTE.GetClientPort();

                }
        }
}
}