/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed 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 android.hdmicec.cts;

import android.hdmicec.cts.error.CecClientWrapperException;
import android.hdmicec.cts.error.ErrorCodes;

import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.device.ITestDevice;
import com.android.tradefed.log.LogUtil.CLog;
import com.android.tradefed.util.RunUtil;

import org.junit.rules.ExternalResource;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

/** Class that helps communicate with the cec-client */
public final class HdmiCecClientWrapper extends ExternalResource {

    private static final int MILLISECONDS_TO_READY = 10000;
    private static final int DEFAULT_TIMEOUT = 20000;
    private static final int BUFFER_SIZE = 1024;

    private Process mCecClient;
    private BufferedWriter mOutputConsole;
    private BufferedReader mInputConsole;
    private boolean mCecClientInitialised = false;

    private LogicalAddress selfDevice = LogicalAddress.RECORDER_1;
    private LogicalAddress targetDevice = LogicalAddress.UNKNOWN;
    private String clientParams[];
    private StringBuilder sendVendorCommand = new StringBuilder("cmd hdmi_control vendorcommand ");
    private int physicalAddress = 0xFFFF;

    private CecOperand featureAbortOperand = CecOperand.FEATURE_ABORT;
    private List<Integer> featureAbortReasons =
            new ArrayList<>(HdmiCecConstants.ABORT_INVALID_OPERAND);
    private boolean isFeatureAbortExpected = false;

    private static final String CEC_PORT_BUSY = "unable to open the device on port";

    public HdmiCecClientWrapper(String ...clientParams) {
        this.clientParams = clientParams;
    }

    @Override
    protected void after() {
        this.killCecProcess();
    }

    void setTargetLogicalAddress(LogicalAddress dutLogicalAddress) {
        targetDevice = dutLogicalAddress;
    }

    public List<String> getValidCecClientPorts() throws CecClientWrapperException {

        List<String> listPortsCommand = new ArrayList();
        Process cecClient;

        listPortsCommand.add("cec-client");
        listPortsCommand.add("-l");

        List<String> comPorts = new ArrayList();
        try {
            cecClient = RunUtil.getDefault().runCmdInBackground(listPortsCommand);
        } catch (IOException ioe) {
            throw new CecClientWrapperException(
                    ErrorCodes.CecClientStart,
                    "as cec-client may not be installed. Please refer to README for"
                        + " setup/installation instructions.");
        }
        try {
            BufferedReader inputConsole =
                    new BufferedReader(new InputStreamReader(cecClient.getInputStream()));
            while (cecClient.isAlive()) {
                if (inputConsole.ready()) {
                    String line = inputConsole.readLine();
                    if (line.toLowerCase().contains("com port")) {
                        String port = line.split(":")[1].trim();
                        comPorts.add(port);
                    }
                }
            }
            inputConsole.close();
            cecClient.waitFor();
        } catch (IOException | InterruptedException ioe) {
            throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
        }

        return comPorts;
    }

    boolean initValidCecClient(ITestDevice device, List<String> clientCommands)
            throws CecClientWrapperException {

        String serialNo;
        List<String> launchCommand = new ArrayList(clientCommands);
        try {
            serialNo = device.getProperty("ro.serialno");
        } catch (DeviceNotAvailableException de) {
            throw new CecClientWrapperException(ErrorCodes.DeviceNotAvailable, de);
        }
        File mDeviceEntry = new File(HdmiCecConstants.CEC_MAP_FOLDER, serialNo);

        try (BufferedReader reader = new BufferedReader(new FileReader(mDeviceEntry))) {
            String port = reader.readLine();
            launchCommand.add(port);
            mCecClient = RunUtil.getDefault().runCmdInBackground(launchCommand);
            mInputConsole = new BufferedReader(new InputStreamReader(mCecClient.getInputStream()));

            /* Wait for the client to become ready */
            if (checkConsoleOutput(
                    CecClientMessage.CLIENT_CONSOLE_READY + "", MILLISECONDS_TO_READY)) {
                        mOutputConsole =
                                new BufferedWriter(
                                        new OutputStreamWriter(mCecClient.getOutputStream()),
                                        BUFFER_SIZE);
                        return true;
            } else {
                CLog.e("Console did not get ready!");
                /* Kill the unwanted cec-client process. */
                Process killProcess = mCecClient.destroyForcibly();
                killProcess.waitFor();
            }
        } catch (IOException | InterruptedException ioe) {
            throw new CecClientWrapperException(
                    ErrorCodes.ReadConsole, ioe, "Could not open port mapping file");
        }
        return false;
    }

