# Copyright (c) 2012 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 os
import sys

sys.path.append('/usr/local/autotest/bin/input')
from linux_input import *


# Define some constants
X = 'x'
Y = 'y'
XY = 'xy'
MAX_SLOT = 10
EV_GROUP_TC = 'type-code'
EV_GROUP_TCV = 'type-code-value'


class TrackpadDeviceDecode:
    """Decode trackpad device events."""

    def __init__(self):
        self._init_event_type_code()
        self._init_event_structure()
        self._init_event_name_dict()
        self._init_axis_dict()
        self._init_motion_sep_list()
        self._init_hidden_event_list()

    def _init_axis_dict(self):
        self.axis_dict = {self.abs_mt_x: X,
                          self.abs_mt_y: Y
                         }

    def _init_motion_sep_list(self):
        self.motion_sep_list = [
            self.finger_on,
            self.finger_off,
            self.mouse_click_press,
            self.mouse_click_release,
            self.two_fingers_on,
            self.three_fingers_on,
            self.four_fingers_on,
        ]

    def _init_hidden_event_list(self):
        self.hidden_event_list = [
            self.one_finger_off,
            self.two_fingers_off,
            self.three_fingers_off,
            self.four_fingers_off
        ]

    def _init_event_type_code(self):
        """Initialize event type and code."""
        self.ev_format = ev_format = '%04x'
        self.tcv_format = '%s %s'
        self.max_slot = MAX_SLOT

        # Event types
        self.EV_SYN = ev_format % EV_SYN
        self.EV_KEY = ev_format % EV_KEY
        self.EV_ABS = ev_format % EV_ABS

        # Event codes for synchronization event
        self.SYN_REPORT = ev_format % SYN_REPORT

        # Event codes for absolute axes
        self.ABS_MT_SLOT = ev_format % ABS_MT_SLOT
        self.ABS_MT_TRACKING_ID = ev_format % ABS_MT_TRACKING_ID

        # Event codes for keys and buttons
        self.BTN_MOUSE = ev_format % BTN_MOUSE
        self.BTN_TOUCH = ev_format % BTN_TOUCH
        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
        self.BTN_TOOL_QUADTAP = ev_format % BTN_TOOL_QUADTAP

        # Event codes for keys and buttons
        self.ABS_X = ev_format % ABS_X
        self.ABS_Y = ev_format % ABS_Y
        self.ABS_PRESSURE = ev_format % ABS_PRESSURE
        self.ABS_MT_SLOT = ev_format % ABS_MT_SLOT
        self.ABS_MT_POSITION_X = ev_format % ABS_MT_POSITION_X
        self.ABS_MT_POSITION_Y = ev_format % ABS_MT_POSITION_Y
        self.ABS_MT_TRACKING_ID = ev_format % ABS_MT_TRACKING_ID
        self.ABS_MT_PRESSURE = ev_format % ABS_MT_PRESSURE

    def _init_event_structure(self):
        ev_type_code = '%s %s'
        ev_struct = '%s %s %d'
        self.finger_on = ev_struct % (self.EV_KEY, self.BTN_TOUCH, 1)
        self.finger_off = ev_struct % (self.EV_KEY, self.BTN_TOUCH, 0)
        self.mouse_click_press = ev_struct % (self.EV_KEY, self.BTN_MOUSE, 1)
        self.mouse_click_release = ev_struct % (self.EV_KEY, self.BTN_MOUSE, 0)
        self.one_finger_on = ev_struct % (self.EV_KEY, self.BTN_TOOL_FINGER, 1)
        self.one_finger_off = ev_struct % (self.EV_KEY, self.BTN_TOOL_FINGER, 0)
        self.two_fingers_on = ev_struct % (self.EV_KEY,
                                           self.BTN_TOOL_DOUBLETAP, 1)
        self.two_fingers_off = ev_struct % (self.EV_KEY,
                                            self.BTN_TOOL_DOUBLETAP, 0)
        self.three_fingers_on = ev_struct % (self.EV_KEY,
                                             self.BTN_TOOL_TRIPLETAP, 1)
        self.three_fingers_off = ev_struct % (self.EV_KEY,
                                              self.BTN_TOOL_TRIPLETAP, 0)
        self.four_fingers_on = ev_struct % (self.EV_KEY,
                                            self.BTN_TOOL_QUADTAP, 1)
        self.four_fingers_off = ev_struct % (self.EV_KEY,
                                             self.BTN_TOOL_QUADTAP, 0)
        self.tracking_id = ev_type_code % (self.EV_ABS, self.ABS_MT_TRACKING_ID)
        self.slot = ev_type_code % (self.EV_ABS, self.ABS_MT_SLOT)
        self.abs_mt_x = ev_type_code % (self.EV_ABS, self.ABS_MT_POSITION_X)
        self.abs_mt_y = ev_type_code % (self.EV_ABS, self.ABS_MT_POSITION_Y)
        self.abs_mt_z = ev_type_code % (self.EV_ABS, self.ABS_MT_PRESSURE)
        self.abs_x = ev_type_code % (self.EV_ABS, self.ABS_X)
        self.abs_y = ev_type_code % (self.EV_ABS, self.ABS_Y)
        self.abs_z = ev_type_code % (self.EV_ABS, self.ABS_PRESSURE)
        self.ev_syn = ev_type_code % (self.EV_SYN, self.SYN_REPORT)

    def _init_event_name_dict(self):
        self.event_name_dict = {
            self.finger_on: 'Finger on',
            self.finger_off: 'Finger off',
            self.mouse_click_press: 'Mouse click press',
            self.mouse_click_release: 'Mouse click release',
            self.one_finger_on: 'One finger on',
            self.one_finger_off: 'One finger off',
            self.two_fingers_on: 'Two fingers on',
            self.two_fingers_off: 'Two fingers off',
            self.three_fingers_on: 'Three fingers on',
            self.three_fingers_off: 'Three fingers off',
            self.four_fingers_on: 'Four fingers on',
            self.four_fingers_off: 'Four fingers off',
            self.tracking_id: 'Tracking ID',
            self.slot: 'Slot',
            self.abs_mt_x: 'Abs mt x',
            self.abs_mt_y: 'Abs mt y',
            self.abs_mt_z: 'Abs mt z',
            self.abs_x: 'Abs x',
            self.abs_y: 'Abs y',
            self.abs_z: 'Abs z',
            self.ev_syn: 'SYN',
        }

    def _get_axis(self, tc):
        return self.axis_dict[tc]

    def _calc_accu_motion(self, slot, axis, evalue):
        value = int(evalue)
        s = slot
        if self.prev_pos[s][axis] is not None:
            motion = abs(value - self.prev_pos[s][axis])
            self.accu_motion[s][axis] += motion
            self.accu_motion[s][XY] += motion
        self.prev_pos[s][axis] = value

    def _reset_accu_motion(self, slot=None):
        slots = range(self.max_slot) if slot is None else [slot]
        for s in slots:
            self.accu_motion[s][X] = 0
            self.accu_motion[s][Y] = 0
            self.accu_motion[s][XY] = 0

    def _reset_accu_pos(self, slot=None):
        slots = range(self.max_slot) if slot is None else [slot]
        for s in slots:
            self.prev_pos[s][X] = None
            self.prev_pos[s][Y] = None

    def _reset_time(self):
        self.time_finger_on = None
        self.time_finger_off = None

    def _calc_timespan(self, bgn_time, end_time):
        if bgn_time is None or end_time is None:
            return None
        else:
            timespan = float(end_time) - float(bgn_time)
            return timespan

    def _init_pos_and_motion(self):
        self.prev_pos = {}
        self.accu_motion = {}
        for s in range(self.max_slot):
            self.prev_pos[s] = {}
            self.accu_motion[s] = {}
        self._reset_accu_pos()
        self._reset_accu_motion()

    def _output_append_motion(self, slot):
        if self.accu_motion[slot][XY] > 0:
            self.output.append(self.motion_format % (slot,
                               self.accu_motion[slot][X],
                               self.accu_motion[slot][Y],
                               self.accu_motion[slot][XY]))

    def _output_append_event(self, group, data, evalue=None):
        event_str = None
        is_finger_on = False
        if group == EV_GROUP_TCV:
            tcv = data
            is_finger_on = tcv == self.finger_on
            if tcv not in self.hidden_event_list:
                if is_finger_on:
                    prefix = '\n'
                elif tcv == self.finger_off:
                    prefix = ''
                else:
                    prefix = '  '
                event_str = prefix + self.event_name_dict[tcv]
        elif group == EV_GROUP_TC:
            tc = data
            event_str = ('      ' + self.tcv_format %
                         (self.event_name_dict[tc], evalue))

        # If finger_on event does not appear yet, save the event_str so
        # that it can be appended to the output after the finger_on event.
        if event_str is not None:
            if self.time_finger_on is None:
                self.output_buffer.append(event_str)
            else:
                self.output.append(event_str)

        # Flush any previous event_str stored in output_buffer to output
        # if this data is a finger_on event
        if is_finger_on:
            for e in self.output_buffer:
                self.output.append(e)
            self.output_buffer = []

    def _output_append_time(self, timespan):
        if timespan is None:
            self.output.append('  warning: finger on event was missing!')
        else:
            msg = '  timespan for whole finger on period: %f seconds'
            self.output.append(msg % timespan)

    def decode_device_events(self, file_name):
        """Decode the device event file."""
        if not os.path.isfile(file_name):
            print ('Warning: the device event file "%s" does not exist.' %
                   file_name)
            return
        print '\n\n%s' % ('-' * 60)
        print 'Decoding %s ...' % file_name

        self.output = []
        self.output_buffer = []
        self._init_pos_and_motion()
        slot = 0
        motion_format = ('      accu_motion[%d]: x = %d, y = %d, ' 'xy = %d')
        self.motion_format = motion_format
        self._reset_time()

        with open(file_name) as f:
            for line in f:
                # print 'Decode line: ', line
                header, timestamp, etype, ecode, evalue = line.split()
                tc = '%s %s' % (etype, ecode)
                tcv = '%s %s %s' % (etype, ecode, evalue)

                # Output accumulated motion if current event is in the
                # motion_sep_list, e.g., mouse_click_press, two_fingers_on, etc.
                if tcv in self.motion_sep_list:
                    for s in range(self.max_slot):
                        self._output_append_motion(s)
                    self._reset_accu_motion()

                if tcv == self.finger_on:
                    self.time_finger_on = timestamp

                if tcv == self.finger_off:
                    self._reset_accu_pos()
                    self._reset_accu_motion()
                    self.time_finger_off = timestamp
                    timespan = self._calc_timespan(self.time_finger_on,
                                                   self.time_finger_off)
                    self._output_append_time(timespan)

                if tcv in self.event_name_dict:
                    self._output_append_event(EV_GROUP_TCV, tcv)

                elif tc in self.event_name_dict:
                    if tc == self.slot:
                        slot = int(evalue)

                    elif tc == self.tracking_id and evalue == '-1':
                        self._output_append_motion(slot)
                        self._reset_accu_pos(slot)
                        self._reset_accu_motion(slot)

                    elif tc in self.axis_dict:
                        self._calc_accu_motion(slot, self._get_axis(tc), evalue)

                if tcv == self.finger_off:
                    self._reset_time()

        for line in self.output:
            print line


if __name__ == '__main__':
    tdd = TrackpadDeviceDecode()
    tdd.decode_device_events(sys.argv[1])