# Copyright 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""This is a display lid close and open test using the Chameleon board."""

import logging, time

from autotest_lib.client.common_lib import error
from autotest_lib.client.cros.chameleon import chameleon_port_finder
from autotest_lib.client.cros.chameleon import chameleon_screen_test
from autotest_lib.server import test
from autotest_lib.server.cros.multimedia import remote_facade_factory

class display_LidCloseOpen(test.test):
    """External Display Lid Close/Open test. """
    version = 1

    # Time to check if device is suspended
    TIMEOUT_SUSPEND_CHECK = 5
    # Allowed timeout for the transition of suspend.
    TIMEOUT_SUSPEND_TRANSITION = 30
    # Allowed timeout for the transition of resume.
    TIMEOUT_RESUME_TRANSITION = 60
    # Time to allow for table video input
    WAIT_TIME_STABLE_VIDEO_INPUT = 10
    # Time to allow lid transition to take effect
    WAIT_TIME_LID_TRANSITION = 5
    # Time to allow display port plug transition to take effect
    WAIT_TIME_PLUG_TRANSITION = 5
    # Some boards do not play well with servo - crosbug.com/p/27591
    INCOMPATIBLE_SERVO_BOARDS = ['daisy', 'falco', 'auron_paine']


    def close_lid(self):
        """Close lid through servo"""
        logging.info('CLOSING LID...')
        self.host.servo.lid_close()
        time.sleep(self.WAIT_TIME_LID_TRANSITION)


    def open_lid(self):
        """Open lid through servo"""
        logging.info('OPENING LID...')
        self.host.servo.lid_open()
        time.sleep(self.WAIT_TIME_LID_TRANSITION)


    def check_primary_display_on_internal_screen(self):
        """Checks primary display is on onboard/internal screen"""
        if not self.display_facade.is_display_primary(internal=True):
            raise error.TestFail('Primary display is not on internal screen')


    def check_primary_display_on_external_screen(self):
        """Checks primary display is on external screen"""
        if not self.display_facade.is_display_primary(internal=False):
            raise error.TestFail('Primary display is not on external screen')


    def check_mode(self):
        """Checks the display mode is as expected"""
        if self.display_facade.is_mirrored_enabled() is not self.test_mirrored:
            raise error.TestFail('Display mode %s is not preserved!' %
                                 ('mirrored' if self.test_mirrored
                                     else 'extended'))


    def check_docked(self):
        """Checks DUT is docked"""
        # Device does not suspend
        if self.host.ping_wait_down(timeout=self.TIMEOUT_SUSPEND_TRANSITION):
            raise error.TestFail('Device suspends when docked!')
        # Verify Chameleon displays main screen
        self.check_primary_display_on_external_screen()
        logging.info('DUT IS DOCKED!')
        return self.chameleon_port.wait_video_input_stable(
            timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)


    def check_still_suspended(self):
        """Checks DUT is (still) suspended"""
        if not self.host.ping_wait_down(timeout=self.TIMEOUT_SUSPEND_CHECK):
            raise error.TestFail('Device does not stay suspended!')
        logging.info('DUT STILL SUSPENDED')


    def check_external_display(self):
        """Display status check"""
        # Check connector
        if self.screen_test.check_external_display_connected(
                self.connector_used, self.errors) is None:
            # Check mode is same as beginning of the test
            self.check_mode()
            # Check test image
            resolution = self.chameleon_port.get_resolution()
            self.screen_test.test_screen_with_image(
                    resolution, self.test_mirrored, self.errors)


    def run_once(self, host, plug_status, test_mirrored=False):

        # Check for chromebook type devices
        if not host.get_board_type() == 'CHROMEBOOK':
            raise error.TestNAError('DUT is not Chromebook. Test Skipped')

        # Check for incompatible with servo chromebooks
        board_name = host.get_board().split(':')[1]
        if board_name in self.INCOMPATIBLE_SERVO_BOARDS:
            raise error.TestNAError(
                    'DUT is incompatible with servo. Skipping test.')

        self.host = host
        self.test_mirrored = test_mirrored
        self.errors = list()

        # Check the servo object
        if self.host.servo is None:
            raise error.TestError('Invalid servo object found on the host.')

        factory = remote_facade_factory.RemoteFacadeFactory(host)
        display_facade = factory.create_display_facade()
        chameleon_board = host.chameleon

        chameleon_board.setup_and_reset(self.outputdir)
        finder = chameleon_port_finder.ChameleonVideoInputFinder(
                chameleon_board, display_facade)
        for chameleon_port in finder.iterate_all_ports():
            self.run_test_on_port(chameleon_port, display_facade, plug_status)


    def run_test_on_port(self, chameleon_port, display_facade, plug_status):
        """Run the test on the given Chameleon port.

        @param chameleon_port: a ChameleonPorts object.
        @param display_facade: a display facade object.
        @param plug_status: the plugged status before_close, after_close,
           and before_open
        """
        self.chameleon_port = chameleon_port
        self.display_facade = display_facade
        self.screen_test = chameleon_screen_test.ChameleonScreenTest(
                self.host, chameleon_port, display_facade, self.outputdir)

        # Get connector type used (HDMI,DP,...)
        self.connector_used = self.display_facade.get_external_connector_name()
        # Set main display mode for the test
        self.display_facade.set_mirrored(self.test_mirrored)

        for (plugged_before_close,
             plugged_after_close,
             plugged_before_open) in plug_status:
            logging.info('TEST CASE: %s > CLOSE_LID > %s > %s > OPEN_LID',
                'PLUG' if plugged_before_close else 'UNPLUG',
                'PLUG' if plugged_after_close else 'UNPLUG',
                'PLUG' if plugged_before_open else 'UNPLUG')

            is_suspended = False
            boot_id = self.host.get_boot_id()

            # Plug before close
            self.chameleon_port.set_plug(plugged_before_close)
            self.chameleon_port.wait_video_input_stable(
                    timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)

            # Close lid and check
            self.close_lid()
            if plugged_before_close:
                self.check_docked()
            else:
                self.host.test_wait_for_sleep(self.TIMEOUT_SUSPEND_TRANSITION)
                is_suspended = True

            # Plug after close and check
            if plugged_after_close is not plugged_before_close:
                self.chameleon_port.set_plug(plugged_after_close)
                self.chameleon_port.wait_video_input_stable(
                        timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
                if not plugged_before_close:
                    self.check_still_suspended()
                else:
                    self.host.test_wait_for_sleep(
                        self.TIMEOUT_SUSPEND_TRANSITION)
                    is_suspended = True

            # Plug before open and check
            if plugged_before_open is not plugged_after_close:
                self.chameleon_port.set_plug(plugged_before_open)
                self.chameleon_port.wait_video_input_stable(
                        timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)
                if not plugged_before_close or not plugged_after_close:
                    self.check_still_suspended()
                else:
                    self.host.test_wait_for_sleep(
                        self.TIMEOUT_SUSPEND_TRANSITION)
                    is_suspended = True

            # Open lid and check
            self.open_lid()
            if is_suspended:
                self.host.test_wait_for_resume(boot_id,
                                               self.TIMEOUT_RESUME_TRANSITION)
                is_suspended = False

            # Check internal screen switch to primary display
            self.check_primary_display_on_internal_screen()

            # Plug monitor if not plugged, such that we can test the screen.
            if not plugged_before_open:
                self.chameleon_port.set_plug(True)
                self.chameleon_port.wait_video_input_stable(
                        timeout=self.WAIT_TIME_STABLE_VIDEO_INPUT)

            # Check status
            self.check_external_display()

            if self.errors:
                raise error.TestFail('; '.join(set(self.errors)))

    def cleanup(self):
        """Test cleanup"""
        # Keep device in lid open sate.
        self.open_lid()