/*

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

 */

/*

 * @test

 * @build DummyWebSocketServer

 * @run testng/othervm

 *      -Djdk.internal.httpclient.websocket.debug=true

 *       AutomaticPong

 */

import org.testng.annotations.AfterTest;

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

import java.io.IOException;

import java.net.http.WebSocket;

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

import java.util.List;

import static java.net.http.HttpClient.newHttpClient;

import static org.testng.Assert.assertEquals;

import static org.testng.Assert.assertFalse;

import static org.testng.Assert.assertTrue;

import static org.testng.Assert.fail;

public class AutomaticPong {

    private DummyWebSocketServer server;

    private WebSocket webSocket;

    @AfterTest

    public void cleanup() {

        server.close();

        webSocket.abort();

    }

    /*

     * The sendClose method has been invoked and a Ping comes from the server.

     * Naturally, the client cannot reply with a Pong (the output has been

     * closed). However, this MUST not be treated as an error.

     * At this stage the server either has received or pretty soon will receive

     * the Close message sent by the sendClose. Thus, the server will know the

     * client cannot send further messages and it's up to the server to decide

     * how to react on the corresponding Pong not being received.

     */

    @Test

    public void sendCloseThenAutomaticPong() throws IOException {

        int[] bytes = {

                0x89, 0x00,                                     // ping

                0x89, 0x06, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x3f, // ping hello?

                0x88, 0x00,                                     // close

        };

        server = Support.serverWithCannedData(bytes);

        server.open();

        MockListener listener = new MockListener() {

            @Override

            protected void onOpen0(WebSocket webSocket) {

                /* request nothing */

            }

        };

        webSocket = newHttpClient()

                .newWebSocketBuilder()

                .buildAsync(server.getURI(), listener)

                .join();

        webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok").join();

        // now request all messages available

        webSocket.request(Long.MAX_VALUE);

        List<MockListener.Invocation> actual = listener.invocations();

        ByteBuffer hello = ByteBuffer.wrap("hello?".getBytes(StandardCharsets.UTF_8));

        ByteBuffer empty = ByteBuffer.allocate(0);

        List<MockListener.Invocation> expected = List.of(

                MockListener.Invocation.onOpen(webSocket),

                MockListener.Invocation.onPing(webSocket, empty),

                MockListener.Invocation.onPing(webSocket, hello),

                MockListener.Invocation.onClose(webSocket, 1005, "")

        );

        assertEquals(actual, expected);

    }

    /*

     * The server sends a number of contiguous Ping messages. The client replies

     * to these messages automatically. According to RFC 6455 a WebSocket client

     * is free to reply only to the most recent Pings.

     *

     * What is checked here is that:

     *

     *     a) the order of Pong replies corresponds to the Pings received,

     *     b) the last Pong corresponds to the last Ping

     *     c) there are no unrelated Pongs

     */

    @Test(dataProvider = "nPings")

    public void automaticPongs(int nPings) throws Exception {

        // big enough to not bother with resize

        ByteBuffer buffer = ByteBuffer.allocate(65536);

        Frame.HeaderWriter w = new Frame.HeaderWriter();

        for (int i = 0; i < nPings; i++) {

            w.fin(true)

             .opcode(Frame.Opcode.PING)

             .noMask()

             .payloadLen(4)    // the length of the number of the Ping (int)

             .write(buffer);

            buffer.putInt(i);  // the number of the Ping (int)

        }

        w.fin(true)

         .opcode(Frame.Opcode.CLOSE)

         .noMask()

         .payloadLen(2)

        .write(buffer);

        buffer.putChar((char) 1000);

        buffer.flip();

        server = Support.serverWithCannedData(buffer.array());

        server.open();

        MockListener listener = new MockListener();

        webSocket = newHttpClient()

                .newWebSocketBuilder()

                .buildAsync(server.getURI(), listener)

                .join();

        List<MockListener.Invocation> inv = listener.invocations();

        assertEquals(inv.size(), nPings + 2); // n * onPing + onOpen + onClose

        ByteBuffer data = server.read();

        Frame.Reader reader = new Frame.Reader();

        Frame.Consumer consumer = new Frame.Consumer() {

            ByteBuffer number = ByteBuffer.allocate(4);

            Frame.Masker masker = new Frame.Masker();

            int i = -1;

            boolean closed;

            @Override

            public void fin(boolean value) { assertTrue(value); }

            @Override

            public void rsv1(boolean value) { assertFalse(value); }

            @Override

            public void rsv2(boolean value) { assertFalse(value); }

            @Override

            public void rsv3(boolean value) { assertFalse(value); }

            @Override

            public void opcode(Frame.Opcode value) {

                if (value == Frame.Opcode.CLOSE) {

                    closed = true;

                    return;

                }

                assertEquals(value, Frame.Opcode.PONG);

            }

            @Override

            public void mask(boolean value) { assertTrue(value); }

            @Override

            public void payloadLen(long value) {

                if (!closed)

                    assertEquals(value, 4);

            }

            @Override

            public void maskingKey(int value) {

                masker.mask(value);

            }

            @Override

            public void payloadData(ByteBuffer src) {

                masker.transferMasking(src, number);

                if (closed) {

                    return;

                }

                number.flip();

                int n = number.getInt();

                System.out.printf("pong number=%s%n", n);

                number.clear();

                // a Pong with the number less than the maximum of Pongs already

                // received MUST never be received

                if (i >= n) {

                    fail(String.format("i=%s, n=%s", i, n));

                }

                i = n;

            }

            @Override

            public void endFrame() { }

        };

        while (data.hasRemaining()) {

            reader.readFrame(data, consumer);

        }

    }

    @DataProvider(name = "nPings")

    public Object[][] nPings() {

        return new Object[][]{{1}, {2}, {4}, {8}, {9}, {256}};

    }

}