#!/usr/bin/python
# Copyright 2012 Google Inc. All Rights Reserved.

"""This Class writes test progress/error/result to files.

This file defines the logging function of the automation test. It
logs test progress, results, error/warning to different files:

  results.txt: this is the file to log the test output
  error.txt:   all test errors are logged into this file
  prompt.txt:  a copy of terminal output, which hints the progress
               of the current test.
"""

__author__ = 'Lehan Meng (lmeng@google.com)'


import datetime
import errno
import os


class Logging(object):
  """This Class collects and writes test information to log files."""

  def __init__(self, **kwargs):
    """initiate the logging instance.

    Args:
      kwargs['f_result']: file name for test result
      kwargs['f_error']: file name for test errors
      kwargs['f_progres']: file name for test progres
      kwargs['std_out']: by default, send a copy of the log info to stdout
    """

    self.params = {'std_out': '1',
                   'f_result': 'result.log',
                   'f_error': 'error.log',
                   'f_progress': 'progress.log',
                   'delimiter': '\t',
                   'out_folder': 'log',
                   'in_folder': 'data'}
    for s in kwargs:
      self.params[s] = kwargs[s]

    try:
      os.makedirs(self.params['out_folder'])
    except OSError, e:
      if e.errno != errno.EEXIST:
        raise

    now = datetime.datetime.now()
    s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
    for f_name in ['f_result', 'f_error', 'f_progress']:
      name = self.ParseLogFileName(self.params[f_name], 'w', s_time)
      if name:
        self.params[f_name] = name
      else:
        print 'Error! Fail to create log File.'
    self.rst_file = open(self.params['f_result'], 'w+')
    self.err_file = open(self.params['f_error'], 'w+')
    self.prg_file = open(self.params['f_progress'], 'w+')
    self.NewTestStart()

  def CreateFile(self, f_name, access='r'):
    """Create a file for read/write.

    Args:
      f_name: the file name that needs to be created
      access: 'r': read, input file
              'w': write, output file
              'rw': read and write
    Returns:
      f_obj: return the file object
             if not succeed, return False
    """
    f_obj = None
    if access == 'r':
      # for input file
      try:
        f_obj = open(f_name, 'r')
      except IOError:
        print 'Cannot open the input file, return'
        return False
    elif access == 'w':
      # for input file
      try:
        os.makedirs(self.params['out_folder'])
      except OSError, e:
        if e.errno != errno.EEXIST:
          print 'Cannot create folder! Return'
          return False
      full_path = self.ParseLogFileName(f_name, access)
      if full_path:
        try:
          f_obj = open(full_path, 'w+')
        except IOError:
          print 'Cannot open the given file, return'
          return False
      else:
        # Can not parse file name
        print 'Cannot parse given file name'
        return False
    else:
      # read-write file:
      try:
        f_obj = open(f_name, 'r')
      except IOError:
        print 'Cannot open the input file, return'
        return False
    return f_obj

  def ParseLogFileName(self, f_name, access='r', time_stamp=None):
    """Generate an uniq log file name for each test case instance.

    Args:
      f_name: file name
      access: 'r': read mode
              'w': write mode
              'rw': read-write
      time_stamp: the time tag used for file name
                  if None, create a new tag using current time
    Returns:
      return the parsed file name
    """
    if not f_name:
      f_name = 'logFile.log'
    if not time_stamp:
      now = datetime.datetime.now()
      s_time = now.strftime('%Y-%m-%d_%H:%M:%S.%f')
    else:
      s_time = time_stamp

    ls = f_name.split('.')
    ext_name = ''
    name = ''
    if len(ls) == 1:
      name = ls[0]
    else:
      ext_name = ls.pop(-1)
      for s in ls:
        name += (s+'.')
      name = name.rstrip('.')

    if not ext_name:
      ext_name = 'log'
    folder = None
    if access == 'r':
      folder = self.params['in_folder']
    elif access == 'w':
      folder = self.params['out_folder']
    else:
      folder = self.params['in_folder']
    name = (folder + '/' + name + '_testID-' + self.params['testID']
            + '_'+ s_time + '.' + ext_name)
    return name

  def SendLineToResult(self, test_info, result_info):
    """Send test result (one-line) information to the result file.

    Args:
      test_info: test case related info: testID, start_time, key_word, etc
      result_info: test results {Pass_Fail: pass, note: Extra_Information}
    Returns:
      return the status of file write operation
    """
    now = datetime.datetime.now()
    if test_info is not None:
      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
              + 'testID:' + test_info['testID']
              + self.params['delimiter'] + 'TestStartAt:'
              + test_info['start_time']
              + self.params['delimiter'] + 'Keyword:' + test_info['key_word']
              + self.params['delimiter'] + result_info['Pass_Fail']
              + self.params['delimiter'] + result_info['note'] + '\n')
    else:
      line = ('Result log information should have testInfo available! '
              + self.params['delimiter'] + 'No logging performed')

    if self.params['std_out'] > 0:
      print line
    self.rst_file.write(line)
    self.rst_file.flush()

  def NewTestStart(self):
    """Mark the start of a new test in the file."""
    self.rst_file.write(
        '################### NEW TEST STARTED ###################\n')
    self.err_file.write(
        '################### NEW TEST STARTED ###################\n')
    self.prg_file.write(
        '################### NEW TEST STARTED ###################\n')

  def SendLineToError(self, test_info, error_info):
    """Send test error (one-line) information to the error file.

    Args:
      test_info: test case related info: testID, start_time, key_word, etc
      error_info: test errors, severity: critical/intermediate/low, and info
    Returns:
      returns the status of file write operation
    """
    now = datetime.datetime.now()
    if test_info is not None:
      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
              + 'testID:' + test_info['testID'] + self.params['delimiter']
              + 'TestStartAt:' + test_info['start_time']
              + self.params['delimiter'] + 'Keyword:'
              + test_info['key_word'] + self.params['delimiter']
              + error_info['severity'] + self.params['delimiter']
              + error_info['note'] + '\n')
    else:
      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter'] +
              error_info['severity'] + self.params['delimiter']
              + error_info['note'] + '\n')

    if self.params['std_out'] > 0:
      print line
    self.err_file.write(line)
    self.err_file.flush()

  def SendLineToProgress(self, test_info, progress_info):
    """Send test progress (one-line) information to the progress file.

    Args:
      test_info: test case related info: testID, start_time, key_word, etc
      progress_info: test progress indication
                    {percent: [0-100]%, note: Information}
    Returns:
      returns the status of file write operation
    """
    now = datetime.datetime.now()
    if test_info is not None:
      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
              + 'testID:' + test_info['testID'] + self.params['delimiter']
              + 'TestStartAt:'+ test_info['start_time']
              + self.params['delimiter'] + 'Keyword:' + test_info['key_word']
              + self.params['delimiter'] + progress_info['percent']
              + self.params['delimiter'] + progress_info['note'] + '\n')
    else:
      line = (now.strftime('%Y-%m-%d %H:%M:%S.%f') + self.params['delimiter']
              + progress_info['percent'] + self.params['delimiter']
              + progress_info['note'] + '\n')

    if self.params['std_out'] > 0:
      print line
    self.prg_file.write(line)
    self.prg_file.flush()

  def SendLine(self, test_info, info):
    """Send test (one-line) information to the corresponding log file.

    Args:
      test_info: test case related info: testID, start_time, key_word, etc
      info: test results/error/progress information (single line)
            test_info could be "None" for class other than TestCase
    Returns:
      return the status of file write operation
    """
    if info['type'] == 'result':
      return self.SendLineToResult(test_info, info)
    elif info['type'] == 'error':
      return self.SendLineToError(test_info, info)
    elif info['type'] == 'progress':
      return self.SendLineToProgress(test_info, info)

  def SendTestData(self, data_list):
    """Send test data to result file."""
    for line in data_list:
      self.rst_file.write(line + '\n')
    self.err_file.flush()

  def SendLines(self, test_info, info):
    """Send test output (multiple lines) to the corresponding log file.

    Args:
      test_info: test case related info: testID, start_time, key_word, etc
      info: test results/error/progress information
            test_info could be "None" for class other than TestCase
    Returns:
      return 1 when succeed
    """
    if info['type'] == 'result':
      for line in info['note'].split('\n'):
        if line == info['note'].split('\n')[0]:
          dup_info = info.copy()
          dup_info['note'] = line
          self.SendLineToResult(test_info, dup_info)
        else:
          self.rst_file.write(line + '\n')
          if self.params['std_out']: print line
          self.rst_file.flush()
    elif info['type'] == 'error':
      for line in info['note'].split('\n'):
        if line == info['note'].split('\n')[0]:
          dup_info = info.copy()
          dup_info['note'] = line
          self.SendLineToError(test_info, dup_info)
        else:
          self.err_file.write(line + '\n')
          if self.params['std_out']: print line
          self.err_file.flush()
    elif info['type'] == 'progress':
      for line in info['note'].split('\n'):
        if line == info['note'].split('\n')[0]:
          dup_info = info.copy()
          dup_info['note'] = line
          self.SendLineToProgress(test_info, dup_info)
        else:
          self.prg_file.write(line + '\n')
          if self.params['std_out']: print line
          self.prg_file.flush()
    return 1

  def CreateResultInfo(self, status='Pass', msg=''):
    """Create the result Info structure for logging.

    Args:
      status: has value 'Pass' or 'Fail'
      msg: test results information line(s)
    Returns:
      returns the infomation structure that should be logged to file
    """
    d = {}
    d.setdefault('type', 'result')
    d.setdefault('Pass_Fail', status)
    d.setdefault('note', msg)
    return d

  def CreateErrorInfo(self, severity='intermediate', msg=''):
    """Create the error Info structure for logging.

    Args:
      severity: has value 'low', 'intermediate' or 'critical'
      msg: test error information line(s)
    Returns:
      returns the infomation structure that should be logged to file
    """
    d = {}
    d.setdefault('type', 'error')
    d.setdefault('severity', severity)
    d.setdefault('note', msg)
    return d

  def CreateProgressInfo(self, percent='0%', msg=''):
    """Create the progress Info structure for logging.

    Args:
      percent: completeness of test progress, in %
      msg: test progress information line(s)
    Returns:
      returns the infomation structure that should be logged to file
    """
    d = {}
    d.setdefault('percent', percent)
    d.setdefault('type', 'progress')
    d.setdefault('note', msg)
    return d

  def __del__(self):
    """Close the log files."""
    self.rst_file.close()
    self.err_file.close()
    self.prg_file.close()