# -*- coding: utf-8 -*-
#
# Copyright (c) 2010 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.


# DESCRIPTION :
#
# Intended for use during manufacturing to validate that all keyboard
# keys function properly.  This program will display a keyboard image
# and keys will be highlighted as they are pressed and released.
# After the first key is hit, a countdown will begin.  If not all keys
# are used in time, the test will fail.


import cairo
import gobject
import gtk
import logging
import time
import os
import sys
import utils

import re
import subprocess

from gtk import gdk

from autotest_lib.client.bin import test
from autotest_lib.client.common_lib import error
from autotest_lib.client.cros import factory_setup_modules
from cros.factory.test import factory
from cros.factory.test import ui as ful

# The keycodes from the GTK keyboard event have a +8 offset
# from the real one, hence the constant here
_GTK_KB_KEYCODE_OFFSET = 8

# GTK keycode for left Ctrl, Alt and Shift.
_LCTRL = 37
_LALT = 64
_LSHIFT = 50

# GTK state mask for key combination.
_MOD_MASK = gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK | gtk.gdk.SHIFT_MASK

def GenerateKeycodeBinding(old_bindings):
    '''Offsets the bindings keycodes for GTK.'''
    key_to_geom = {}
    for item in old_bindings.items():
        key_to_geom[item[0] + _GTK_KB_KEYCODE_OFFSET] = (
                item[1] if isinstance(item[1], list) else [item[1],])
    return key_to_geom

class KeyboardTest:
    '''Keyboard test.

    Args:
      kbd_image: Keyboard image file
      binding: Keyboard binding file
      scale: image scaling factor
      accept_combi_key: (bool) True to accept combination key.
    '''

    def __init__(self, kbd_image, bindings, scale, accept_combi_key):
        self._kbd_image = kbd_image
        self._bindings = bindings
        self._scale = scale
        self._pressed_keys = set()
        self._deadline = None
        self.successful_keys = set()
        self._accept_combi_key = accept_combi_key

    def calc_missing_string(self):
        missing_keys = sorted((gdk.keyval_name(k) or '<0x%x>' % k)for k in
                              set(self._bindings) - self.successful_keys)
        if not missing_keys:
            return ''
        return ('Missing following keys\n' +
                '没有侦测到下列按键，键盘可能故障，请检修: %s' %
                ', '.join(missing_keys))

    def timer_event(self, countdown_label):
        if not self._deadline:   # Ignore timer with no countdown in progress.
            return True
        time_remaining = max(0, self._deadline - time.time())
        if time_remaining == 0:
            factory.log('deadline reached')
            gtk.main_quit()
        countdown_label.set_text('%d' % time_remaining)
        countdown_label.queue_draw()
        return True

    def expose_event(self, widget, event):
        context = widget.window.cairo_create()

        # Show keyboard image as the background.
        context.scale(self._scale, self._scale)
        context.set_source_surface(self._kbd_image, 0, 0)
        context.paint()

        for key in self.successful_keys:
            for coords in self._bindings[key]:
                context.rectangle(*coords)
                context.set_source_rgba(*ful.RGBA_GREEN_OVERLAY)
                context.fill()
        for key in self._pressed_keys:
            for coords in self._bindings[key]:
                context.rectangle(*coords)
                context.set_source_rgba(*ful.RGBA_YELLOW_OVERLAY)
                context.fill()

        return True

    def get_combined_keycode(self, event):
        '''Gets combined keycode.

        If Ctrl/Alt/Shift is also presented in key event, returns
        hardware_keycode + offset:
          Shift: 256
          Ctrl: 1024
          Alt: 2048

        Args:
          event: GTK event.

        Returns:
          Combined keycode explained above.
        '''
        return event.hardware_keycode + ((event.state & _MOD_MASK) << 8)

    def process_combi_key_press_event(self, event):
        '''Processes key-press event with combination key.

        Args:
          event: GTK event.

        Returns:
          (accept, keycode):
            accept == True if the key is in _bindings.
            keycode: combined keycode. Refer get_combined_keycode().
        '''
        keycode = self.get_combined_keycode(event)
        if keycode in self._bindings:
            # Known issue: if you press left Ctrl then "New Tab (Ctrl-T)", and
            # then release them, the left Ctrl will be discarded unexpectedly.
            # However, as it only hapeends when an operator sweeps keyboard
            # and presses left Ctrl first then "New Tab", which is rare. And
            # if it happends, operator can hit left Ctrl again to fix the
            # issue. So I will leave the issue open until we found a nice fix.
            if event.state & gtk.gdk.CONTROL_MASK:
                self._pressed_keys.discard(_LCTRL)
            if event.state & gtk.gdk.MOD1_MASK:
                self._pressed_keys.discard(_LALT)
            if event.state & gtk.gdk.SHIFT_MASK:
                self._pressed_keys.discard(_LSHIFT)
        elif event.hardware_keycode in self._bindings:
            # For those unbinded key combinations, treat them as only
            # base keys are pressed.
            keycode = event.hardware_keycode
        else:
            return False, 0
        return True, keycode

    def process_simple_key_press_event(self, event):
        '''Processes key-press event regardless key combination.

        Args:
          event: GTK event.

        Returns:
          (accept, keycode):
            accept == True if the key is in _bindings.
            keycode: hardware_keycode.
        '''
        keycode = event.hardware_keycode
        return keycode in self._bindings, keycode

    def key_press_event(self, widget, event):
        accept = False
        if self._accept_combi_key:
            accept, keycode = self.process_combi_key_press_event(event)
        else:
            accept, keycode = self.process_simple_key_press_event(event)
        if not accept:
            factory.log('key (0x%x) ignored because not in bindings'
                        % event.keyval)
            return True

        self._pressed_keys.add(keycode)
        widget.queue_draw()

        # The first keypress starts test countdown.
        if self._deadline is None:
            self._deadline = int(time.time()) + ful.FAIL_TIMEOUT

        return True

    def key_release_event(self, widget, event):
        hardware_keycode_check = True
        if self._accept_combi_key:
            keycode = self.get_combined_keycode(event)
            # If combined keycode is not pressed before, fall back to check
            # hardware_keycode instead.
            hardware_keycode_check = keycode not in self._pressed_keys
        if hardware_keycode_check:
            keycode = event.hardware_keycode
            if keycode not in self._pressed_keys:
                # Ignore releases for keys not previously accepted as pressed.
                return False
        self._pressed_keys.remove(keycode)
        self.successful_keys.add(keycode)
        widget.queue_draw()
        if not self.calc_missing_string():
            factory.log('completed successfully')
            gtk.main_quit()
        return True

    def register_callbacks(self, window):
        window.connect('key-press-event', self.key_press_event)
        window.connect('key-release-event', self.key_release_event)
        window.add_events(gdk.KEY_PRESS_MASK | gdk.KEY_RELEASE_MASK)


