/*

 * Copyright (c) 2015, 2018, 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.

 */

package jdk.internal.net.http;

import java.net.*;

import java.io.*;

import java.nio.channels.*;

import java.nio.ByteBuffer;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.atomic.AtomicInteger;

import java.net.http.HttpClient;

import java.net.http.HttpResponse;

import org.testng.annotations.Test;

import jdk.internal.net.http.websocket.RawChannel;

import static java.lang.System.out;

import static java.nio.charset.StandardCharsets.US_ASCII;

import static java.util.concurrent.TimeUnit.SECONDS;

import static java.net.http.HttpResponse.BodyHandlers.discarding;

/**

 * Whitebox test of selector mechanics. Currently only a simple test

 * setting one read and one write event is done. It checks that the

 * write event occurs first, followed by the read event and then no

 * further events occur despite the conditions actually still existing.

 */

@Test

public class SelectorTest {

    AtomicInteger counter = new AtomicInteger();

    volatile boolean error;

    static final CountDownLatch finishingGate = new CountDownLatch(1);

    static volatile HttpClient staticDefaultClient;

    static HttpClient defaultClient() {

        if (staticDefaultClient == null) {

            synchronized (SelectorTest.class) {

                staticDefaultClient = HttpClient.newHttpClient();

            }

        }

        return staticDefaultClient;

    }

    String readSomeBytes(RawChannel chan) {

        try {

            ByteBuffer buf = chan.read();

            if (buf == null) {

                out.println("chan read returned null");

                return null;

            }

            buf.flip();

            byte[] bb = new byte[buf.remaining()];

            buf.get(bb);

            return new String(bb, US_ASCII);

        } catch (IOException ioe) {

            throw new UncheckedIOException(ioe);

        }

    }

    @Test

    public void test() throws Exception {

        try (ServerSocket server = new ServerSocket()) {

            server.setReuseAddress(false);

            server.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));

            int port = server.getLocalPort();

            out.println("Listening on port " + server.getLocalPort());

            TestServer t = new TestServer(server);

            t.start();

            out.println("Started server thread");

            try (RawChannel chan = getARawChannel(port)) {

                chan.registerEvent(new RawChannel.RawEvent() {

                    @Override

                    public int interestOps() {

                        return SelectionKey.OP_READ;

                    }

                    @Override

                    public void handle() {

                        readSomeBytes(chan);

                        out.printf("OP_READ\n");

                        final int count = counter.get();

                        if (count != 1) {

                            out.printf("OP_READ error counter = %d\n", count);

                            error = true;

                        }

                    }

                });

                chan.registerEvent(new RawChannel.RawEvent() {

                    @Override

                    public int interestOps() {

                        return SelectionKey.OP_WRITE;

                    }

                    @Override

                    public void handle() {

                        out.printf("OP_WRITE\n");

                        final int count = counter.get();

                        if (count != 0) {

                            out.printf("OP_WRITE error counter = %d\n", count);

                            error = true;

                        } else {

                            ByteBuffer bb = ByteBuffer.wrap(TestServer.INPUT);

                            counter.incrementAndGet();

                            try {

                                chan.write(new ByteBuffer[]{bb}, 0, 1);

                            } catch (IOException e) {

                                throw new UncheckedIOException(e);

                            }

                        }

                    }

                });

                out.println("Events registered. Waiting");

                finishingGate.await(30, SECONDS);

                if (error)

                    throw new RuntimeException("Error");

                else

                    out.println("No error");

            }

        }

    }

    static RawChannel getARawChannel(int port) throws Exception {

        URI uri = URI.create("http://localhost:" + port + "/");

        out.println("client connecting to " + uri.toString());

        HttpRequestImpl req = new HttpRequestBuilderImpl(uri).buildForWebSocket();

        // Otherwise HttpClient will think this is an ordinary connection and

        // thus all ordinary procedures apply to it, e.g. it must be put into

        // the cache

        req.isWebSocket(true);

        HttpResponse<?> r = defaultClient().send(req, discarding());

        r.body();

        return ((HttpResponseImpl) r).rawChannel();

    }

    static class TestServer extends Thread {

        static final byte[] INPUT = "Hello world".getBytes(US_ASCII);

        static final byte[] OUTPUT = "Goodbye world".getBytes(US_ASCII);

        static final String FIRST_RESPONSE = "HTTP/1.1 200 OK\r\nContent-length: 0\r\n\r\n";

        final ServerSocket server;

        TestServer(ServerSocket server) throws IOException {

            this.server = server;

        }

        public void run() {

            try (Socket s = server.accept();

                 InputStream is = s.getInputStream();

                 OutputStream os = s.getOutputStream()) {

                out.println("Got connection");

                readRequest(is);

                os.write(FIRST_RESPONSE.getBytes());

                read(is);

                write(os);

                Thread.sleep(1000);

                // send some more data, and make sure WRITE op does not get called

                write(os);

                out.println("TestServer exiting");

                SelectorTest.finishingGate.countDown();

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        // consumes the HTTP request

        static void readRequest(InputStream is) throws IOException {

            out.println("starting readRequest");

            byte[] buf = new byte[1024];

            String s = "";

            while (true) {

                int n = is.read(buf);

                if (n <= 0)

                    throw new IOException("Error");

                s = s + new String(buf, 0, n);

                if (s.indexOf("\r\n\r\n") != -1)

                    break;

            }

            out.println("returning from readRequest");

        }

        static void read(InputStream is) throws IOException {

            out.println("starting read");

            for (int i = 0; i < INPUT.length; i++) {

                int c = is.read();

                if (c == -1)

                    throw new IOException("closed");

                if (INPUT[i] != (byte) c)

                    throw new IOException("Error. Expected:" + INPUT[i] + ", got:" + c);

            }

            out.println("returning from read");

        }

        static void write(OutputStream os) throws IOException {

            out.println("doing write");

            os.write(OUTPUT);

        }

    }

}