#!/usr/bin/env python3
#
# Copyright 2017 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 script can be used to upload CTS results to CTS and APFE buckets."""

from __future__ import print_function
from lib.upload_utils import UploadUtils
from xml.dom import minidom

import argparse
import getopt
import os.path
import sys


class UploadCts(UploadUtils):
  """Helps upload CTS results to gs:// buckets.

  Prints CTS test results with their pass/fail status to terminal.
  Prints gsutil links to the terminal to upload CTS results to gs:// buckets
  to get the results in the tooling.

  Attributes:
    test_board_name: Test board name.
    current_test_board_name: Temporary string to hold current test board name.
    build_mismatch_exist: A boolean indicating if build mismatch exists.
    failed_tests_exist: A boolean indicating if failed tests exist.
    valid_exist: A boolean indicating if any valid file with the
                 correct build version exists.
    untested_tests_exist: A boolean indicating if untested tests exist.
  """
  def __init__(self, input_build_id, dir_path):
    super(UploadCts, self).__init__()
    self.test_board_name = None
    self.current_test_board_name = None
    self.build_mismatch_exist = False
    self.valid_exist = False
    self.untested_tests_exist = False
    self.obsolete_files_exist = False
    self.input_build_id = input_build_id
    self.dir_path = dir_path

  def PrintBuildInfoList(self):
    """Sorts build information by build board and prints to the terminal."""
    self.build_info_list.sort(key=lambda x: x[1])
    for item in self.build_info_list:
      if self.current_test_board_name != item[1]:
        title_msg = 'List of files for %s' % item[1]
        table_column_header = self.TABLE_HEADER_CTS

        print(self.BOLD +
              self.C_PURPLE +
              title_msg +
              self.BOLD +
              self.C_END)
        print(self.BOLD +
              self.C_BLACK +
              table_column_header +
              self.BOLD +
              self.C_END)

        self.current_test_board_name = item[1]
      self.PrintFormattedDataCts(item)
    print('\n')

  def PrintGsutilLinks(self, dir_path):
    """Prints gsutil links to upload results to CTS and APFE buckets.

    Args:
      dir_path: Results directory path.
    """
    for item in self.build_info_list:
      if self.test_board_name != item[1]:
        print('gsutil cp -r {0}/{1}-release/ gs://chromeos-cts-apfe/'
              .format(dir_path, item[1]))
        print('gsutil cp -r {0}/{1}_{2}/ '
              'gs://chromeos-cts-results/manual'
              .format(dir_path, item[2], item[1]))
        self.test_board_name = item[1]


  def ParseXmlFile(self, abs_input_file_path, test_result_filename, dir_path):
    """Gets build information for M or N Builds.

    Parses the test result xml file to obtain build information. Adds build
    information to a list. Handles Untested tests if they exist. Untested
    tests may not have complete build information or may have partial
    build information in the test_result.xml file.

    Args:
      abs_input_file_path: Absolute input file path.
                           Eg: ~/Downloads/Manual/2017.09.22_14.27.09.zip
      test_result_filename: M/N build test result file name.
                            Eg: testResult.xml(M) or test_result.xml(N)
      dir_path: Results directory path.
                Eg: ~/Downloads/Manual
    """
    self.GetXmlTagNamesCts(test_result_filename)
    tag_list = self.GetXmlTagNamesCts(test_result_filename)
    summary = tag_list[0]
    build_version = tag_list[1]
    build_board_version = tag_list[2]
    build_id_type = tag_list[3]
    test_package_list = tag_list[4]
    test_package_v = tag_list[5]
    build_abi_type = tag_list[6]
    failed = tag_list[7]
    passed = tag_list[8]
    split_file_list = self.SplitFileName(abs_input_file_path)
    basename = split_file_list[1]
    full_base_name = os.path.join(dir_path, basename)
    basename_xml_file = split_file_list[2]
    absolute_base_xml_file = os.path.join(dir_path, basename_xml_file)
    timestamp = basename
    self.CopyFileToDestination(full_base_name,
                               test_result_filename,
                               dir_path,
                               basename_xml_file)
    xml_doc = minidom.parse(absolute_base_xml_file)
    summary = xml_doc.getElementsByTagName(summary)
    build_info = xml_doc.getElementsByTagName(build_version)
    test_package_list = xml_doc.getElementsByTagName(test_package_list)
    if not build_info:
      self.UpdateBuildInfoList([timestamp,
                                'null',
                                'null',
                                'null',
                                'null',
                                '0',
                                '0'])
      self.untested_tests_exist = True
    elif not build_info[0].hasAttribute(build_board_version):
      self.UpdateBuildInfoList([timestamp,
                                'null',
                                'null',
                                'null',
                                'null',
                                '0',
                                '0'])
      self.untested_tests_exist = True
    elif not test_package_list:
      self.UpdateBuildInfoList([timestamp,
                                'null',
                                'null',
                                'null',
                                'null',
                                '0',
                                '0'])
      self.untested_tests_exist = True
    else:
      build_board = build_info[0].attributes[build_board_version].value
      build_id = build_info[0].attributes[build_id_type].value
      test_package = test_package_list[0].attributes[test_package_v].value
      build_abi = test_package_list[0].attributes[build_abi_type].value
      failed = summary[0].attributes[failed].value
      passed = summary[0].attributes[passed].value
      self.UpdateBuildInfoList([timestamp,
                                build_board,
                                build_id,
                                build_abi,
                                test_package,
                                failed,
                                passed])

  def ProcessFilesToUpload(self, input_build_id, dir_path):
    """Process Files to Upload to CTS and APFE Buckets.

    Checks if Test Result File has M build or N Build and parses the
    corresponding xml file to obtain build information.Checks for file
    validity by comparing with provided input BuildID. Pushes valid files to
    appropriate folders to upload to APFE and CTS buckets.Pushes invalid
    files to Obsolete Folder.Pushes untested files if any to UnTested
    Folder.

    Args:
      input_build_id: BuildID command line argument.
      dir_path: Results directory path.
    """
    test_result_filename_n_build = 'test_result.xml'
    test_result_filename_m_build = 'testResult.xml'
    build_id = ' '
    item = ' '
    for the_file in os.listdir(dir_path):
      if the_file.endswith('.zip'):
        full_file_path = os.path.join(dir_path, the_file)
        self.ExtractZipFile(full_file_path, dir_path)
        split_file_list = self.SplitFileName(full_file_path)
        basename = split_file_list[1]
        full_base_name = os.path.join(dir_path, basename)
        src_file = os.path.join(full_base_name,
                                test_result_filename_m_build)
        is_m_build = os.path.isfile(src_file)
        if is_m_build is True:
          self.ParseXmlFile(full_file_path,
                            test_result_filename_m_build,
                            dir_path)

        else:
          self.ParseXmlFile(full_file_path,
                            test_result_filename_n_build,
                            dir_path)

        for item in self.build_info_list:
          build_id = item[2]

        if build_id == input_build_id:
          self.valid_exist = True
          self.CreateApfeFolder(full_file_path, dir_path)
          self.CreateCtsFolder(full_file_path, dir_path)

        else:
          self.obsolete_files_exist = True
          if self.untested_tests_exist is True:
            self.build_info_list.remove(item)
            self.CreateUntestedFolder(full_file_path, dir_path)
            self.untested_tests_exist = False
          else:
            self.build_mismatch_exist = True
            self.build_info_list.remove(item)
            self.CreateObsoleteFolder(full_file_path, dir_path)

  def PrintData(self, dir_path):
    """Print results/gsutil links or error message if invalid files exist."""
    if not self.obsolete_files_exist:
      self.PrintBuildInfoList()
      self.PrintGsutilLinks(dir_path)

    if self.build_mismatch_exist is True and self.valid_exist is True:
      self.PrintBuildInfoList()
      self.PrintGsutilLinks(dir_path)
      self.PrintObsoleteFolderCount()

    if self.untested_file_count > 0 and self.valid_exist is True:
      self.PrintBuildInfoList()
      self.PrintGsutilLinks(dir_path)
      self.PrintUntestedFolderCount()

    if self.obsolete_files_exist is True and not self.valid_exist:
      self.PrintObsoleteFolderCount()
      self.PrintUntestedFolderCount()

def main(argv):
  """Processes result files and prints gsutil links to upload CTS results.

  Displays help message when script is called without expected arguments.
  Displays Usage: upload_cts.py <build_id> <results_dir_path>.
  """
  parser = argparse.ArgumentParser()
  parser.add_argument('build_id',
                      help='upload_cts.py <build_id> <results_dir_path>')
  parser.add_argument('dir_path',
                      help='upload_cts.py <build_id> <results_dir_path>')
  args = parser.parse_args()

  cts = UploadCts(args.build_id,args.dir_path)

  if len(sys.argv) == 1:
    parser.print_help()
    sys.exit(1)
  parser.parse_args()
  try:
    opts, args = getopt.getopt(argv, 'hb:', ['build_id='])
  except getopt.GetoptError:
    sys.exit(2)
  for opt in opts:
    if opt == '-h':
      cts.usage()
      sys.exit()
  cts.ProcessFilesToUpload(cts.input_build_id, cts.dir_path)
  os.system('stty cols 120')
  cts.PrintData(cts.dir_path)

if __name__ == '__main__':
  main(sys.argv[1:])