/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.websocket;

import java.util.ArrayList;
import java.util.List;

import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;
import javax.websocket.Extension;
import javax.websocket.Extension.Parameter;
import javax.websocket.MessageHandler;

import org.junit.Assert;
import org.junit.Test;

public class TestUtil {

    // Used to init SecureRandom prior to running tests
    public static void generateMask() {
        Util.generateMask();
    }

    @Test
    public void testGetMessageTypeSimple() {
        Assert.assertEquals(
                String.class, Util.getMessageType(new SimpleMessageHandler()));
    }


    @Test
    public void testGetMessageTypeSubclass() {
        Assert.assertEquals(String.class,
                Util.getMessageType(new SubSimpleMessageHandler()));
    }


    @Test
    public void testGetMessageTypeGenericSubclass() {
        Assert.assertEquals(String.class,
                Util.getMessageType(new GenericSubMessageHandler()));
    }


    @Test
    public void testGetMessageTypeGenericMultipleSubclass() {
        Assert.assertEquals(String.class,
                Util.getMessageType(new GenericMultipleSubSubMessageHandler()));
    }


    @Test
    public void testGetMessageTypeGenericMultipleSubclassSwap() {
        Assert.assertEquals(String.class,
                Util.getMessageType(new GenericMultipleSubSubSwapMessageHandler()));
    }


    @Test
    public void testGetEncoderTypeSimple() {
        Assert.assertEquals(
                String.class, Util.getEncoderType(SimpleEncoder.class));
    }


    @Test
    public void testGetEncoderTypeSubclass() {
        Assert.assertEquals(String.class,
                Util.getEncoderType(SubSimpleEncoder.class));
    }


    @Test
    public void testGetEncoderTypeGenericSubclass() {
        Assert.assertEquals(String.class,
                Util.getEncoderType(GenericSubEncoder.class));
    }


    @Test
    public void testGetEncoderTypeGenericMultipleSubclass() {
        Assert.assertEquals(String.class,
                Util.getEncoderType(GenericMultipleSubSubEncoder.class));
    }


    @Test
    public void testGetEncoderTypeGenericMultipleSubclassSwap() {
        Assert.assertEquals(String.class,
                Util.getEncoderType(GenericMultipleSubSubSwapEncoder.class));
    }


    @Test
    public void testGetEncoderTypeSimpleWithGenericType() {
        Assert.assertEquals(List.class,
                Util.getEncoderType(SimpleEncoderWithGenericType.class));
    }


    @Test
    public void testGenericArrayEncoderString() {
        Assert.assertEquals(String[].class,
                Util.getEncoderType(GenericArrayEncoderString.class));
    }


    @Test
    public void testGenericArraySubEncoderString() {
        Assert.assertEquals(String[][].class,
                Util.getEncoderType(GenericArraySubEncoderString.class));
    }


    private static class SimpleMessageHandler
            implements MessageHandler.Whole<String> {
        @Override
        public void onMessage(String message) {
            // NO-OP
        }
    }


    private static class SubSimpleMessageHandler extends SimpleMessageHandler {
    }


    private abstract static class GenericMessageHandler<T> implements MessageHandler.Whole<T> {
    }


    private static class GenericSubMessageHandler extends GenericMessageHandler<String> {
        @Override
        public void onMessage(String message) {
            // NO-OP
        }
    }


    private static interface Foo<T> {
        void doSomething(T thing);
    }


    private abstract static class GenericMultipleMessageHandler<A,B>
            implements MessageHandler.Whole<A>, Foo<B> {
    }


    private abstract static class GenericMultipleSubMessageHandler<X,Y>
            extends GenericMultipleMessageHandler<X,Y> {
    }


    private static class GenericMultipleSubSubMessageHandler
            extends GenericMultipleSubMessageHandler<String,Boolean> {

        @Override
        public void onMessage(String message) {
            // NO-OP
        }

        @Override
        public void doSomething(Boolean thing) {
            // NO-OP
        }
    }


    private abstract static class GenericMultipleSubSwapMessageHandler<Y,X>
            extends GenericMultipleMessageHandler<X,Y> {
    }


    private static class GenericMultipleSubSubSwapMessageHandler
            extends GenericMultipleSubSwapMessageHandler<Boolean,String> {

        @Override
        public void onMessage(String message) {
            // NO-OP
        }

        @Override
        public void doSomething(Boolean thing) {
            // NO-OP
        }
    }


