# Copyright 2014 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 logging
import os
import threading

from devil.android import device_blacklist
from devil.android import device_errors
from devil.android import device_utils
from devil.utils import parallelizer
from pylib import constants
from pylib.base import environment


def _DeviceCachePath(device):
  file_name = 'device_cache_%s.json' % device.adb.GetDeviceSerial()
  return os.path.join(constants.GetOutDirectory(), file_name)


class LocalDeviceEnvironment(environment.Environment):

  def __init__(self, args, _error_func):
    super(LocalDeviceEnvironment, self).__init__()
    self._blacklist = (device_blacklist.Blacklist(args.blacklist_file)
                       if args.blacklist_file
                       else None)
    self._device_serial = args.test_device
    self._devices_lock = threading.Lock()
    self._devices = []
    self._max_tries = 1 + args.num_retries
    self._tool_name = args.tool
    self._enable_device_cache = args.enable_device_cache
    self._incremental_install = args.incremental_install
    self._concurrent_adb = args.enable_concurrent_adb

  #override
  def SetUp(self):
    available_devices = device_utils.DeviceUtils.HealthyDevices(
        self._blacklist, enable_device_files_cache=self._enable_device_cache)
    if not available_devices:
      raise device_errors.NoDevicesError
    if self._device_serial:
      self._devices = [d for d in available_devices
                       if d.adb.GetDeviceSerial() == self._device_serial]
      if not self._devices:
        raise device_errors.DeviceUnreachableError(
            'Could not find device %r' % self._device_serial)
    else:
      self._devices = available_devices

    if self._enable_device_cache:
      for d in self._devices:
        cache_path = _DeviceCachePath(d)
        if os.path.exists(cache_path):
          logging.info('Using device cache: %s', cache_path)
          with open(cache_path) as f:
            d.LoadCacheData(f.read())
          os.unlink(cache_path)

  @property
  def devices(self):
    if not self._devices:
      raise device_errors.NoDevicesError()
    return self._devices

  @property
  def concurrent_adb(self):
    return self._concurrent_adb

  @property
  def incremental_install(self):
    return self._incremental_install

  @property
  def parallel_devices(self):
    return parallelizer.SyncParallelizer(self.devices)

  @property
  def max_tries(self):
    return self._max_tries

  @property
  def tool(self):
    return self._tool_name

  #override
  def TearDown(self):
    # Write the cache even when not using it so that it will be ready the first
    # time that it is enabled. Writing it every time is also necessary so that
    # an invalid cache can be flushed just by disabling it for one run.
    for d in self._devices:
      cache_path = _DeviceCachePath(d)
      with open(cache_path, 'w') as f:
        f.write(d.DumpCacheData())
        logging.info('Wrote device cache: %s', cache_path)

  def BlacklistDevice(self, device, reason='local_device_failure'):
    if not self._blacklist:
      logging.warning(
          'Attempted to blacklist %s, but no blacklist was provided.',
          str(device))
      return

    device_serial = device.adb.GetDeviceSerial()
    self._blacklist.Extend([device_serial], reason=reason)
    with self._devices_lock:
      self._devices = [d for d in self._devices if str(d) != device_serial]