# 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 end-to-end test using the Chameleon board."""

import logging, os, shutil, time

from autotest_lib.client.common_lib import error

from autotest_lib.server.cros.chameleon import chameleon_test


class display_EndToEnd(chameleon_test.ChameleonTest):
    """External Display end-toend test.

    This test talks to a Chameleon board and a DUT to set up, run, and verify
    DUT behavior response to reboot, login, docked mode, suspend and resume,
    switching mode, etc.
    """
    version = 1

    # Duration of suspend, in second.
    SUSPEND_DURATION = 15
    # Allowed timeout for the transition of suspend.
    SUSPEND_TIMEOUT = 7
    # Allowed timeout for the transition of resume.
    RESUME_TIMEOUT = 20
    #Default waiting time in sec
    WAIT_TIME = 5
    #Crash paths to check for crash meta data
    CRASH_PATHS = ['/var/spool/crash',
                   '/chronos/home/crash'
                   '/home/chronos/user/crash'
                  ]
    #EDID data files names for different ports
    EDID_FILE_NAMES = [('DELL_U3011T_HDMI.txt', 'ASUS_VE258_HDMI.txt'),
                       ('DELL_U3011T_DP.txt', 'ASUS_VE258_DP.txt')]
    NO_LID_BOARDS = ['stumpy', 'panther', 'zako', 'tricky', 'mccloud']

    def remove_crash_data(self):
        """delete crash meta files"""
        for crash_path in self.CRASH_PATHS:
            if os.path.isdir(crash_path):
                shutil.rmtree(crash_path)


    def is_crash_data_present(self):
        """Check for crash meta files"""
        for crash_path in self.CRASH_PATHS:
            if os.path.isdir(crash_path):
                logging.debug('CRASH detected!')
                return True
        return False


    def switch_display_mode(self):
        """Switch from extended to mirror and the opposite"""
        from_mode = 'MIRRORED' if self.test_mirrored else 'EXTENDED'
        self.test_mirrored = not self.test_mirrored
        to_mode = 'MIRRORED' if self.test_mirrored else 'EXTENDED'
        self.set_mirrored(self.test_mirrored)
        logging.debug('Switched from %s to %s mode', from_mode, to_mode)
        time.sleep(self.WAIT_TIME)
        self.reconnect_and_get_external_resolution()


    def reboot_device(self, plugged_before, plugged_after):
        """Reboot DUT

        @param plugged_before: a boolean, plugged status before reboot
        @param plugged_after: a boolean, plugged status after reboot

        """

        boot_id = self.host.get_boot_id()
        self.set_plug(plugged_before)
        self.reboot(wait=False)
        self.host.test_wait_for_shutdown()
        self.host.test_wait_for_boot(boot_id)
        self.set_plug(plugged_after)
        self.display_facade.connect()


    def suspend_resume(self, plugged_before_suspend,
                          plugged_after_suspend, plugged_after_resume):
        """Suspends and resumes the DUT with different connections status
        before suspend, after suspend, and after resume

        @param plugged_before_suspend: a boolean, plugged before suspend
        @param plugged_after_suspend: a boolean, plugged after suspend
        @param plugged_after_resume: a boolean, plugged after resume

        """
        boot_id = self.host.get_boot_id()
        #Plug before suspend
        self.set_plug(plugged_before_suspend)
        time.sleep(self.WAIT_TIME)
        logging.debug('Going to suspend, for %d seconds...',
                     self.SUSPEND_DURATION)
        time_before_suspend = time.time()
        self.display_facade.suspend_resume_bg(self.SUSPEND_DURATION)

        # Confirm DUT suspended.
        self.host.test_wait_for_sleep(self.SUSPEND_TIMEOUT)
        self.set_plug(plugged_after_suspend)

        current_time = time.time()
        sleep_time = (self.SUSPEND_DURATION -
                      (current_time - time_before_suspend))
        logging.debug('Wait for %.2f seconds...', sleep_time)
        time.sleep(sleep_time)

        self.host.test_wait_for_resume(boot_id, self.RESUME_TIMEOUT)
        logging.debug('Resumed ')

        self.set_plug(plugged_after_resume)


    def wait_to_suspend(self, suspend_timeout):
        """Wait for DUT to suspend.

        @param suspend_timeout: Time in seconds to wait for suspend

        @exception TestFail: If fail to suspend in time
        """
        if not self.host.ping_wait_down(timeout=suspend_timeout):
            raise error.TestFail('Failed to SUSPEND after %d seconds' %
                                 suspend_timeout)

        logging.debug('Dut is suspended.')

    def wait_to_resume(self, resume_timeout):
        """Wait for DUT to resume.

        @param resume_timeout: Time in seconds to wait for resuming

        @exception TestFail: if fail to resume in time
        """
        if not self.host.wait_up(timeout=resume_timeout):
            raise error.TestFail(
                'Failed to RESUME after %d seconds' %
                    resume_timeout)
        logging.debug('Dut is up.')


    def check_external_display(self):
        """Display status check"""
        self.test_name = '%s-%s-%s' % (self.connector_used,
            str(self.resolution),
            'mirror' if self.test_mirrored else 'extended')
        #Check connector
        self.check_external_display_connector(self.connector_used)
        #Check test image
        self.load_test_image_and_check(
            self.test_name, self.resolution,
            under_mirrored_mode=self.test_mirrored,
            error_list=self.errors)
        #Check for crashes.
        if self.is_crash_data_present():
            self.errors.append('Crash data is detected on DUT')
        self.raise_on_errors(self.errors)

    def get_edids_filepaths(self):
        """Gets the EDID data files for the connector type used"""
        if self.connector_used.startswith('HDMI'):
            first_edid,second_edid = self.EDID_FILE_NAMES[0]
        elif self.connector_used.startswith('DP'):
            first_edid,second_edid = self.EDID_FILE_NAMES[1]
        first_edid = os.path.join(self.bindir, 'test_data/edids', first_edid)
        second_edid = os.path.join(self.bindir, 'test_data/edids', second_edid)
        return (first_edid, second_edid)


    def reconnect_and_get_external_resolution(self):
        """Reconnect the display and get the external screen resolution."""
        self.reconnect_output()
        # Get the resolution for the edid applied
        self.resolution = self.display_facade.get_external_resolution()
        logging.debug('External display resolution: %s',
                str(self.resolution))


    def apply_edid_and_reconnect(self, edid_file, suspended=False):
        """Apply EDID from a file

        @param edid_file: file path to edid data
        @param suspended: a boolean, to not reconnect ouptut when suspended

        """
        self.apply_edid_file(edid_file)
        #reconnect for the new edid if not suspended
        if not suspended:
            self.reconnect_and_get_external_resolution()

    def dock_dut(self):
        """Close lid(assumes device is connected to chameleon)"""
        board = self.host.get_board().split(':')[1]
        logging.debug('Docking the DUT!')
        if board not in self.NO_LID_BOARDS:
            self.host.servo.lid_close()
            time.sleep(self.WAIT_TIME)
            return True
        else:
            logging.debug('DUT does not dock!')
            return False

    def undock_dut(self):
        """Open the lid"""
        self.host.servo.lid_open()
        time.sleep(self.WAIT_TIME)

    def run_once(self, host, test_mirrored=False):
        self.host = host
        self.test_mirrored = test_mirrored
        self.errors = []

        #Remove any crash data before test procedure
        if self.is_crash_data_present():
            self.remove_crash_data()

        self.connector_used = self.display_facade.get_external_connector_name()
        first_edid, second_edid = self.get_edids_filepaths()

        #Set first monitor/EDID and tracked resolution
        self.apply_edid_and_reconnect(first_edid)
        #Set main display mode for the test
        self.set_mirrored(self.test_mirrored)

        #Reboot the device as connected and login
        self.reboot_device(plugged_before=True, plugged_after=True)
        #Check status
        self.check_external_display()

        #Dock and undock (close lid and open lid)
        if self.dock_dut():
            self.undock_dut();

        #Switch mode
        self.switch_display_mode()
        #Switch mode back
        self.switch_display_mode()
        self.check_external_display()

        #Suspend and resume as currently plugged
        self.suspend_resume()

        #Unplug-Suspend-Plug-Resume
        self.suspend_resume(plugged_before_suspend=False,
                               plugged_after_suspend=True,
                               plugged_after_resume=True)
        #Check status
        self.check_external_display()

        #Switch mode
        self.switch_display_mode()
        #Switch mode back
        self.switch_display_mode()

        #Suspens-Unplug-Resume-Plug
        self.suspend_resume(plugged_before_suspend=True,
                               plugged_after_suspend=False,
                               plugged_after_resume=True)
        #Check status
        self.check_external_display()

        #Docked mode(close lid)
        if self.dock_dut():
            logging.debug('Unplug display')
            #Unplug, thus DUT should suspend
            self.set_plug(False)
            self.wait_to_suspend(self.SUSPEND_TIMEOUT)
            logging.debug('DUT is suspended')

        #Plug the second monitor while suspended
        self.apply_edid_and_reconnect(second_edid, suspended=True)
        #Plug back
        self.set_plug(True)

        #Resume(open lid), doesn't hurt if DUT is not docked
        self.undock_dut()
        self.wait_to_resume(self.RESUME_TIMEOUT)

        self.reconnect_and_get_external_resolution()
        #Check status
        self.check_external_display()

        #Switch mode
        self.switch_display_mode()
        #Switch mode back
        self.switch_display_mode()

        #Unplug and plug the original monitor
        self.set_plug(False)
        self.apply_edid_and_reconnect(first_edid)
        self.set_plug(True)
        self.check_external_display()