/*
 * 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.maven.surefire.booter.spi;

import javax.annotation.Nonnull;

import java.io.ByteArrayInputStream;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
import org.apache.maven.surefire.api.booter.Command;
import org.apache.maven.surefire.api.booter.DumpErrorSingleton;
import org.apache.maven.surefire.api.booter.Shutdown;
import org.apache.maven.surefire.api.fork.ForkNodeArguments;
import org.apache.maven.surefire.booter.ForkedNodeArg;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;

import static java.nio.channels.Channels.newChannel;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.BYE_ACK;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.NOOP;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.RUN_CLASS;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.SHUTDOWN;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.SKIP_SINCE_NEXT_TEST;
import static org.apache.maven.surefire.api.booter.MasterProcessCommand.TEST_SET_FINISHED;
import static org.apache.maven.surefire.api.booter.Shutdown.DEFAULT;
import static org.apache.maven.surefire.api.booter.Shutdown.EXIT;
import static org.apache.maven.surefire.api.booter.Shutdown.KILL;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;

/**
 * Tests for {@link CommandChannelDecoder}.
 */
@SuppressWarnings("checkstyle:magicnumber")
public class CommandChannelDecoderTest {
    private static final Random RND = new Random();

    @Rule
    public final TemporaryFolder tempFolder = new TemporaryFolder();

