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

import inspect
import optparse
import os
import sys
from subprocess import Popen, PIPE

import colorama as color

from remote import ChromeOSTouchDevice, AndroidTouchDevice, mt
from remote import ElanTouchScreenDevice, ElanTouchDevice, SynapticsTouchDevice
from report import Report
from test_suite import TestSuite

REPORT_LOCATION_FORMAT = '%s_report.html'

def parse_arguments():
  VALID_DUT_TYPES = ['chromeos', 'android', 'elan_i2c', 'elan_ts_i2c',
                     'synaptics_ts_i2c', 'replay']
  VALID_MODES = ['performance', 'noise', 'full']
  VALID_PROTOCOLS = [mt.MTA, mt.MTB, mt.STYLUS, 'auto']
  parser = optparse.OptionParser()

  # DUT specification information
  parser.add_option('-a', '--addr', dest='addr', default=None,
                    help=('The address of the DUT (ip for CrOS, Device ID '
                          'for Android, or a filename to replay old results).'))
  parser.add_option('-t', '--type', dest='dut_type', default=None,
                    help='The type of DUT (android, chromeos, or replay).')
  parser.add_option('-d', '--device_num', dest='device_num',
                    default=None, type=int,
                    help='The device number of the touch sensor if you know it')
  parser.add_option('--touchscreen', dest='is_touchscreen',
                    default=False, action='store_true',
                    help=('Use the touchscreen (instead of touchpad) on '
                          'the device.'))

  parser.add_option('--protocol', dest='protocol', default='auto',
                    help=('Manually specify the multitouch protocol for the '
                          'DUT.  This should be detected automatically, but '
                          'in the event that fails, you may specify "mtb", '
                          '"mta", or "stylus" with this flag to over-ride it.'))
  parser.add_option('-n', '--name', dest='name', default='unknown_device',
                    help='The name of this DUT.  This is used by the robot to '
                         'store calibration data and is only needed if you are '
                         'using the touchbot.  Simply keep the name consistent '
                         'across multiple tests on the same DUT to avoid '
                         'having to recalibrate the robot each time.')

  # Lab equipment specification
  parser.add_option('-r', '--robot', dest='has_robot',
                    default=False, action='store_true',
                    help=('Indicate that you have a Google Touchbot that '
                          'will perform your gestures for you.'))
  parser.add_option('-f', '--fn_gen', dest='has_fn_gen',
                    default=False, action='store_true',
                    help=('Indicate that you have an HP 33120A function '
                          'generator to automate the electric noise tests.'))
  parser.add_option('-m', '--mode', dest='mode', default='performance',
                    help=('Which mode to run the test suite in. Options are '
                          '(performance, noise, or full) with performance as '
                          'the default selection.'))

  # Test suite settings
  parser.add_option('-i', '--iterations', dest='num_iterations', default=1,
                    type=int, help=('The number of test iterations to run.'))
  parser.add_option('--title', dest='title', default=None,
                    help='An optional title to put at the top of the report.')
  parser.add_option('--test_version', dest='test_version', default=None,
                    help=('An optionally overridden test version string.  This '
                          'string will appear at the top of the report.  If '
                          'left undefined the most recent git commit hash is '
                          'used by default.'))

  (options, args) = parser.parse_args()

  if options.dut_type not in VALID_DUT_TYPES:
    print 'ERROR: invalid dut type "%s"' % options.dut_type
    print 'valid dut types are: %s' % str(VALID_DUT_TYPES)
    sys.exit(1)
  elif options.dut_type == 'chromeos' and not options.addr:
    print 'ERROR: You must supply an IP address for ChromeOS DUTs'
    sys.exit(1)
  # Aardvark setup does not support the physical button
  elif options.dut_type in ['android', 'elan_ts_i2c',
                            'elan_i2c', 'synaptics_ts_i2c']:
    options.is_touchscreen = True

  if options.protocol not in VALID_PROTOCOLS:
    print 'ERROR: invalid protocol "%s"' % options.protocol
    print 'valid protocols are: %s' % str(VALID_PROTOCOLS)
    sys.exit(1)
  if options.mode not in VALID_MODES:
    print 'ERROR: invalid mode "%s"' % options.mode
    print 'valid modes are: %s' % str(VALID_MODES)
    sys.exit(1)

  # If they didn't manually specify a test_version string, generate the default
  # By looking up the most recent commit in the touch_firmware_test git repo.
  if options.test_version is None:
    src_file = inspect.getfile(inspect.currentframe())
    root_path = os.path.dirname(os.path.realpath(src_file))
    git_path = os.path.join(root_path, '.git')
    args = ['git', '--git-dir', git_path, 'log', '--oneline', '-n1']
    options.test_version = Popen(args, stdout=PIPE).communicate()[0]

  return options, args


def initialize_touch_device(options):
  """ Using the supplied options connect to the DUT """
  # Open a connection to the device specified
  print (color.Style.DIM + color.Fore.RED +
         'Please do not touch the device until the test starts!')
  print 'Connecting to remote touch device...'
  if options.dut_type == 'chromeos':
    touch_dev = ChromeOSTouchDevice(options.addr, options.is_touchscreen,
                                    options.protocol,
                                    device_num=options.device_num)
  elif options.dut_type == 'android':
    touch_dev = AndroidTouchDevice(options.addr, True, options.protocol,
                                   options.device_num)
  elif options.dut_type == 'elan_i2c':
    touch_dev = ElanTouchDevice(options.addr)
  elif options.dut_type == 'elan_ts_i2c':
    touch_dev = ElanTouchScreenDevice(options.addr)
  elif options.dut_type == 'synaptics_ts_i2c':
    touch_dev = SynapticsTouchDevice(options.addr)
  else:
    return None

  return touch_dev

def main():
  base_dir = os.getenv('TOUCH_REPORT_OUTPUT', '.')
  print base_dir
  color.init(autoreset=True)

  # Parse and validate the command line arguments
  options, args = parse_arguments()

  if options.dut_type != 'replay':
    # Connect to the DUT
    touch_dev = initialize_touch_device(options)

    # Create a test flow object that will run the test step by step
    test_suite = TestSuite(touch_dev, options, args)

    # Run through the entire test suite in turn
    while test_suite.RunNextTestAndVariation():
      pass
    test_suite.StopPlotter()

    # The test suite should have a fully populated Report object now, filled
    # with the results of all the test runs.
    report = test_suite.report

    # Save this report into a default location as a backup in case you want
    # to replay it later.
    report.SaveToDisk(base_dir + '/last_report.p')
  else:
    # We are trying to replay an old report from a file on disk.  Load it
    # directly from the specified file instead of running the test over again.
    report = Report.FromFile(options.addr)

  # Generate an HTML version of the Report and write it to disk
  report_filename = REPORT_LOCATION_FORMAT % options.mode
  report_path = base_dir + "/" + report_filename;
  print (color.Fore.MAGENTA + 'FW Testing Complete.  Report is being generated '
         'now, and will be stored on disk as "%s"' % report_path)
  html_report = report.GenerateHtml()
  with open(report_path, 'w') as fo:
    fo.write(html_report)

  return 0


if __name__ == "__main__":
  sys.exit(main())