#!/usr/bin/env python
#
# Copyright (C) 2013 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os
import re
import subprocess
import sys
from xml.dom import Node
from xml.dom import minidom

def getChildrenWithTag(parent, tagName):
  children = []
  for child in  parent.childNodes:
    if (child.nodeType == Node.ELEMENT_NODE) and (child.tagName == tagName):
      #print "parent " + parent.getAttribute("name") + " " + tagName +\
      #  " " + child.getAttribute("name")
      children.append(child)
  return children

def getText(tag):
  return str(tag.firstChild.nodeValue)

class TestCase(object):
  def __init__(self, name, summary, details, result):
    self.name = name
    self.summary = summary
    self.details = details
    self.result = result

  def getName(self):
    return self.name

  def getSummary(self):
    return self.summary

  def getDetails(self):
    return self.details

  def getResult(self):
    return self.result

def parseSuite(suite, parentName):
  if parentName != "":
    parentName += '.'
  cases = {}
  childSuites = getChildrenWithTag(suite, "TestSuite")
  for child in childSuites:
    cases.update(parseSuite(child, parentName + child.getAttribute("name")))
  childTestCases = getChildrenWithTag(suite, "TestCase")
  for child in childTestCases:
    className = parentName + child.getAttribute("name")
    for test in getChildrenWithTag(child, "Test"):
      methodName = test.getAttribute("name")
      # do not include this
      if methodName == "testAndroidTestCaseSetupProperly":
        continue
      caseName = str(className + "#" + methodName)
      result = str(test.getAttribute("result"))
      summary = {}
      details = {}
      if result == "pass":
        sts = getChildrenWithTag(test, "Summary")
        dts = getChildrenWithTag(test, "Details")
        if len(sts) == len(dts) == 1:
          summary[sts[0].getAttribute("message")] = getText(sts[0])
          for d in getChildrenWithTag(dts[0], "ValueArray"):
            values = []
            for c in getChildrenWithTag(d, "Value"):
              values.append(getText(c))
            details[d.getAttribute("message")] = values
        else:
          result = "no results"
      testCase = TestCase(caseName, summary, details, result)
      cases[caseName] = testCase
  return cases


class Result(object):
  def __init__(self, reportXml):
    self.results = {}
    self.infoKeys = []
    self.infoValues = []
    doc = minidom.parse(reportXml)
    testResult = doc.getElementsByTagName("TestResult")[0]
    buildInfos = testResult.getElementsByTagName("BuildInfo")
    if buildInfos != None and len(buildInfos) > 0:
      buildInfo = buildInfos[0]
      buildId = buildInfo.getAttribute("buildID")
      deviceId = buildInfo.getAttribute("deviceID")
      deviceName = buildInfo.getAttribute("build_device")
      boardName = buildInfo.getAttribute("build_board")
      partitions = buildInfo.getAttribute("partitions")
      m = re.search(r'.*;/data\s+([\w\.]+)\s+([\w\.]+)\s+([\w\.]+)\s+([\w\.]+);', partitions)
      dataPartitionSize = m.group(1)
      self.addKV("device", deviceName)
      self.addKV("board", boardName)
      self.addKV("serial", deviceId)
      self.addKV("build", buildId)
      self.addKV("data size", dataPartitionSize)
    packages = getChildrenWithTag(testResult, "TestPackage")
    for package in packages:
      casesFromChild = parseSuite(package, "")
      self.results.update(casesFromChild)
    #print self.results.keys()

  def addKV(self, key, value):
    self.infoKeys.append(key)
    self.infoValues.append(value)

  def getResults(self):
    return self.results

  def getKeys(self):
    return self.infoKeys

  def getValues(self):
    return self.infoValues

  def getDeviceName(self):
    return self.getInfoV("device")

  def getInfoV(self, key):
    if key in self.infoKeys:
      return self.infoValues[self.infoKeys.index(key)]
    else:
      return "unknown"

def executeWithResult(command):
  p = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
  out, err = p.communicate()
  return out

def parseReports(path):
  deviceResults = []
  xmls = executeWithResult("find " + path + " -name testResult.xml -print")
  print "xml files found :"
  print xmls
  for xml in xmls.splitlines():
    result = Result(xml)
    deviceResults.append(result)
  reportInfo = {}
  keys = ["device", "board", "serial", "build", "data size"]
  numDevices = len(deviceResults)
  for i in xrange(len(keys)):
    values = []
    for j in xrange(numDevices):
      values.append(str(deviceResults[j].getInfoV(keys[i])))
    reportInfo[keys[i]] = values
  #print reportInfo

  tests = []
  for deviceResult in deviceResults:
    for key in deviceResult.getResults().keys():
      if not key in tests:
        tests.append(key)
  #print tests

  reportTests = {}
  for i in xrange(len(tests)):
    test = tests[i]
    reportTests[test] = []
    for j in xrange(numDevices):
      values = {}
      if deviceResults[j].getResults().has_key(test):
        result = deviceResults[j].getResults()[test]
        values["result"] = result.getResult()
        values["summary"] = result.getSummary()
        values["details"] = result.getDetails()
        values["device"] = deviceResults[j].getDeviceName()
      # even if report does not have test, put empty dict
      # otherwise, there is no way to distinguish results from the same device
      reportTests[test].append(values)
  #print reportTests
  return (reportInfo, reportTests)

def main(argv):
  if len(argv) < 3:
    print "get_csv_report.py cts_report_dir output_file"
    sys.exit(1)
  reportPath = os.path.abspath(argv[1])
  outputCsv = os.path.abspath(argv[2])

  (reportInfo, reportTests) = parseReports(reportPath)

  with open(outputCsv, 'w') as f:
    for key in reportInfo:
      f.write(key)
      for value in reportInfo[key]:
        f.write(',')
        f.write(value)
      f.write('\n')
    sortedTest = sorted(reportTests)
    for test in sortedTest:
      f.write(test)
      for report in reportTests[test]:
        f.write(',')
        if 'summary' in report:
          summaryValues = report['summary'].values()
          if len(summaryValues) > 0:
            f.write(summaryValues[0])
        # else: no data printed but just empty cell
      # close a test with line
      f.write('\n')

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