    @Before
    public void initTmpFile() {
        File reportsDir = tempFolder.getRoot();
        String dumpFileName = "surefire-" + RND.nextLong();
        DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName);
    }

    @After
    public void deleteTmpFiles() {
        tempFolder.delete();
    }

    @Test
    public void testDecoderRunClass() throws IOException {
        assertEquals(String.class, RUN_CLASS.getDataType());
        byte[] encoded = new StringBuilder(512)
                .append(":maven-surefire-command:")
                .append((char) 13)
                .append(":run-testclass:")
                .append((char) 5)
                .append(":UTF-8:")
                .append((char) 0)
                .append((char) 0)
                .append((char) 0)
                .append((char) 8)
                .append(":")
                .append("pkg.Test")
                .append(":")
                .toString()
                .getBytes(UTF_8);
        InputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(RUN_CLASS);
        assertThat(command.getData()).isEqualTo("pkg.Test");
    }

    @Test
    public void testDecoderTestsetFinished() throws IOException {
        Command command = Command.TEST_SET_FINISHED;
        assertThat(command.getCommandType()).isSameAs(TEST_SET_FINISHED);
        assertEquals(Void.class, TEST_SET_FINISHED.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0010:testset-finished:".getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(TEST_SET_FINISHED);
        assertNull(command.getData());
    }

    @Test
    public void testDecoderSkipSinceNextTest() throws IOException {
        Command command = Command.SKIP_SINCE_NEXT_TEST;
        assertThat(command.getCommandType()).isSameAs(SKIP_SINCE_NEXT_TEST);
        assertEquals(Void.class, SKIP_SINCE_NEXT_TEST.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0014:skip-since-next-test:".getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(SKIP_SINCE_NEXT_TEST);
        assertNull(command.getData());
    }

    @Test
    public void testDecoderShutdownWithExit() throws IOException {
        Shutdown shutdownType = EXIT;
        assertEquals(String.class, SHUTDOWN.getDataType());
        byte[] encoded = (":maven-surefire-command:\u0008:shutdown:\u0005:UTF-8:\u0000\u0000\u0000\u0004:"
                        + shutdownType.getParam() + ":")
                .getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(SHUTDOWN);
        assertThat(command.getData()).isEqualTo(shutdownType.name());
    }

    @Test
    public void testDecoderShutdownWithKill() throws IOException {
        Shutdown shutdownType = KILL;
        assertEquals(String.class, SHUTDOWN.getDataType());
        byte[] encoded = (":maven-surefire-command:\u0008:shutdown:\u0005:UTF-8:\u0000\u0000\u0000\u0004:"
                        + shutdownType.getParam() + ":")
                .getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(SHUTDOWN);
        assertThat(command.getData()).isEqualTo(shutdownType.name());
    }

    @Test
    public void testDecoderShutdownWithDefault() throws IOException {
        Shutdown shutdownType = DEFAULT;
        assertEquals(String.class, SHUTDOWN.getDataType());
        byte[] encoded = (":maven-surefire-command:\u0008:shutdown:\u0005:UTF-8:\u0000\u0000\u0000\u0007:"
                        + shutdownType.getParam() + ":")
                .getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(SHUTDOWN);
        assertThat(command.getData()).isEqualTo(shutdownType.name());
    }

    @Test
    public void testDecoderNoop() throws IOException {
        assertThat(NOOP).isSameAs(Command.NOOP.getCommandType());
        assertEquals(Void.class, NOOP.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0004:noop:".getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(NOOP);
        assertNull(command.getData());
    }

    @Test
    public void shouldIgnoreDamagedStream() throws IOException {
        assertThat(BYE_ACK).isSameAs(Command.BYE_ACK.getCommandType());
        assertEquals(Void.class, BYE_ACK.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0007:bye-ack:".getBytes();
        byte[] streamContent = ("<something>" + new String(encoded) + "<damaged>").getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(streamContent);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(BYE_ACK);
        assertNull(command.getData());
    }

    @Test
    public void shouldIgnoreDamagedHeader() throws IOException {
        assertThat(BYE_ACK).isSameAs(Command.BYE_ACK.getCommandType());
        assertEquals(Void.class, BYE_ACK.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0007:bye-ack:".getBytes();
        byte[] streamContent = (":<damaged>:" + new String(encoded)).getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(streamContent);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(BYE_ACK);
        assertNull(command.getData());
    }

    @Test
    public void testDecoderByeAck() throws IOException {
        assertThat(BYE_ACK).isSameAs(Command.BYE_ACK.getCommandType());
        assertEquals(Void.class, BYE_ACK.getDataType());
        byte[] encoded = ":maven-surefire-command:\u0007:bye-ack:".getBytes();
        ByteArrayInputStream is = new ByteArrayInputStream(encoded);
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(BYE_ACK);
        assertNull(command.getData());
    }

    @Test
    public void shouldDecodeTwoCommands() throws IOException {
        String cmd = ":maven-surefire-command:\u0007:bye-ack:\r\n:maven-surefire-command:\u0007:bye-ack:";
        InputStream is = new ByteArrayInputStream(cmd.getBytes());
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);

        Command command = decoder.decode();
        assertThat(command.getCommandType()).isEqualTo(BYE_ACK);
        assertThat(command.getData()).isNull();

        command = decoder.decode();
        assertThat(command.getCommandType()).isEqualTo(BYE_ACK);
        assertThat(command.getData()).isNull();

        decoder.close();
    }

    @Test(expected = EOFException.class)
    public void testIncompleteCommand() throws IOException {

        ByteArrayInputStream is = new ByteArrayInputStream(":maven-surefire-command:".getBytes());
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        decoder.decode();
        fail();
    }

    @Test(expected = EOFException.class)
    public void testIncompleteCommandStart() throws IOException {

        ByteArrayInputStream is = new ByteArrayInputStream(new byte[] {':', '\r'});
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);
        decoder.decode();
        fail();
    }

    @Test(expected = EOFException.class)
    public void shouldNotDecodeCorruptedCommand() throws IOException {
        String cmd = ":maven-surefire-command:\u0007:bye-ack ::maven-surefire-command:";
        InputStream is = new ByteArrayInputStream(cmd.getBytes());
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);

        decoder.decode();
    }

    @Test
    public void shouldSkipCorruptedCommand() throws IOException {
        String cmd = ":maven-surefire-command:\0007:bye-ack\r\n::maven-surefire-command:\u0004:noop:";
        InputStream is = new ByteArrayInputStream(cmd.getBytes());
        ForkNodeArguments args = new ForkedNodeArg(1, false);
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(is), args);

        Command command = decoder.decode();
        assertThat(command.getCommandType()).isSameAs(NOOP);
        assertNull(command.getData());
    }

    @Test
    public void testBinaryCommandStream() throws Exception {
        InputStream commands = getClass().getResourceAsStream("/binary-commands/75171711-encoder.bin");
        assertThat(commands).isNotNull();
        ConsoleLoggerMock logger = new ConsoleLoggerMock(true, true, true, true);
        ForkNodeArguments args = new ForkNodeArgumentsMock(logger, new File(""));
        CommandChannelDecoder decoder = new CommandChannelDecoder(newChannel(commands), args);

        Command command = decoder.decode();
        assertThat(command).isNotNull();
        assertThat(command.getCommandType()).isEqualTo(NOOP);
        assertThat(command.getData()).isNull();

        command = decoder.decode();
        assertThat(command).isNotNull();
        assertThat(command.getCommandType()).isEqualTo(RUN_CLASS);
        assertThat(command.getData()).isEqualTo("pkg.ATest");

        for (int i = 0; i < 24; i++) {
            command = decoder.decode();
            assertThat(command).isNotNull();
            assertThat(command.getCommandType()).isEqualTo(NOOP);
            assertThat(command.getData()).isNull();
        }
    }

    /**
     * Threadsafe impl. Mockito and Powermock are not thread-safe.
     */
    private static class ForkNodeArgumentsMock implements ForkNodeArguments {
        private final ConcurrentLinkedQueue<String> dumpStreamText = new ConcurrentLinkedQueue<>();
        private final ConcurrentLinkedQueue<String> logWarningAtEnd = new ConcurrentLinkedQueue<>();
        private final ConsoleLogger logger;
        private final File dumpStreamTextFile;

        ForkNodeArgumentsMock(ConsoleLogger logger, File dumpStreamTextFile) {
            this.logger = logger;
            this.dumpStreamTextFile = dumpStreamTextFile;
        }

        @Nonnull
        @Override
        public String getSessionId() {
            throw new UnsupportedOperationException();
        }

        @Override
        public int getForkChannelId() {
            return 0;
        }

        @Nonnull
        @Override
        public File dumpStreamText(@Nonnull String text) {
            dumpStreamText.add(text);
            return dumpStreamTextFile;
        }

        @Nonnull
        @Override
        public File dumpStreamException(@Nonnull Throwable t) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void logWarningAtEnd(@Nonnull String text) {
            logWarningAtEnd.add(text);
        }

        @Nonnull
        @Override
        public ConsoleLogger getConsoleLogger() {
            return logger;
        }

        @Nonnull
        @Override
        public Object getConsoleLock() {
            return logger;
        }

        boolean isCalled() {
            return !dumpStreamText.isEmpty() || !logWarningAtEnd.isEmpty();
        }

        @Override
        public File getEventStreamBinaryFile() {
            return null;
        }

        @Override
        public File getCommandStreamBinaryFile() {
            return null;
        }
    }

    /**
     * Threadsafe impl. Mockito and Powermock are not thread-safe.
     */
    private static class ConsoleLoggerMock implements ConsoleLogger {
        final ConcurrentLinkedQueue<String> debug = new ConcurrentLinkedQueue<>();
        final ConcurrentLinkedQueue<String> info = new ConcurrentLinkedQueue<>();
        final ConcurrentLinkedQueue<String> error = new ConcurrentLinkedQueue<>();
        final boolean isDebug;
        final boolean isInfo;
        final boolean isWarning;
        final boolean isError;
        private volatile boolean called;
        private volatile boolean isDebugEnabledCalled;
        private volatile boolean isInfoEnabledCalled;

        ConsoleLoggerMock(boolean isDebug, boolean isInfo, boolean isWarning, boolean isError) {
            this.isDebug = isDebug;
            this.isInfo = isInfo;
            this.isWarning = isWarning;
            this.isError = isError;
        }

        @Override
        public synchronized boolean isDebugEnabled() {
            isDebugEnabledCalled = true;
            called = true;
            return isDebug;
        }

        @Override
        public synchronized void debug(String message) {
            debug.add(message);
            called = true;
        }

        @Override
        public synchronized boolean isInfoEnabled() {
            isInfoEnabledCalled = true;
            called = true;
            return isInfo;
        }

        @Override
        public synchronized void info(String message) {
            info.add(message);
            called = true;
        }

        @Override
        public synchronized boolean isWarnEnabled() {
            called = true;
            return isWarning;
        }

        @Override
        public synchronized void warning(String message) {
            called = true;
        }

        @Override
        public synchronized boolean isErrorEnabled() {
            called = true;
            return isError;
        }

        @Override
        public synchronized void error(String message) {
            error.add(message);
            called = true;
        }

        @Override
        public synchronized void error(String message, Throwable t) {
            called = true;
        }

        @Override
        public synchronized void error(Throwable t) {
            called = true;
        }

        synchronized boolean isCalled() {
            return called;
        }
    }
}
