# Copyright 2015 The Chromium 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 collections
import cPickle
import json
import logging
import os
import re
import socket
import time
import urllib
import urllib2


PENDING = None
SUCCESS = 0
WARNING = 1
FAILURE = 2
EXCEPTION = 4
SLAVE_LOST = 5


BASE_URL = 'http://build.chromium.org/p'
CACHE_FILE_NAME = 'cache.dat'


StackTraceLine = collections.namedtuple(
    'StackTraceLine', ('file', 'function', 'line', 'source'))


def _FetchData(master, url):
  url = '%s/%s/json/%s' % (BASE_URL, master, url)
  try:
    logging.info('Retrieving ' + url)
    return json.load(urllib2.urlopen(url))
  except (urllib2.HTTPError, socket.error):
    # Could be intermittent; try again.
    try:
      return json.load(urllib2.urlopen(url))
    except (urllib2.HTTPError, socket.error):
      logging.error('Error retrieving URL ' + url)
      raise
  except:
    logging.error('Error retrieving URL ' + url)
    raise


def Builders(master):
  builders = {}

  # Load builders from cache file.
  if os.path.exists(master):
    start_time = time.time()
    for builder_name in os.listdir(master):
      cache_file_path = os.path.join(master, builder_name, CACHE_FILE_NAME)
      if os.path.exists(cache_file_path):
        with open(cache_file_path, 'rb') as cache_file:
          try:
            builders[builder_name] = cPickle.load(cache_file)
          except EOFError:
            logging.error('File is corrupted: %s', cache_file_path)
            raise
    logging.info('Loaded builder caches in %0.2f seconds.',
                 time.time() - start_time)

  return builders


def Update(master, builders):
  # Update builders with latest information.
  builder_data = _FetchData(master, 'builders')
  for builder_name, builder_info in builder_data.iteritems():
    if builder_name in builders:
      builders[builder_name].Update(builder_info)
    else:
      builders[builder_name] = Builder(master, builder_name, builder_info)

  return builders


class Builder(object):
  def __init__(self, master, name, data):
    self._master = master
    self._name = name

    self.Update(data)

    self._builds = {}

  def __setstate__(self, state):
    self.__dict__ = state  # pylint: disable=attribute-defined-outside-init
    if not hasattr(self, '_builds'):
      self._builds = {}

  def __lt__(self, other):
    return self.name < other.name

  def __str__(self):
    return self.name

  def __getitem__(self, key):
    if not isinstance(key, int):
      raise TypeError('build numbers must be integers, not %s' %
                      type(key).__name__)

    self._FetchBuilds(key)
    return self._builds[key]

  def _FetchBuilds(self, *build_numbers):
    """Download build details, if not already cached.

    Returns:
      A tuple of downloaded build numbers.
    """
    build_numbers = tuple(build_number for build_number in build_numbers
                          if not (build_number in self._builds and
                          self._builds[build_number].complete))
    if not build_numbers:
      return ()

    for build_number in build_numbers:
      if build_number < 0:
        raise ValueError('Invalid build number: %d' % build_number)

    build_query = urllib.urlencode(
        [('select', build) for build in build_numbers])
    url = 'builders/%s/builds/?%s' % (urllib.quote(self.name), build_query)
    builds = _FetchData(self.master, url)
    for build_info in builds.itervalues():
      self._builds[build_info['number']] = Build(self.master, build_info)

    self._Cache()

    return build_numbers

  def FetchRecentBuilds(self, number_of_builds):
    min_build = max(self.last_build - number_of_builds, -1)
    return self._FetchBuilds(*xrange(self.last_build, min_build, -1))

  def Update(self, data=None):
    if not data:
      data = _FetchData(self.master, 'builders/%s' % urllib.quote(self.name))
    self._state = data['state']
    self._pending_build_count = data['pendingBuilds']
    self._current_builds = tuple(data['currentBuilds'])
    self._cached_builds = tuple(data['cachedBuilds'])
    self._slaves = tuple(data['slaves'])

    self._Cache()

  def _Cache(self):
    cache_dir_path = os.path.join(self.master, self.name)
    if not os.path.exists(cache_dir_path):
      os.makedirs(cache_dir_path)
    cache_file_path = os.path.join(cache_dir_path, CACHE_FILE_NAME)
    with open(cache_file_path, 'wb') as cache_file:
      cPickle.dump(self, cache_file, -1)

  def LastBuilds(self, count):
    min_build = max(self.last_build - count, -1)
    for build_number in xrange(self.last_build, min_build, -1):
      yield self._builds[build_number]

  @property
  def master(self):
    return self._master

  @property
  def name(self):
    return self._name

  @property
  def state(self):
    return self._state

  @property
  def pending_build_count(self):
    return self._pending_build_count

  @property
  def current_builds(self):
    """List of build numbers currently building.

    There may be multiple entries if there are multiple build slaves."""
    return self._current_builds

  @property
  def cached_builds(self):
    """Builds whose data are visible on the master in increasing order.

    More builds may be available than this."""
    return self._cached_builds

  @property
  def last_build(self):
    """Last completed build."""
    for build_number in reversed(self.cached_builds):
      if build_number not in self.current_builds:
        return build_number
    return None

  @property
  def slaves(self):
    return self._slaves


class Build(object):
  def __init__(self, master, data):
    self._master = master
    self._builder_name = data['builderName']
    self._number = data['number']
    self._complete = not ('currentStep' in data and data['currentStep'])
    self._start_time, self._end_time = data['times']

    self._steps = {step_info['name']:
        Step(self._master, self._builder_name, self._number, step_info)
        for step_info in data['steps']}

  def __str__(self):
    return str(self.number)

  def __lt__(self, other):
    return self.number < other.number

  @property
  def builder_name(self):
    return self._builder_name

  @property
  def number(self):
    return self._number

  @property
  def complete(self):
    return self._complete

  @property
  def start_time(self):
    return self._start_time

  @property
  def end_time(self):
    return self._end_time

  @property
  def steps(self):
    return self._steps