class factory_Keyboard(test.test):
    version = 1
    preserve_srcdir = True

    def get_layout_from_vpd(self):
       """ vpd should contain
          "initial_locale"="en-US"
          "keyboard_layout"="xkb:us::eng"
       or similar. """
       cmd = 'vpd -l | grep initial_locale | cut -f4 -d\'"\''
       layout = utils.system_output(cmd).strip()
       if layout != '':
           return layout
       return None

    def run_once(self, layout=None, combi_key=False, config_dir=''):
        '''

        Args:
          layout: use specified layout other than derived from VPD.
          combi_key: True to handle key combination.
          config_dir: specify directory to read keyboard image and binding
             from. If unspeified, read from default directory.
        '''

        factory.log('%s run_once' % self.__class__)

        os.chdir(self.srcdir)

        # Autodetect from VPD.
        if not layout:
            layout = self.get_layout_from_vpd()
        # Default to United States.
        if not layout:
            layout = 'en-US'

        factory.log("Using keyboard layout %s" % layout)
        layout_filename = os.path.join(config_dir, '%s.png' % layout)
        try:
            kbd_image = cairo.ImageSurface.create_from_png(layout_filename)
            image_size = (kbd_image.get_width(), kbd_image.get_height())
        except cairo.Error as e:
            raise error.TestNAError('Error while opening %s: %s' %
                                    (layout_filename, e.message))

        bindings_filename = os.path.join(config_dir, '%s.bindings' % layout)
        try:
            with open(bindings_filename, 'r') as file:
                bindings = eval(file.read())
                bindings = GenerateKeycodeBinding(bindings)
        except IOError as e:
            raise error.TestNAError('Error while opening %s: %s [Errno %d]' %
                                    (e.filename, e.strerror, e.errno))

        scale = ful.calc_scale(*image_size)

        test = KeyboardTest(kbd_image, bindings, scale, combi_key)

        scaled_image_size = (image_size[0] * scale, image_size[1] * scale)

        drawing_area = gtk.DrawingArea()
        drawing_area.set_size_request(*scaled_image_size)
        drawing_area.connect('expose_event', test.expose_event)
        drawing_area.add_events(gdk.EXPOSURE_MASK)

        countdown_widget, countdown_label = ful.make_countdown_widget()
        gobject.timeout_add(1000, test.timer_event, countdown_label)

        test_widget = gtk.VBox()
        test_widget.set_spacing(20)
        test_widget.pack_start(drawing_area, False, False)
        test_widget.pack_start(countdown_widget, False, False)

        ful.run_test_widget(self.job, test_widget,
            window_registration_callback=test.register_callbacks)

        missing = test.calc_missing_string()
        if missing:
            raise error.TestFail(missing)

        factory.log('%s run_once finished' % self.__class__)