    /** Initialise the client */
    void init(boolean startAsTv, ITestDevice device) throws CecClientWrapperException {
        if (targetDevice == LogicalAddress.UNKNOWN) {
            throw new CecClientWrapperException(
                    ErrorCodes.CecClientStart, "Missing logical address of the target device.");
        }

        List<String> commands = new ArrayList();

        commands.add("cec-client");

        /* "-p 2" starts the client as if it is connected to HDMI port 2, taking the physical
         * address 2.0.0.0 */
        commands.add("-p");
        commands.add("2");
        physicalAddress = 0x2000;
        if (startAsTv) {
            commands.add("-t");
            commands.add("x");
            selfDevice = LogicalAddress.TV;
        }
        /* "-d 15" set the log level to ERROR|WARNING|NOTICE|TRAFFIC */
        commands.add("-d");
        commands.add("15");
        commands.addAll(Arrays.asList(clientParams));
        if (Arrays.asList(clientParams).contains("a")) {
            selfDevice = LogicalAddress.AUDIO_SYSTEM;
        }

        mCecClientInitialised = true;
        if (!initValidCecClient(device, commands)) {
            mCecClientInitialised = false;

            throw new CecClientWrapperException(ErrorCodes.CecClientStart);
        }
    }

    private void checkCecClient() throws CecClientWrapperException {
        if (!mCecClientInitialised) {
            throw new CecClientWrapperException(ErrorCodes.CecClientStart);
        }
        if (!mCecClient.isAlive()) {
            throw new CecClientWrapperException(ErrorCodes.CecClientNotRunning);
        }
    }

    /**
     * Sends a CEC message with source marked as broadcast to the device passed in the constructor
     * through the output console of the cec-communication channel.
     */
    public void sendCecMessage(CecOperand message) throws CecClientWrapperException {
        sendCecMessage(message, "");
    }

    /**
     * Sends a CEC message with source marked as broadcast to the device passed in the constructor
     * through the output console of the cec-communication channel.
     */
    public void sendCecMessage(CecOperand message, String params) throws CecClientWrapperException {
        sendCecMessage(LogicalAddress.BROADCAST, targetDevice, message, params);
    }

    /**
     * Sends a CEC message from source device to the device passed in the constructor through the
     * output console of the cec-communication channel.
     */
    public void sendCecMessage(LogicalAddress source, CecOperand message)
            throws CecClientWrapperException {
        sendCecMessage(source, targetDevice, message, "");
    }

    /**
     * Sends a CEC message from source device to the device passed in the constructor through the
     * output console of the cec-communication channel with the appended params.
     */
    public void sendCecMessage(LogicalAddress source, CecOperand message, String params)
            throws Exception {
        sendCecMessage(source, targetDevice, message, params);
    }

    /**
     * Sends a CEC message from source device to a destination device through the output console of
     * the cec-communication channel.
     */
    public void sendCecMessage(
            LogicalAddress source, LogicalAddress destination, CecOperand message)
            throws CecClientWrapperException {
        sendCecMessage(source, destination, message, "");
    }

    /**
     * Broadcasts a CEC ACTIVE_SOURCE message from client device source through the output console
     * of the cec-communication channel.
     */
    public void broadcastActiveSource(LogicalAddress source) throws CecClientWrapperException {
        int sourcePa = (source == selfDevice) ? physicalAddress : 0xFFFF;
        sendCecMessage(
                source,
                LogicalAddress.BROADCAST,
                CecOperand.ACTIVE_SOURCE,
                CecMessage.formatParams(sourcePa, HdmiCecConstants.PHYSICAL_ADDRESS_LENGTH));
    }

    /**
     * Broadcasts a CEC ACTIVE_SOURCE message with physicalAddressOfActiveDevice from client device
     * source through the output console of the cec-communication channel.
     */
    public void broadcastActiveSource(LogicalAddress source, int physicalAddressOfActiveDevice)
            throws CecClientWrapperException {
        sendCecMessage(
                source,
                LogicalAddress.BROADCAST,
                CecOperand.ACTIVE_SOURCE,
                CecMessage.formatParams(
                        physicalAddressOfActiveDevice, HdmiCecConstants.PHYSICAL_ADDRESS_LENGTH));
    }

    /**
     * Broadcasts a CEC REPORT_PHYSICAL_ADDRESS message from client device source through the output
     * console of the cec-communication channel.
     */
    public void broadcastReportPhysicalAddress(LogicalAddress source)
            throws CecClientWrapperException {
        String deviceType = CecMessage.formatParams(source.getDeviceType());
        int sourcePa = (source == selfDevice) ? physicalAddress : 0xFFFF;
        String physicalAddress =
                CecMessage.formatParams(sourcePa, HdmiCecConstants.PHYSICAL_ADDRESS_LENGTH);
        sendCecMessage(
                source,
                LogicalAddress.BROADCAST,
                CecOperand.REPORT_PHYSICAL_ADDRESS,
                physicalAddress + deviceType);
    }