def _ParseTraceFromLog(log):
  """Search the log for a stack trace and return a structured representation.

  This function supports both default Python-style stacks and Telemetry-style
  stacks. It returns the first stack trace found in the log - sometimes a bug
  leads to a cascade of failures, so the first one is usually the root cause.
  """
  log_iterator = iter(log.splitlines())
  for line in log_iterator:
    if line == 'Traceback (most recent call last):':
      break
  else:
    return (None, None)

  stack_trace = []
  while True:
    line = log_iterator.next()
    match1 = re.match(r'\s*File "(?P<file>.+)", line (?P<line>[0-9]+), '
                      'in (?P<function>.+)', line)
    match2 = re.match(r'\s*(?P<function>.+) at '
                      '(?P<file>.+):(?P<line>[0-9]+)', line)
    match = match1 or match2
    if not match:
      exception = line
      break
    trace_line = match.groupdict()
    # Use the base name, because the path will be different
    # across platforms and configurations.
    file_base_name = trace_line['file'].split('/')[-1].split('\\')[-1]
    source = log_iterator.next().strip()
    stack_trace.append(StackTraceLine(
        file_base_name, trace_line['function'], trace_line['line'], source))

  return tuple(stack_trace), exception


class Step(object):
  def __init__(self, master, builder_name, build_number, data):
    self._master = master
    self._builder_name = builder_name
    self._build_number = build_number
    self._name = data['name']
    self._result = data['results'][0]
    self._start_time, self._end_time = data['times']

    self._log_link = None
    self._results_link = None
    for link_name, link_url in data['logs']:
      if link_name == 'stdio':
        self._log_link = link_url + '/text'
      elif link_name == 'json.output':
        self._results_link = link_url + '/text'

    self._log = None
    self._results = None
    self._stack_trace = None

  def __getstate__(self):
    return {
      '_master': self._master,
      '_builder_name': self._builder_name,
      '_build_number': self._build_number,
      '_name': self._name,
      '_result': self._result,
      '_start_time': self._start_time,
      '_end_time': self._end_time,
      '_log_link': self._log_link,
      '_results_link': self._results_link,
    }

  def __setstate__(self, state):
    self.__dict__ = state  # pylint: disable=attribute-defined-outside-init
    self._log = None
    self._results = None
    self._stack_trace = None

  def __str__(self):
    return self.name

  @property
  def name(self):
    return self._name

  @property
  def result(self):
    return self._result

  @property
  def start_time(self):
    return self._start_time

  @property
  def end_time(self):
    return self._end_time

  @property
  def log_link(self):
    return self._log_link

  @property
  def results_link(self):
    return self._results_link

  @property
  def log(self):
    if self._log is None:
      if not self.log_link:
        return None
      cache_file_path = os.path.join(
          self._master, self._builder_name,
          str(self._build_number), self._name, 'log')
      if os.path.exists(cache_file_path):
        # Load cache file, if it exists.
        with open(cache_file_path, 'rb') as cache_file:
          self._log = cache_file.read()
      else:
        # Otherwise, download it.
        logging.info('Retrieving ' + self.log_link)
        try:
          data = urllib2.urlopen(self.log_link).read()
        except (urllib2.HTTPError, socket.error):
          # Could be intermittent; try again.
          try:
            data = urllib2.urlopen(self.log_link).read()
          except (urllib2.HTTPError, socket.error):
            logging.error('Error retrieving URL ' + self.log_link)
            raise
        except:
          logging.error('Error retrieving URL ' + self.log_link)
          raise
        # And cache the newly downloaded data.
        cache_dir_path = os.path.dirname(cache_file_path)
        if not os.path.exists(cache_dir_path):
          os.makedirs(cache_dir_path)
        with open(cache_file_path, 'wb') as cache_file:
          cache_file.write(data)
        self._log = data
    return self._log

  @property
  def results(self):
    if self._results is None:
      if not self.results_link:
        return None
      cache_file_path = os.path.join(
          self._master, self._builder_name,
          str(self._build_number), self._name, 'results')
      if os.path.exists(cache_file_path):
        # Load cache file, if it exists.
        try:
          with open(cache_file_path, 'rb') as cache_file:
            self._results = cPickle.load(cache_file)
        except EOFError:
          os.remove(cache_file_path)
          return self.results
      else:
        # Otherwise, download it.
        logging.info('Retrieving ' + self.results_link)
        try:
          data = json.load(urllib2.urlopen(self.results_link))
        except (urllib2.HTTPError, socket.error):
          # Could be intermittent; try again.
          try:
            data = json.load(urllib2.urlopen(self.results_link))
          except (urllib2.HTTPError, socket.error):
            logging.error('Error retrieving URL ' + self.results_link)
            raise
        except ValueError:
          # If the build had an exception, the results might not be valid.
          data = None
        except:
          logging.error('Error retrieving URL ' + self.results_link)
          raise
        # And cache the newly downloaded data.
        cache_dir_path = os.path.dirname(cache_file_path)
        if not os.path.exists(cache_dir_path):
          os.makedirs(cache_dir_path)
        with open(cache_file_path, 'wb') as cache_file:
          cPickle.dump(data, cache_file, -1)
        self._results = data
    return self._results

  @property
  def stack_trace(self):
    if self._stack_trace is None:
      self._stack_trace = _ParseTraceFromLog(self.log)
    return self._stack_trace

  @property
  def chrome_stack_trace(self):
    raise NotImplementedError()