/*

 * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* @test

 * @summary Test chat server chatserver test

 *

 * @library ../../../src/share/sample/nio/chatserver

 * @build ChatTest ChatServer Client ClientReader DataReader MessageReader NameReader

 * @run main ChatTest

 */

import java.io.*;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.concurrent.CyclicBarrier;

public class ChatTest {

    public static int listeningPort = 0;

    public static void main(String[] args) throws Throwable {

        testStartStop();

        testPortOpen();

        testAsksForName();

        testUseName();

        testConnectDisconnectConnect();

        testUsernameAndMessage();

        testDontReceiveMessageInNameState();

    }

    private static ChatServer startServer() throws IOException {

        ChatServer server = new ChatServer(0);

        InetSocketAddress address = (InetSocketAddress) server.getSocketAddress();

        listeningPort = address.getPort();

        server.run();

        return server;

    }

    public static void testStartStop() throws Exception {

        ChatServer server = startServer();

        server.shutdown();

    }

    public static void testPortOpen() throws Exception {

        ChatServer server = startServer();

        try {

            Socket socket = new Socket("localhost", listeningPort);

            if (!socket.isConnected()) {

                throw new RuntimeException("Failed to connect to server: port not open");

            }

        } finally {

            server.shutdown();

        }

    }

    public static void testAsksForName() throws Exception {

        ChatServer server = startServer();

        try {

            Socket socket = new Socket("localhost", listeningPort);

            Reader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            String string = readAvailableString(reader);

            if (!string.equals("Name: ")) {

                throw new RuntimeException("Server doesn't send Name: ");

            }

        } finally {

            server.shutdown();

        }

    }

    public static void testUseName() throws Throwable {

        ChatServer server = startServer();

        try {

            performTestUseName();

        } finally {

            server.shutdown();

        }

    }

    public static void testConnectDisconnectConnect() throws Exception {

        ChatServer server = startServer();

        try {

            performTestConnectDisconnectConnect();

        } finally {

            server.shutdown();

        }

    }

    public static void testUsernameAndMessage() throws Exception {

        ChatServer server = startServer();

        try {

            performTestUsernameAndMessage();

        } finally {

            server.shutdown();

        }

    }

    public static void testDontReceiveMessageInNameState() throws Exception {

        ChatServer server = startServer();

        try {

            performDontReceiveMessageInNameState();

        } finally {

            server.shutdown();

        }

    }

    private static void assertEqual(List<Exception> exception, Object value, Object expected) {

        if (expected == value) {

            return;

        }

        if (expected == null) {

            exception.add(new RuntimeException("Expected null, but was: " + value));

            return;

        }

        if (!expected.equals(value)) {

            exception.add(new RuntimeException("Expected: " + expected + " but was: " + value));

            return;

        }

    }

    private static void performDontReceiveMessageInNameState() throws Exception {

        final CyclicBarrier barrier1 = new CyclicBarrier(2);

        final CyclicBarrier barrier2 = new CyclicBarrier(2);

        final CyclicBarrier barrier3 = new CyclicBarrier(2);

        final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

        ChatConnection chatConnection = new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "Name: ");

                writer.write("testClient1\n");

                waitForJoin(reader, "testClient1");

                barrier1.await();

                writer.write("Ignore this!\n");

                barrier2.await();