    /**
     * Broadcasts a CEC REPORT_PHYSICAL_ADDRESS message with physicalAddressToReport from client
     * device source through the output console of the cec-communication channel.
     */
    public void broadcastReportPhysicalAddress(LogicalAddress source, int physicalAddressToReport)
            throws CecClientWrapperException {
        String deviceType = CecMessage.formatParams(source.getDeviceType());
        String physicalAddress =
                CecMessage.formatParams(
                        physicalAddressToReport, HdmiCecConstants.PHYSICAL_ADDRESS_LENGTH);
        sendCecMessage(
                source,
                LogicalAddress.BROADCAST,
                CecOperand.REPORT_PHYSICAL_ADDRESS,
                physicalAddress + deviceType);
    }

    /**
     * Sends a CEC message from source device to a destination device through the output console of
     * the cec-communication channel with the appended params.
     */
    public void sendCecMessage(
            LogicalAddress source, LogicalAddress destination, CecOperand message, String params)
            throws CecClientWrapperException {
        checkCecClient();
        String sendMessageString = "tx " + source + destination + ":" + message + params;
        try {
            CLog.v("Sending CEC message: " + sendMessageString);
            mOutputConsole.write(sendMessageString);
            mOutputConsole.newLine();
            mOutputConsole.flush();
        } catch (IOException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    public void sendMultipleUserControlPressAndRelease(
            LogicalAddress source, List<Integer> keycodes) throws CecClientWrapperException {
        try {
            for (int keycode : keycodes) {
                String key = String.format("%02x", keycode);
                mOutputConsole.write(
                        "tx "
                                + source
                                + targetDevice
                                + ":"
                                + CecOperand.USER_CONTROL_PRESSED
                                + ":"
                                + key);
                mOutputConsole.newLine();
                mOutputConsole.write(
                        "tx " + source + targetDevice + ":" + CecOperand.USER_CONTROL_RELEASED);
                mOutputConsole.newLine();
                mOutputConsole.flush();
                TimeUnit.MILLISECONDS.sleep(200);
            }
        } catch (InterruptedException | IOException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    /**
     * Sends a <USER_CONTROL_PRESSED> and <USER_CONTROL_RELEASED> from source to device through the
     * output console of the cec-communication channel with the mentioned keycode.
     */
    public void sendUserControlPressAndRelease(LogicalAddress source, int keycode, boolean holdKey)
            throws CecClientWrapperException {
        sendUserControlPressAndRelease(source, targetDevice, keycode, holdKey);
    }

    /**
     * Sends a <USER_CONTROL_PRESSED> and <USER_CONTROL_RELEASED> from source to destination
     * through the output console of the cec-communication channel with the mentioned keycode.
     */
    public void sendUserControlPressAndRelease(
            LogicalAddress source, LogicalAddress destination, int keycode, boolean holdKey)
            throws CecClientWrapperException {
        sendUserControlPress(source, destination, keycode, holdKey);
        try {
            /* Sleep less than 200ms between press and release */
            TimeUnit.MILLISECONDS.sleep(100);
            mOutputConsole.write(
                    "tx " + source + destination + ":" + CecOperand.USER_CONTROL_RELEASED);
            mOutputConsole.flush();
        } catch (IOException | InterruptedException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    /**
     * Sends a {@code <UCP>} with and additional param. This is used to check that the DUT ignores
     * additional params in an otherwise correct message.
     */
    public void sendUserControlPressAndReleaseWithAdditionalParams(
            LogicalAddress source, LogicalAddress destination, int keyCode, int additionalParam)
            throws CecClientWrapperException {
        String key = String.format("%02x", keyCode);
        String command =
                "tx "
                        + source
                        + destination
                        + ":"
                        + CecOperand.USER_CONTROL_PRESSED
                        + ":"
                        + key
                        + ":"
                        + additionalParam;

        try {
            mOutputConsole.write(command);
            mOutputConsole.newLine();
            mOutputConsole.write(
                    "tx " + source + destination + ":" + CecOperand.USER_CONTROL_RELEASED);
            mOutputConsole.newLine();
            mOutputConsole.flush();
        } catch (IOException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    /**
     * Sends a <UCP> message from source to destination through the output console of the
     * cec-communication channel with the mentioned keycode. If holdKey is true, the method will
     * send multiple <UCP> messages to simulate a long press. No <UCR> will be sent.
     */
    public void sendUserControlPress(
            LogicalAddress source, LogicalAddress destination, int keycode, boolean holdKey)
            throws CecClientWrapperException {
        String key = String.format("%02x", keycode);
        String command = "tx " + source + destination + ":" +
                CecOperand.USER_CONTROL_PRESSED + ":" + key;

        try {
            if (holdKey) {
                /* Repeat once every 450ms for at least 5 seconds. Send 11 times in loop every
                 * 450ms. The message is sent once after the loop as well.
                 * ((11 + 1) * 0.45 = 5.4s total) */
                int repeat = 11;
                for (int i = 0; i < repeat; i++) {
                    mOutputConsole.write(command);
                    mOutputConsole.newLine();
                    mOutputConsole.flush();
                    TimeUnit.MILLISECONDS.sleep(450);
                }
            }

            mOutputConsole.write(command);
            mOutputConsole.newLine();
            mOutputConsole.flush();
        } catch (IOException | InterruptedException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    /**
     * Sends a series of <UCP> [firstKeycode] from source to destination through the output console
     * of the cec-communication channel immediately followed by <UCP> [secondKeycode]. No <UCR>
     * message is sent.
     */
    public void sendUserControlInterruptedPressAndHold(
            LogicalAddress source,
            LogicalAddress destination,
            int firstKeycode,
            int secondKeycode,
            boolean holdKey)
            throws CecClientWrapperException {
        sendUserControlPress(source, destination, firstKeycode, holdKey);
        try {
            /* Sleep less than 200ms between press and release */
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException ie) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ie);
        }
        sendUserControlPress(source, destination, secondKeycode, false);
    }

    /** Sends a poll message to the device */
    public void sendPoll() throws Exception {
        sendPoll(targetDevice);
    }

    /** Sends a poll message to the destination */
    public void sendPoll(LogicalAddress destination) throws Exception {
        String command = CecClientMessage.POLL + " " + destination;
        sendConsoleMessage(command);
    }


    /** Sends a message to the output console of the cec-client */
    public void sendConsoleMessage(String message) throws CecClientWrapperException {
        sendConsoleMessage(message, mOutputConsole);
    }

    /** Sends a message to the output console of the cec-client */
    public void sendConsoleMessage(String message, BufferedWriter outputConsole)
            throws CecClientWrapperException {
        CLog.v("Sending console message:: " + message);
        try {
            outputConsole.write(message);
            outputConsole.flush();
        } catch (IOException ioe) {
            throw new CecClientWrapperException(ErrorCodes.WriteConsole, ioe);
        }
    }

    /** Check for any string on the input console of the cec-client, uses default timeout */
    public boolean checkConsoleOutput(String expectedMessage) throws CecClientWrapperException {
        return checkConsoleOutput(expectedMessage, DEFAULT_TIMEOUT);
    }

    /** Check for any string on the input console of the cec-client */
    public boolean checkConsoleOutput(String expectedMessage, long timeoutMillis)
            throws CecClientWrapperException {
        checkCecClient();
        return checkConsoleOutput(expectedMessage, timeoutMillis, mInputConsole);
    }

    /** Check for any string on the specified input console */
    public boolean checkConsoleOutput(
            String expectedMessage, long timeoutMillis, BufferedReader inputConsole)
            throws CecClientWrapperException {
        long startTime = System.currentTimeMillis();
        long endTime = startTime;

        while ((endTime - startTime <= timeoutMillis)) {
            try {
                if (inputConsole.ready()) {
                    String line = inputConsole.readLine();
                    if (line != null
                            && line.toLowerCase().contains(expectedMessage.toLowerCase())) {
                        CLog.v("Found " + expectedMessage + " in " + line);
                        return true;
                    } else if (line.toLowerCase().contains(CEC_PORT_BUSY.toLowerCase())) {
                        throw new CecClientWrapperException(ErrorCodes.CecPortBusy);
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
        return false;
    }

    /** Gets all the messages received from the given list of source devices during a period of
     * duration seconds.
     */
    public List<CecOperand> getAllMessages(List<LogicalAddress> sourceList, int duration)
            throws CecClientWrapperException {
        List<CecOperand> receivedOperands = new ArrayList<>();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;

        String source = sourceList.toString().replace(",", "").replace(" ", "");

        Pattern pattern = Pattern.compile("(.*>>)(.*?)" +
                "(" + source + "\\p{XDigit}):(.*)",
            Pattern.CASE_INSENSITIVE);

        while ((endTime - startTime <= (duration * 1000))) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        CecOperand operand = CecMessage.getOperand(line);
                        if (!receivedOperands.contains(operand)) {
                            receivedOperands.add(operand);
                        }
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
        return receivedOperands;
    }

    /**
     * Gets the list of logical addresses which receives messages with operand expectedMessage
     * during a period of duration seconds.
     */
    public List<LogicalAddress> getAllDestLogicalAddresses(CecOperand expectedMessage, int duration)
            throws CecClientWrapperException {
        return getAllDestLogicalAddresses(expectedMessage, "", duration);
    }

    /**
     * Gets the list of logical addresses which receives messages with operand expectedMessage and
     * params during a period of duration seconds.
     */
    public List<LogicalAddress> getAllDestLogicalAddresses(
            CecOperand expectedMessage, String params, int duration)
            throws CecClientWrapperException {
        List<LogicalAddress> destinationAddresses = new ArrayList<>();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;
        Pattern pattern =
                Pattern.compile(
                        "(.*>>)(.*?)" + ":(" + expectedMessage + params + ")(.*)",
                        Pattern.CASE_INSENSITIVE);

        while ((endTime - startTime <= (duration * 1000))) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        LogicalAddress destination = CecMessage.getDestination(line);
                        if (!destinationAddresses.contains(destination)) {
                            destinationAddresses.add(destination);
                        }
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
        return destinationAddresses;
    }

    /**
     * The next checkExpectedOutput calls will also permit a feature abort as an alternate to the
     * expected operand. The feature abort will be permissible if it has
     *
     * @param abortForOperand The operand for which the feature abort could be an allowed response
     * @param reasons List of allowed reasons that the feature abort message could have
     */
    private void setExpectFeatureAbortFor(CecOperand abortOperand, Integer... abortReasons) {
        isFeatureAbortExpected = true;
        featureAbortOperand = abortOperand;
        featureAbortReasons = Arrays.asList(abortReasons);
    }

    /** Removes feature abort as a permissible alternate response for {@link checkExpectedOutput} */
    private void unsetExpectFeatureAbort() {
        isFeatureAbortExpected = false;
        CecOperand featureAbortOperand = CecOperand.FEATURE_ABORT;
        List<Integer> featureAbortReasons = new ArrayList<>(HdmiCecConstants.ABORT_INVALID_OPERAND);
    }

    /**
     * Looks for the CEC expectedMessage broadcast on the cec-client communication channel and
     * returns the first line that contains that message within default timeout. If the CEC message
     * is not found within the timeout, an CecClientWrapperException is thrown.
     */
    public String checkExpectedOutput(CecOperand expectedMessage) throws CecClientWrapperException {
        return checkExpectedOutput(
                targetDevice, LogicalAddress.BROADCAST, expectedMessage, DEFAULT_TIMEOUT, false);
    }

    /**
     * Looks for the CEC expectedMessage sent to CEC device toDevice on the cec-client communication
     * channel and returns the first line that contains that message within default timeout. If the
     * CEC message is not found within the timeout, an CecClientWrapperException is thrown.
     */
    public String checkExpectedOutput(LogicalAddress toDevice, CecOperand expectedMessage)
            throws CecClientWrapperException {
        return checkExpectedOutput(targetDevice, toDevice, expectedMessage, DEFAULT_TIMEOUT, false);
    }

    /**
     * Looks for the broadcasted CEC expectedMessage sent from cec-client device fromDevice on the
     * cec-client communication channel and returns the first line that contains that message within
     * default timeout. If the CEC message is not found within the timeout, an
     * CecClientWrapperException is thrown.
     */
    public String checkExpectedMessageFromClient(
            LogicalAddress fromDevice, CecOperand expectedMessage)
            throws CecClientWrapperException {
        return checkExpectedMessageFromClient(
                fromDevice, LogicalAddress.BROADCAST, expectedMessage);
    }

    /**
     * Looks for the CEC expectedMessage sent from cec-client device fromDevice to CEC device
     * toDevice on the cec-client communication channel and returns the first line that contains
     * that message within default timeout. If the CEC message is not found within the timeout, an
     * CecClientWrapperException is thrown.
     */
    public String checkExpectedMessageFromClient(
            LogicalAddress fromDevice, LogicalAddress toDevice, CecOperand expectedMessage)
            throws CecClientWrapperException {
        return checkExpectedOutput(fromDevice, toDevice, expectedMessage, DEFAULT_TIMEOUT, true);
    }

    /**
     * Looks for the CEC expectedMessage or a {@code <Feature Abort>} for {@code
     * featureAbortOperand} with one of the abort reasons in {@code abortReason} is sent from
     * cec-client device fromDevice to the DUT on the cec-client communication channel and returns
     * the first line that contains that message within default timeout. If the CEC message is not
     * found within the timeout, a CecClientWrapperException is thrown.
     */
    public String checkExpectedOutputOrFeatureAbort(
            LogicalAddress fromDevice,
            CecOperand expectedMessage,
            CecOperand featureAbortOperand,
            Integer... featureAbortReasons)
            throws CecClientWrapperException {
        setExpectFeatureAbortFor(featureAbortOperand, featureAbortReasons);
        String message =
                checkExpectedOutput(
                        targetDevice, fromDevice, expectedMessage, DEFAULT_TIMEOUT, false);
        unsetExpectFeatureAbort();
        return message;
    }

    /**
     * Looks for the CEC expectedMessage broadcast on the cec-client communication channel and
     * returns the first line that contains that message within timeoutMillis. If the CEC message is
     * not found within the timeout, an CecClientWrapperException is thrown.
     */
    public String checkExpectedOutput(CecOperand expectedMessage, long timeoutMillis)
            throws CecClientWrapperException {
        return checkExpectedOutput(
                targetDevice, LogicalAddress.BROADCAST, expectedMessage, timeoutMillis, false);
    }

    /**
     * Looks for the CEC expectedMessage sent to CEC device toDevice on the cec-client communication
     * channel and returns the first line that contains that message within timeoutMillis. If the
     * CEC message is not found within the timeout, an CecClientWrapperException is thrown.
     */
    public String checkExpectedOutput(
            LogicalAddress toDevice, CecOperand expectedMessage, long timeoutMillis)
            throws CecClientWrapperException {
        return checkExpectedOutput(targetDevice, toDevice, expectedMessage, timeoutMillis, false);
    }

    /**
     * Looks for the CEC expectedMessage sent from CEC device fromDevice to CEC device toDevice on
     * the cec-client communication channel and returns the first line that contains that message
     * within timeoutMillis. If the CEC message is not found within the timeout, an
     * CecClientWrapperException is thrown. This method looks for the CEC messages coming from
     * Cec-client if fromCecClient is true.
     */
    public String checkExpectedOutput(
            LogicalAddress fromDevice,
            LogicalAddress toDevice,
            CecOperand expectedMessage,
            long timeoutMillis,
            boolean fromCecClient)
            throws CecClientWrapperException {
        checkCecClient();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;
        String direction = fromCecClient ? "<<" : ">>";
        Pattern pattern;
        if (expectedMessage == CecOperand.POLL) {
            pattern =
                    Pattern.compile(
                            "(.*"
                                    + direction
                                    + ")(.*?)"
                                    + "("
                                    + fromDevice
                                    + toDevice
                                    + ")(.*)",
                            Pattern.CASE_INSENSITIVE);
        } else {
            String expectedOperands = expectedMessage.toString();
            if (isFeatureAbortExpected) {
                expectedOperands += "|" + CecOperand.FEATURE_ABORT;
            }
            pattern =
                    Pattern.compile(
                            "(.*"
                                    + direction
                                    + ")(.*?)"
                                    + "("
                                    + fromDevice
                                    + toDevice
                                    + "):"
                                    + "("
                                    + expectedOperands
                                    + ")(.*)",
                            Pattern.CASE_INSENSITIVE);
        }
        while ((endTime - startTime <= timeoutMillis)) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        if (isFeatureAbortExpected
                                && CecMessage.getOperand(line) == CecOperand.FEATURE_ABORT) {
                            CecOperand featureAbortedFor =
                                    CecOperand.getOperand(CecMessage.getParams(line, 0, 2));
                            int reason = CecMessage.getParams(line, 2, 4);
                            if (featureAbortedFor == featureAbortOperand
                                    && featureAbortReasons.contains(reason)) {
                                return line;
                            } else {
                                continue;
                            }
                        }
                        CLog.v("Found " + expectedMessage.name() + " in " + line);
                        return line;
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
        throw new CecClientWrapperException(ErrorCodes.CecMessageNotFound, expectedMessage.name());
    }

    public void checkNoMessagesSentFromDevice(int timeoutMillis, List<CecOperand> excludeOperands)
            throws CecClientWrapperException {
        checkCecClient();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;
        Pattern pattern =
                Pattern.compile("(.*>>)(.*?)("
                                + targetDevice
                                + "\\p{XDigit}):(.*)",
                        Pattern.CASE_INSENSITIVE);
        while ((endTime - startTime <= timeoutMillis)) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        CecOperand operand = CecMessage.getOperand(line);
                        if(excludeOperands.contains(operand)){
                            continue;
                        }
                        CLog.v("Found unexpected message in " + line);
                        throw new CecClientWrapperException(
                                ErrorCodes.CecMessageFound,
                                CecMessage.getOperand(line)
                                        + " from "
                                        + targetDevice
                                        + " with params "
                                        + CecMessage.getParamsAsString(line));
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
    }

    public void checkNoMessagesSentFromDevice(int timeoutMillis)
            throws CecClientWrapperException {
        List<CecOperand> excludeOperands = new ArrayList<>();
        checkNoMessagesSentFromDevice(timeoutMillis, excludeOperands);
    }

    /**
     * Looks for the CEC message incorrectMessage sent to CEC device toDevice on the cec-client
     * communication channel and throws an CecClientWrapperException if it finds the line that
     * contains the message within the default timeout. If the CEC message is not found within the
     * timeout, function returns without error.
     */
    public void checkOutputDoesNotContainMessage(
            LogicalAddress toDevice, CecOperand incorrectMessage) throws CecClientWrapperException {
        checkOutputDoesNotContainMessage(toDevice, incorrectMessage, "", DEFAULT_TIMEOUT);
     }

    /**
     * Looks for the CEC message incorrectMessage along with the params sent to CEC device toDevice
     * on the cec-client communication channel and throws an CecClientWrapperException if it finds
     * the line that contains the message with its params within the default timeout. If the CEC
     * message is not found within the timeout, function returns without error.
     */
    public void checkOutputDoesNotContainMessage(
            LogicalAddress toDevice, CecOperand incorrectMessage, String params)
            throws CecClientWrapperException {
        checkOutputDoesNotContainMessage(toDevice, incorrectMessage, params, DEFAULT_TIMEOUT);
    }

    /**
     * Looks for the CEC message incorrectMessage sent to CEC device toDevice on the cec-client
     * communication channel and throws an CecClientWrapperException if it finds the line that
     * contains the message within timeoutMillis. If the CEC message is not found within the
     * timeout, function returns without error.
     */
    public void checkOutputDoesNotContainMessage(
            LogicalAddress toDevice, CecOperand incorrectMessage, long timeoutMillis)
            throws CecClientWrapperException {
        checkOutputDoesNotContainMessage(toDevice, incorrectMessage, "", timeoutMillis);
    }

    /**
     * Looks for the CEC message incorrectMessage along with the params sent to CEC device toDevice
     * on the cec-client communication channel and throws an CecClientWrapperException if it finds
     * the line that contains the message and params within timeoutMillis. If the CEC message is not
     * found within the timeout, function returns without error.
     */
    public void checkOutputDoesNotContainMessage(
            LogicalAddress toDevice, CecOperand incorrectMessage, String params, long timeoutMillis)
            throws CecClientWrapperException {
        checkCecClient();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;
        Pattern pattern =
                Pattern.compile(
                        "(.*>>)(.*?)"
                                + "("
                                + targetDevice
                                + toDevice
                                + "):"
                                + "("
                                + incorrectMessage
                                + params
                                + ")(.*)",
                        Pattern.CASE_INSENSITIVE);

        while ((endTime - startTime <= timeoutMillis)) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        CLog.v("Found " + incorrectMessage.name() + " in " + line);
                        throw new CecClientWrapperException(
                                ErrorCodes.CecMessageFound,
                                incorrectMessage.name()
                                        + " to "
                                        + toDevice
                                        + " with params "
                                        + CecMessage.getParamsAsString(line));
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
     }

    /**
     * Checks that one of the message from the {@code primaryMessages} is broadcasted from target
     * device before sending any of the messages from the {@code secondaryMessages} on the
     * cec-client communication channel within default time.
     *
     * @param primaryMessages   list of CEC messages out of which at least one is expected from the
     *                          target device.
     * @param secondaryMessages list of CEC messages that are not expected before primary messages
     *                          to be sent from the target device.
     * @return the first line that contains any of the primaryMessages.
     * If none of the {@code primaryMessages} are found or if any of the {@code secondaryMessages}
     * are found, exception is thrown.
     */
    public String checkMessagesInOrder(
            List<CecOperand> primaryMessages,
            List<String> secondaryMessages)
            throws CecClientWrapperException {
        return checkMessagesInOrder(LogicalAddress.BROADCAST, primaryMessages, secondaryMessages);
    }

    /**
     * Checks that one of the message from the {@code primaryMessages} is sent from target
     * device to destination before sending any of the messages from the {@code secondaryMessages}
     * on the cec-client communication channel within default time.
     *
     * @param destination       logical address of the destination device.
     * @param primaryMessages   list of CEC messages out of which at least one is expected from the
     *                          target device.
     * @param secondaryMessages list of CEC messages that are not expected before primary messages
     *                          to be sent from the target device.
     * @return the first line that contains any of the primaryMessages.
     * If none of the {@code primaryMessages} are found or if any of the {@code secondaryMessages}
     * are found, exception is thrown.
     */
    public String checkMessagesInOrder(
            LogicalAddress destination,
            List<CecOperand> primaryMessages,
            List<String> secondaryMessages)
            throws CecClientWrapperException {
        return checkMessagesInOrder(
                destination, primaryMessages, secondaryMessages, DEFAULT_TIMEOUT);
    }

    /**
     * Checks that one of the message from the {@code primaryMessages} is sent from target
     * device to destination before sending any of the messages from the {@code secondaryMessages}
     * on the cec-client communication channel within give time.
     *
     * @param destination       logical address of the destination device.
     * @param primaryMessages   list of CEC messages out of which at least one is expected from the
     *                          target device.
     * @param secondaryMessages list of CEC messages that are not expected before primary messages
     *                          to be sent from the target device.
     * @param timeoutMillis     timeout to monitor CEC messages from source device.
     * @return the first line that contains any of the primaryMessages.
     * If none of the {@code primaryMessages} are found or if any of the {@code secondaryMessages}
     * are found, exception is thrown.
     */
    public String checkMessagesInOrder(
            LogicalAddress destination,
            List<CecOperand> primaryMessages,
            List<String> secondaryMessages,
            long timeoutMillis)
            throws CecClientWrapperException {
        return checkMessagesInOrder(
                targetDevice, destination, primaryMessages, secondaryMessages, timeoutMillis);
    }

    /**
     * Checks that one of the message from the {@code primaryMessages} is sent from source device to
     * destination before sending any of the messages from the {@code secondaryMessages}
     * on the cec-client communication channel within give time.
     *
     * @param source            logical address of the source device.
     * @param destination       logical address of the destination device.
     * @param primaryMessages   list of CEC messages out of which at least one is expected from the
     *                          target device.
     * @param secondaryMessages list of CEC messages that are not expected before primary messages
     *                          to be sent from the target device.
     * @param timeoutMillis     timeout to monitor CEC messages from source device.
     * @return the first line that contains any of the primaryMessages.
     * If none of the {@code primaryMessages} are found or if any of the {@code secondaryMessages}
     * are found, exception is thrown.
     */
    public String checkMessagesInOrder(
            LogicalAddress source,
            LogicalAddress destination,
            List<CecOperand> primaryMessages,
            List<String> secondaryMessages,
            long timeoutMillis)
            throws CecClientWrapperException {
        checkCecClient();
        long startTime = System.currentTimeMillis();
        long endTime = startTime;
        Pattern pattern = Pattern.compile("(.*>>)(.*?)"
                        + "(" + source + destination + "):"
                        + "(.*)",
                Pattern.CASE_INSENSITIVE);

        while ((endTime - startTime <= timeoutMillis)) {
            try {
                if (mInputConsole.ready()) {
                    String line = mInputConsole.readLine();
                    if (pattern.matcher(line).matches()) {
                        CecOperand operand = CecMessage.getOperand(line);
                        String params = CecMessage.getParamsAsString(line);
                        // Check for secondary messages. If found, throw an exception.
                        for (String secondaryMessage : secondaryMessages) {
                            if (line.contains(secondaryMessage)) {
                                throw new CecClientWrapperException(ErrorCodes.CecMessageFound,
                                        operand.name() + " to " + destination + " with params "
                                                + CecMessage.getParamsAsString(line));
                            }
                        }
                        // Check for the primary messages.
                        if (primaryMessages.contains(operand)) {
                            CLog.v("Found " + operand.name() + " in " + line);
                            return line;
                        }
                    }
                }
            } catch (IOException ioe) {
                throw new CecClientWrapperException(ErrorCodes.ReadConsole, ioe);
            }
            endTime = System.currentTimeMillis();
        }
        throw new CecClientWrapperException(
                ErrorCodes.CecMessageNotFound, primaryMessages.toString());
    }

    /** Returns the device type that the cec-client has started as. */
    public LogicalAddress getSelfDevice() {
        return selfDevice;
    }

    /** Set the physical address of the cec-client instance */
    public void setPhysicalAddress(int newPhysicalAddress) throws CecClientWrapperException {
        String command =
                String.format(
                        "pa %02d %02d",
                        (newPhysicalAddress & 0xFF00) >> 8, newPhysicalAddress & 0xFF);
        sendConsoleMessage(command);
        physicalAddress = newPhysicalAddress;
    }

    /** Get the physical address of the cec-client instance, will return 0xFFFF if uninitialised */
    public int getPhysicalAddress() {
        return physicalAddress;
    }

    public void clearClientOutput() {
        mInputConsole = new BufferedReader(new InputStreamReader(mCecClient.getInputStream()));
    }

    /**
     * Kills the cec-client process that was created in init().
     */
    private void killCecProcess() {
        try {
            checkCecClient();
            sendConsoleMessage(CecClientMessage.QUIT_CLIENT.toString());
            mOutputConsole.close();
            mInputConsole.close();
            mCecClientInitialised = false;
            if (!mCecClient.waitFor(MILLISECONDS_TO_READY, TimeUnit.MILLISECONDS)) {
                /* Use a pkill cec-client if the cec-client process is not dead in spite of the
                 * quit above.
                 */
                List<String> commands = new ArrayList<>();
                Process killProcess;
                commands.add("pkill");
                commands.add("cec-client");
                killProcess = RunUtil.getDefault().runCmdInBackground(commands);
                killProcess.waitFor();
            }
        } catch (IOException | InterruptedException | CecClientWrapperException e) {
            /*
             * If cec-client is not running, do not throw a CecClientWrapperException, just return.
             */
            CLog.w(new CecClientWrapperException(ErrorCodes.CecClientStop, e));
        }
    }
}