    private static class SimpleEncoder implements Encoder.Text<String> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }

        @Override
        public String encode(String object) throws EncodeException {
            return null;
        }
    }


    private static class SubSimpleEncoder extends SimpleEncoder {
    }


    private abstract static class GenericEncoder<T> implements Encoder.Text<T> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }
    }


    private static class GenericSubEncoder extends GenericEncoder<String> {

        @Override
        public String encode(String object) throws EncodeException {
            return null;
        }

    }


    private abstract static class GenericMultipleEncoder<A,B>
            implements Encoder.Text<A>, Foo<B> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }
    }


    private abstract static class GenericMultipleSubEncoder<X,Y>
            extends GenericMultipleEncoder<X,Y> {
    }


    private static class GenericMultipleSubSubEncoder
            extends GenericMultipleSubEncoder<String,Boolean> {

        @Override
        public String encode(String object) throws EncodeException {
            return null;
        }

        @Override
        public void doSomething(Boolean thing) {
            // NO-OP
        }

    }


    private abstract static class GenericMultipleSubSwapEncoder<Y,X>
            extends GenericMultipleEncoder<X,Y> {
    }


    private static class GenericMultipleSubSubSwapEncoder
            extends GenericMultipleSubSwapEncoder<Boolean,String> {

        @Override
        public String encode(String object) throws EncodeException {
            return null;
        }

        @Override
        public void doSomething(Boolean thing) {
            // NO-OP
        }
    }


    private static class SimpleEncoderWithGenericType
            implements Encoder.Text<List<String>> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }

        @Override
        public String encode(List<String> object) throws EncodeException {
            return null;
        }
    }


    private abstract static class GenericArrayEncoder<T> implements Encoder.Text<T[]> {
    }


    private static class GenericArrayEncoderString extends GenericArrayEncoder<String> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }

        @Override
        public String encode(String[] object) throws EncodeException {
            return null;
        }
    }


    private abstract static class GenericArraySubEncoder<T> extends GenericArrayEncoder<T[]> {
    }


    private static class GenericArraySubEncoderString extends GenericArraySubEncoder<String> {

        @Override
        public void init(EndpointConfig endpointConfig) {
            // NO-OP
        }

        @Override
        public void destroy() {
            // NO-OP
        }

        @Override
        public String encode(String[][] object) throws EncodeException {
            return null;
        }
    }


    @Test
    public void testParseExtensionHeaderSimple01() {
        doTestParseExtensionHeaderSimple("ext;a=1;b=2");
    }

    @Test
    public void testParseExtensionHeaderSimple02() {
        doTestParseExtensionHeaderSimple("ext;a=\"1\";b=2");
    }

    @Test
    public void testParseExtensionHeaderSimple03() {
        doTestParseExtensionHeaderSimple("ext;a=1;b=\"2\"");
    }

    @Test
    public void testParseExtensionHeaderSimple04() {
        doTestParseExtensionHeaderSimple(" ext ; a = 1 ; b = 2 ");
    }

    private void doTestParseExtensionHeaderSimple(String header) {
        // Simple test
        List<Extension> result = new ArrayList<>();
        Util.parseExtensionHeader(result, header);

        Assert.assertEquals(1, result.size());

        Extension ext = result.get(0);
        Assert.assertEquals("ext", ext.getName());
        List<Parameter> params = ext.getParameters();
        Assert.assertEquals(2, params.size());
        Parameter paramA = params.get(0);
        Assert.assertEquals("a", paramA.getName());
        Assert.assertEquals("1", paramA.getValue());
        Parameter paramB = params.get(1);
        Assert.assertEquals("b", paramB.getName());
        Assert.assertEquals("2", paramB.getValue());
    }


    @Test
    public void testParseExtensionHeaderMultiple01() {
        doTestParseExtensionHeaderMultiple("ext;a=1;b=2,ext2;c;d=xyz,ext3");
    }

    @Test
    public void testParseExtensionHeaderMultiple02() {
        doTestParseExtensionHeaderMultiple(
                " ext ; a = 1 ; b = 2 , ext2 ; c ; d = xyz , ext3 ");
    }

    private void doTestParseExtensionHeaderMultiple(String header) {
        // Simple test
        List<Extension> result = new ArrayList<>();
        Util.parseExtensionHeader(result, header);

        Assert.assertEquals(3, result.size());

        Extension ext = result.get(0);
        Assert.assertEquals("ext", ext.getName());
        List<Parameter> params = ext.getParameters();
        Assert.assertEquals(2, params.size());
        Parameter paramA = params.get(0);
        Assert.assertEquals("a", paramA.getName());
        Assert.assertEquals("1", paramA.getValue());
        Parameter paramB = params.get(1);
        Assert.assertEquals("b", paramB.getName());
        Assert.assertEquals("2", paramB.getValue());

        Extension ext2 = result.get(1);
        Assert.assertEquals("ext2", ext2.getName());
        List<Parameter> params2 = ext2.getParameters();
        Assert.assertEquals(2, params2.size());
        Parameter paramC = params2.get(0);
        Assert.assertEquals("c", paramC.getName());
        Assert.assertNull(paramC.getValue());
        Parameter paramD = params2.get(1);
        Assert.assertEquals("d", paramD.getName());
        Assert.assertEquals("xyz", paramD.getValue());

        Extension ext3 = result.get(2);
        Assert.assertEquals("ext3", ext3.getName());
        List<Parameter> params3 = ext3.getParameters();
        Assert.assertEquals(0, params3.size());
    }

    @Test(expected=IllegalArgumentException.class)
    public void testParseExtensionHeaderInvalid01() {
        Util.parseExtensionHeader(new ArrayList<Extension>(), "ext;a=\"1;b=2");
    }

    @Test(expected=IllegalArgumentException.class)
    public void testParseExtensionHeaderInvalid02() {
        Util.parseExtensionHeader(new ArrayList<Extension>(), "ext;a=1\";b=2");
    }
}