# Copyright (c) 2011 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.

''' A module for extracting trackpad device file properties '''

import glob
import logging
import os
import re

import trackpad_util

from autotest_lib.client.bin import utils
from autotest_lib.client.bin.input.linux_input import *
from autotest_lib.client.common_lib import error
from trackpad_util import read_trackpad_test_conf, get_trackpad_device_file


class TrackpadDevice:
    ''' Management of the trackpad device file

    It is used
    (1) to extract trackpad device file properties such as device event
        playback times, and
    (2) to play back the device packets. The device file is usually
        '/dev/input/event*'.
    '''
    PLAYBACK_PROGRAM = 'evemu-play'
    DEVICE_TIME_FILE = '/tmp/time.out'

    def __init__(self, conf_path):
        self._set_dev_type_and_code()
        if self._get_trackpad_driver() == 'synaptics':
            self._ungrab_device()
        self.trackpad_device_file, msg = get_trackpad_device_file()
        if self.trackpad_device_file is None:
            raise error.TestError(msg)
        logging.info(msg)

    def _finger_i_on_MTB(self, i):
        ''' The i-th finger touches the trackpad in MTB protocol '''
        return '%s %s %d'  % (self.EV_ABS, self.ABS_MT_SLOT, i - 1)

    def _set_dev_type_and_code(self):
        ''' Set device code

        Device event types and codes are imported from linux_input.
        '''
        ev_format = '%04x'
        ev_code_x = ev_format % ABS_MT_POSITION_X
        ev_code_y = ev_format % ABS_MT_POSITION_Y
        self.ev_code_dict = {'left':  (ev_code_x,),
                             'right': (ev_code_x,),
                             'up':    (ev_code_y,),
                             'down':  (ev_code_y,),
                             None:    (ev_code_x, ev_code_y)}
        # Event types
        self.EV_KEY = ev_format % EV_KEY
        self.EV_ABS = ev_format % EV_ABS

        # Event codes
        self.ABS_MT_SLOT = ev_format % ABS_MT_SLOT
        self.ABS_MT_TRACKING_ID = ev_format % ABS_MT_TRACKING_ID
        self.BTN_TOOL_FINGER = ev_format % BTN_TOOL_FINGER
        self.BTN_TOOL_DOUBLETAP = ev_format % BTN_TOOL_DOUBLETAP
        self.BTN_TOOL_TRIPLETAP = ev_format % BTN_TOOL_TRIPLETAP

        # MTA: not supported at this time

        # MTB: the default MT type to use
        self.second_finger_on_MTB = self._finger_i_on_MTB(2)
        self.finger_off_MTB = '%s %s -1' % (self.EV_ABS,
                                            self.ABS_MT_TRACKING_ID)

        finger_MTB = '{0} %s {1}'
        finger_on_MTB = finger_MTB.format(self.EV_KEY, 1)
        finger_off_MTB = finger_MTB.format(self.EV_KEY, 0)

        self.dev_event = {
            '1st Finger Landed': finger_on_MTB  % self.BTN_TOOL_FINGER,
            '1st Finger Lifted': finger_off_MTB % self.BTN_TOOL_FINGER,
            '2nd Finger Landed': finger_on_MTB  % self.BTN_TOOL_DOUBLETAP,
            '2nd Finger Lifted': finger_off_MTB % self.BTN_TOOL_DOUBLETAP,
            '3rd Finger Landed': finger_on_MTB  % self.BTN_TOOL_TRIPLETAP,
            '3rd Finger Lifted': finger_off_MTB % self.BTN_TOOL_TRIPLETAP,
        }

    def _extract_playback_time(self, line):
        ''' Extract the actual event playback time from the line '''
        return int(float(line.split('playback ')[1]) * 1000)

    def _find_event_time(self, ev_seq):
        ''' Match the events in ev_seq against the device time file, and
        return the time stamps of the matched device events.
        '''
        ev_seq_len = len(ev_seq)
        if ev_seq_len == 0:
            return None

        with open(TrackpadDevice.DEVICE_TIME_FILE) as f:
            time_file = f.read().splitlines()

        ev = ev_seq.pop(0)
        for line in time_file:
            if ev in line:
                if len(ev_seq) == 0:
                    return self._extract_playback_time(line)
                ev = ev_seq.pop(0)
        return None

    def get_finger_time(self, ev_str):
        ''' Derive the device playback time when the 2nd finger touches '''
        ev_seq_MTB = [self.dev_event[ev_str]]
        return [self._find_event_time(ev_seq_MTB)]

    def get_2nd_finger_touch_time(self, direction):
        ''' Derive the device playback time when the 2nd finger touches '''
        ev_time = None
        # When the functionality is 'two_fingers_no_delay_2d' in config file,
        # check the ABS_MT_POSITION_X or ABS_MT_POSITION_Y event time.
        # Use the timestamp which occurs earlier.
        for ev_code in self.ev_code_dict[direction]:
            motion_code = '%s %s' % (self.EV_ABS, ev_code)
            ev_seq_MTB = [self.second_finger_on_MTB, motion_code]
            new_ev_time = self._find_event_time(ev_seq_MTB)
            ev_time = new_ev_time if ev_time is None else min(ev_time,
                                                              new_ev_time)
        return ev_time

    def get_2nd_finger_lifted_time(self):
        ''' Derive the device playback time when the 2nd finger is lifted '''
        ev_seq_MTB = [self.second_finger_on_MTB, self.finger_off_MTB]
        return self._find_event_time(ev_seq_MTB)

    def get_two_finger_touch_time_list(self):
        ''' Derive all device playback times when two fingers touch the pad '''
        with open(TrackpadDevice.DEVICE_TIME_FILE) as f:
            time_file = f.read().splitlines()

        ev = self.dev_event['2nd Finger Landed']
        touch_time_list = []
        for line in time_file:
            if ev in line:
                touch_time_list.append(self._extract_playback_time(line))
        return touch_time_list

    def _get_trackpad_driver(self):
        ''' Query which trackpad driver is used in xorg '''
        trackpad_drivers = read_trackpad_test_conf('trackpad_drivers', '.')
        xorg_log = read_trackpad_test_conf('xorg_log', '.')

        try:
            f = open(xorg_log)
        except IOError:
            raise error.TestError('Xorg log file %s does not exist.' % xorg_log)
        log_lines = f.read().splitlines()
        f.close()

        for line in log_lines:
            if 'LoadModule' in line:
                for driver in trackpad_drivers:
                    if driver in line:
                        logging.info('Trackpad driver "%s" is found.' % driver)
                        self.trackpad_driver = driver
                        return self.trackpad_driver
        raise error.TestError('Cannot find driver in %s.' %
                              str(trackpad_drivers))

    def _ungrab_device(self):
        ''' Ungrab the device if the driver is synaptics and is grabbed '''
        self.grab_value = -1
        display_environ = trackpad_util.Display().get_environ()
        synclient_list_cmd = ' '.join([display_environ, 'synclient -l'])
        self.grab_device = ' '.join([display_environ,
                                     'synclient GrabEventDevice=%d'])
        synclient_settings = utils.system_output(synclient_list_cmd)
        for line in synclient_settings.splitlines():
            if line.lstrip().startswith('GrabEventDevice'):
                self.grab_value = int(line.split('=')[1].strip())
                break
        logging.info('GrabEventDevice=%d.' % self.grab_value)
        if self.grab_value == -1:
            err_msg = 'Cannot find GrabEventDevice setting in "%s".'
            raise error.TestError(err_msg % synclient_list_cmd)
        # Ungrab the device only if it has been grabbed.
        elif self.grab_value == 1:
            try:
                utils.system(self.grab_device % 0)
            except:
                raise error.TestError('Fail to execute: %s' % ungrab_cmd)
            logging.info('The synaptics device file is ungrabbed now.')

    def playback(self, packet_data_file):
        play_cmd = '%s %s %s < %s' % (TrackpadDevice.PLAYBACK_PROGRAM,
                                      self.trackpad_device_file,
                                      TrackpadDevice.DEVICE_TIME_FILE,
                                      packet_data_file)
        utils.system(play_cmd)

    def __del__(self):
        # Grab the device again only if it was originally grabbed.
        if self.trackpad_driver == 'synaptics' and self.grab_value == 1:
            try:
                utils.system(self.grab_device % 1)
            except:
                raise error.TestError('Fail to execute: %s' % grab_cmd)
            logging.info('The synaptics device file is grabbed successfully.')

        # Remove the temporary device time file
        if os.path.exists(TrackpadDevice.DEVICE_TIME_FILE):
            try:
                os.remove(TrackpadDevice.DEVICE_TIME_FILE)
            except:
                logging.warn('Cannot remove the device time file: %s.' %
                             TrackpadDevice.DEVICE_TIME_FILE)