GUIClient.java

// GUIClient.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.rmi.registry.*;
import java.util.*;
import java.util.List;

public class GUIClient extends JFrame {
    
    private String method;
    private JTextArea messageArea;
    private JTextField inputField;
    private JButton sendButton;
    private JButton getAllButton;
    private JTextArea logArea;
    
    // Connection objects
    private HelloInterface rmiStub;
    private Socket socket;
    private PrintWriter socketOut;
    private BufferedReader socketIn;
    private OutputStream wsOut;
    private InputStream wsIn;
    
    public GUIClient(String method) {
        this.method = method;
        
        setTitle(method + " Client");
        setSize(600, 500);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setLayout(new BorderLayout(10, 10));
        
        // Top panel - Connection info
        JPanel topPanel = new JPanel();
        topPanel.setBackground(new Color(70, 130, 180));
        JLabel titleLabel = new JLabel(method + " Client Connected");
        titleLabel.setFont(new Font("Arial", Font.BOLD, 16));
        titleLabel.setForeground(Color.WHITE);
        topPanel.add(titleLabel);
        add(topPanel, BorderLayout.NORTH);
        
        // Center panel - Messages
        JPanel centerPanel = new JPanel(new BorderLayout(5, 5));
        centerPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        
        JLabel msgLabel = new JLabel("Server Messages:");
        centerPanel.add(msgLabel, BorderLayout.NORTH);
        
        messageArea = new JTextArea();
        messageArea.setEditable(false);
        messageArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
        JScrollPane msgScroll = new JScrollPane(messageArea);
        centerPanel.add(msgScroll, BorderLayout.CENTER);
        
        add(centerPanel, BorderLayout.CENTER);
        
        // Bottom panel - Input
        JPanel bottomPanel = new JPanel(new BorderLayout(5, 5));
        bottomPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        
        JPanel inputPanel = new JPanel(new BorderLayout(5, 5));
        inputField = new JTextField();
        inputField.setFont(new Font("Arial", Font.PLAIN, 14));
        inputPanel.add(new JLabel("Message:"), BorderLayout.WEST);
        inputPanel.add(inputField, BorderLayout.CENTER);
        
        JPanel buttonPanel = new JPanel(new FlowLayout());
        sendButton = new JButton("Send");
        sendButton.setBackground(new Color(34, 139, 34));
        sendButton.setForeground(Color.WHITE);
        sendButton.addActionListener(e -> sendMessage());
        
        getAllButton = new JButton("Get All Messages");
        getAllButton.setBackground(new Color(70, 130, 180));
        getAllButton.setForeground(Color.WHITE);
        getAllButton.addActionListener(e -> getAllMessages());
        
        buttonPanel.add(sendButton);
        buttonPanel.add(getAllButton);
        
        bottomPanel.add(inputPanel, BorderLayout.NORTH);
        bottomPanel.add(buttonPanel, BorderLayout.CENTER);
        
        add(bottomPanel, BorderLayout.SOUTH);
        
        // Connect to server
        connectToServer();
        
        // Test initial methods
        testInitialMethods();
        
        setVisible(true);
    }
    