                barrier3.await();

            }

        };

        Thread client2 = new Thread(new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                barrier1.await();

                barrier2.await();

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "Name: ");

                string = readAvailableString(reader, true);

                assertEqual(exceptions, string, null);

                writer.write("testClient2\n");

                barrier3.await();

            }

        });

        client2.start();

        chatConnection.run();

        if (!exceptions.isEmpty()) {

            throw exceptions.get(0);

        }

    }

    private static void waitForJoin(BufferedReader reader, String s) throws IOException {

        String joined;

        do {

            joined = readAvailableString(reader);

        } while (!(joined != null && joined.contains("Welcome " + s)));

    }

    private static void performTestUsernameAndMessage() throws Exception {

        final CyclicBarrier barrier1 = new CyclicBarrier(2);

        final CyclicBarrier barrier2 = new CyclicBarrier(2);

        final CyclicBarrier barrier3 = new CyclicBarrier(2);

        final List<Exception> exceptions = Collections.synchronizedList(new ArrayList<Exception>());

        ChatConnection chatConnection = new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "Name: ");

                writer.write("testClient1\n");

                waitForJoin(reader, "testClient1");

                barrier1.await();

                barrier2.await();

                string = readAvailableString(reader);

                assertEqual(exceptions, string, "testClient2: Hello world!\n");

                barrier3.await();

            }

        };

        Thread client2 = new Thread(new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "Name: ");

                barrier1.await();

                writer.write("testClient2\nHello world!\n");

                barrier2.await();

                barrier3.await();

            }

        });

        client2.start();

        chatConnection.run();

        if (!exceptions.isEmpty()) {

            throw exceptions.get(0);

        }

    }

    private static void performTestConnectDisconnectConnect() throws Exception {

        final CyclicBarrier barrier1 = new CyclicBarrier(2);

        final CyclicBarrier barrier2 = new CyclicBarrier(2);

        final CyclicBarrier barrier3 = new CyclicBarrier(2);

        final List<Exception> exceptions = new ArrayList<Exception>();

        ChatConnection chatConnection = new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "Name: ");

                writer.write("testClient1\n");

            }

        };

        ChatConnection chatConnection2 = new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                readAvailableString(reader);

                writer.write("testClient1\n");

                waitForJoin(reader, "testClient1");

                barrier1.await();

                writer.write("Good morning!\n");

                barrier2.await();

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "testClient2: Hello world!\n");

                barrier3.await();

            }

        };

        Thread client2 = new Thread(new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                readAvailableString(reader);

                writer.write("testClient2\n");

                waitForJoin(reader, "testClient2");

                barrier1.await();

                writer.write("Hello world!\n");

                barrier2.await();

                String string = readAvailableString(reader);

                assertEqual(exceptions, string, "testClient1: Good morning!\n");

                barrier3.await();

            }

        });

        client2.start();

        chatConnection.run();

        chatConnection2.run();

        if (!exceptions.isEmpty()) {

            throw exceptions.get(0);

        }

    }

    private static void performTestUseName() throws Exception {

        final CyclicBarrier barrier1 = new CyclicBarrier(2);

        final CyclicBarrier barrier2 = new CyclicBarrier(2);

        final CyclicBarrier barrier3 = new CyclicBarrier(2);

        final List<Exception> exceptions = new ArrayList<Exception>();

        ChatConnection chatConnection = new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                if (!"Name: ".equals(string)) {

                    exceptions.add(new RuntimeException("Expected Name: "));

                }

                writer.write("testClient1\n");

                waitForJoin(reader, "testClient1");

                barrier1.await();

                barrier2.await();

                string = readAvailableString(reader);

                if (!"testClient2: Hello world!\n".equals(string)) {

                    exceptions.add(new RuntimeException("testClient2: Hello world!\n"));

                }

                barrier3.await();

            }

        };

        Thread client2 = new Thread(new ChatConnection() {

            @Override

            public void run(Socket socket, BufferedReader reader, Writer writer) throws Exception {

                String string = readAvailableString(reader);

                if (!"Name: ".equals(string)) {

                    exceptions.add(new RuntimeException("Expected Name: "));

                }

                writer.write("testClient2\n");

                waitForJoin(reader, "testClient2");

                barrier1.await();

                writer.write("Hello world!\n");

                barrier2.await();

                barrier3.await();

            }

        });

        client2.start();

        chatConnection.run();

        if (!exceptions.isEmpty()) {

            throw exceptions.get(0);

        }

    }

    private static String readAvailableString(Reader reader) throws IOException {

        return readAvailableString(reader, false);

    }

    private static String readAvailableString(Reader reader, boolean now) throws IOException {

        StringBuilder builder = new StringBuilder();

        int bytes;

        if (now && !reader.ready()) {

            return null;

        }

        do {

            char[] buf = new char[256];

            bytes = reader.read(buf);

            builder.append(buf, 0, bytes);

        } while (bytes == 256);

        return builder.toString();

    }

    private abstract static class ChatConnection implements Runnable {

        public Exception exception;

        @Override

        public void run() {

            try (Socket socket = new Socket("localhost", listeningPort);

            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            Writer writer = new FlushingWriter(new OutputStreamWriter(socket.getOutputStream()))) {

                socket.setTcpNoDelay(true);

                run(socket, reader, writer);

            } catch (Exception e) {

                exception = e;

            }

        }

        public abstract void run(Socket socket, BufferedReader reader, Writer writer) throws Exception;

    }

    private static class FlushingWriter extends Writer {

        public final Writer delegate;

        private FlushingWriter(Writer delegate) {

            this.delegate = delegate;

        }

        @Override

        public void write(char[] cbuf, int off, int len) throws IOException {

            delegate.write(cbuf, off, len);

        }

        @Override

        public void flush() throws IOException {

            delegate.flush();

        }

        @Override

        public void close() throws IOException {

            delegate.close();

        }

        @Override

        public void write(String str) throws IOException {

            super.write(str);

            flush();

        }

    }

}