    private void connectToServer() {
        try {
            switch (method) {
                case "RMI":
                    Registry registry = LocateRegistry.getRegistry("localhost", 1099);
                    rmiStub = (HelloInterface) registry.lookup("HelloService");
                    break;
                    
                case "RPC":
                    socket = new Socket("localhost", 5000);
                    socketOut = new PrintWriter(socket.getOutputStream(), true);
                    socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    break;
                    
                case "WebSocket":
                    connectWebSocket();
                    break;
            }
            appendMessage("Connected to " + method + " server successfully!\n");
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this, 
                "Could not connect to server: " + e.getMessage(), 
                "Connection Error", 
                JOptionPane.ERROR_MESSAGE);
        }
    }
    
    private void connectWebSocket() throws Exception {
        socket = new Socket("localhost", 8080);
        wsOut = socket.getOutputStream();
        wsIn = socket.getInputStream();
        
        String key = Base64.getEncoder().encodeToString(
            ("client" + System.currentTimeMillis()).getBytes()
        );
        
        String handshake = "GET / HTTP/1.1\r\n" +
                         "Host: localhost:8080\r\n" +
                         "Upgrade: websocket\r\n" +
                         "Connection: Upgrade\r\n" +
                         "Sec-WebSocket-Key: " + key + "\r\n" +
                         "Sec-WebSocket-Version: 13\r\n\r\n";
        
        wsOut.write(handshake.getBytes());
        wsOut.flush();
        
        BufferedReader reader = new BufferedReader(new InputStreamReader(wsIn));
        String line;
        while (!(line = reader.readLine()).isEmpty()) {
            // Skip headers
        }
    }
    
    private void testInitialMethods() {
        try {
            String helloResponse = callRemote("HELLO", "Alice");
            appendMessage("Test 1 - " + helloResponse + "\n");
            
            String addResponse = callRemote("ADD", "5,3");
            appendMessage("Test 2 - 5 + 3 = " + addResponse + "\n\n");
            appendMessage("You can now send messages to the server!\n");
        } catch (Exception e) {
            appendMessage("Error testing methods: " + e.getMessage() + "\n");
        }
    }
    
    private void sendMessage() {
        String message = inputField.getText().trim();
        if (message.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Please enter a message!", "Empty Message", JOptionPane.WARNING_MESSAGE);
            return;
        }
        
        try {
            String response = callRemote("SEND", message);
            appendMessage("You: " + message + "\n");
            appendMessage("Server: " + response + "\n\n");
            inputField.setText("");
        } catch (Exception e) {
            appendMessage("Error sending message: " + e.getMessage() + "\n");
        }
    }
    
    private void getAllMessages() {
        try {
            String response = callRemote("GETALL", "");
            appendMessage("=== All Messages on Server ===\n");
            
            if (response.equals("No messages")) {
                appendMessage("No messages stored on server\n");
            } else {
                String[] messages = response.split(";;");
                for (int i = 0; i < messages.length; i++) {
                    appendMessage((i + 1) + ". " + messages[i] + "\n");
                }
            }
            appendMessage("\n");
        } catch (Exception e) {
            appendMessage("Error getting messages: " + e.getMessage() + "\n");
        }
    }
    
    private String callRemote(String methodName, String params) throws Exception {
        switch (method) {
            case "RMI":
                return callRMI(methodName, params);
            case "RPC":
                return callRPC(methodName, params);
            case "WebSocket":
                return callWebSocket(methodName, params);
            default:
                return "Unknown method";
        }
    }
    
    private String callRMI(String methodName, String params) throws Exception {
        switch (methodName) {
            case "HELLO":
                return rmiStub.sayHello(params);
            case "ADD":
                String[] nums = params.split(",");
                return String.valueOf(rmiStub.add(Integer.parseInt(nums[0]), Integer.parseInt(nums[1])));
            case "SEND":
                rmiStub.sendMessage(params);
                return "Message received";
            case "GETALL":
                List<String> msgs = rmiStub.getAllMessages();
                return msgs.isEmpty() ? "No messages" : String.join(";;", msgs);
            default:
                return "Unknown";
        }
    }
    
    private String callRPC(String methodName, String params) throws Exception {
        String request = params.isEmpty() ? methodName : methodName + "|" + params;
        socketOut.println(request);
        return socketIn.readLine();
    }
    
    private String callWebSocket(String methodName, String params) throws Exception {
        String request = params.isEmpty() ? methodName : methodName + "|" + params;
        sendWSMessage(request);
        return receiveWSMessage();
    }
    
    private void sendWSMessage(String message) throws IOException {
        byte[] data = message.getBytes();
        Random random = new Random();
        byte[] mask = new byte[4];
        random.nextBytes(mask);
        
        wsOut.write(0x81);
        wsOut.write(0x80 | data.length);
        wsOut.write(mask);
        
        for (int i = 0; i < data.length; i++) {
            wsOut.write(data[i] ^ mask[i % 4]);
        }
        wsOut.flush();
    }
    
    private String receiveWSMessage() throws IOException {
        int b = wsIn.read();
        if (b == -1) return null;
        
        b = wsIn.read();
        int length = b & 0x7F;
        
        byte[] data = new byte[length];
        wsIn.read(data);
        
        return new String(data);
    }
    
    private void appendMessage(String msg) {
        messageArea.append(msg);
        messageArea.setCaretPosition(messageArea.getDocument().getLength());
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new GUIClient("RMI"));
    }
}