# Copyright 2018 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.

"""Implements commands for running and interacting with Fuchsia on devices."""

import boot_data
import filecmp
import logging
import os
import subprocess
import sys
import target
import tempfile
import time
import uuid

from common import SDK_ROOT, EnsurePathExists

CONNECT_RETRY_COUNT = 20
CONNECT_RETRY_WAIT_SECS = 1

# Number of failed connection attempts before redirecting system logs to stdout.
CONNECT_RETRY_COUNT_BEFORE_LOGGING = 10

TARGET_HASH_FILE_PATH = '/data/.hash'

class DeviceTarget(target.Target):
  def __init__(self, output_dir, target_cpu, host=None, port=None,
               ssh_config=None, system_log_file=None):
    """output_dir: The directory which will contain the files that are
                   generated to support the deployment.
    target_cpu: The CPU architecture of the deployment target. Can be
                "x64" or "arm64".
    host: The address of the deployment target device.
    port: The port of the SSH service on the deployment target device.
    ssh_config: The path to SSH configuration data."""

    super(DeviceTarget, self).__init__(output_dir, target_cpu)

    self._port = 22
    self._auto = not ssh_config
    self._new_instance = True
    self._system_log_file = system_log_file
    self._loglistener = None

    if self._auto:
      boot_data.ProvisionSSH(output_dir)
      self._ssh_config_path = boot_data.GetSSHConfigPath(output_dir)
    else:
      self._ssh_config_path = os.path.expanduser(ssh_config)
      self._host = host
      if port:
        self._port = port
      self._new_instance = False

  def __exit__(self, exc_type, exc_val, exc_tb):
    if self._loglistener:
      self._loglistener.kill()

  def _SDKHashMatches(self):
    """Checks if /data/.hash on the device matches SDK_ROOT/.hash.

    Returns True if the files are identical, or False otherwise.
    """
    with tempfile.NamedTemporaryFile() as tmp:
      try:
        self.GetFile(TARGET_HASH_FILE_PATH, tmp.name)
      except subprocess.CalledProcessError:
        # If the file is unretrievable for whatever reason, assume mismatch.
        return False

      return filecmp.cmp(tmp.name, os.path.join(SDK_ROOT, '.hash'), False)

  def __Discover(self, node_name):
    """Returns the IP address and port of a Fuchsia instance discovered on
    the local area network. If |node_name| is None then the first discovered
    device is returned. """

    # TODO(crbug.com/929874): Use the nodename when it's respected by Zircon.
    dev_finder_path = os.path.join(SDK_ROOT, 'tools', 'dev_finder')
    command = [dev_finder_path, 'list']
    logging.debug(' '.join(command))
    proc = subprocess.Popen(command,
                            stdout=subprocess.PIPE,
                            stderr=open(os.devnull, 'w'))
    proc.wait()
    if proc.returncode == 0:
      entries = proc.stdout.readlines()
      host = entries[0].strip()

      if len(entries) > 1:
        logging.warn('Found more than one device on the network:')
        logging.warn(' , '.join(set(map(lambda x: x.strip(), entries))))
        logging.warn('Automatically using the first device in the list.')

      return host

    return None

  def Start(self):
    if self._auto:
      logging.debug('Starting automatic device deployment.')
      node_name = boot_data.GetNodeName(self._output_dir)
      self._host = self.__Discover(node_name)
      if self._host and self._WaitUntilReady(retries=0):
        if not self._SDKHashMatches():
          logging.info('SDK hash does not match, rebooting.')
          self.RunCommand(['dm', 'reboot'])
          self._started = False
        else:
          logging.info('Connected to an already booted device.')
          self._new_instance = False
          return

      self.__ProvisionDevice(node_name)

    else:
      if not self._host:
        self._host = self.__Discover(node_name=None)
        if not self._host:
          raise Exception('No Fuchsia devices found.')

      if not self._WaitUntilReady(retries=0):
        raise Exception('Could not conenct to %s' % self._host)

  def __ProvisionDevice(self, node_name):
    logging.info('Netbooting Fuchsia. ' +
                 'Please ensure that your device is in bootloader mode.')
    bootserver_path = os.path.join(SDK_ROOT, 'tools', 'bootserver')
    bootserver_command = [
        bootserver_path,
        '-1',
        '--fvm',
        EnsurePathExists(boot_data.GetTargetFile(self._GetTargetSdkArch(),
                                                 'fvm.sparse.blk')),
        EnsurePathExists(boot_data.GetBootImage(self._output_dir,
                                                self._GetTargetSdkArch()))]

    if self._GetTargetSdkArch() == 'x64':
      bootserver_command += [
          '--efi',
          EnsurePathExists(boot_data.GetTargetFile(self._GetTargetSdkArch(),
                                                   'local.esp.blk'))]

    bootserver_command += ['--']
    bootserver_command += boot_data.GetKernelArgs(self._output_dir)

    logging.debug(' '.join(bootserver_command))
    subprocess.check_call(bootserver_command)

    # Start loglistener to save system logs.
    if self._system_log_file:
      loglistener_path = os.path.join(SDK_ROOT, 'tools', 'loglistener')
      self._loglistener = subprocess.Popen(
          [loglistener_path, node_name],
          stdout=self._system_log_file,
          stderr=subprocess.STDOUT, stdin=open(os.devnull))

    logging.debug('Waiting for device to join network.')
    for retry in xrange(CONNECT_RETRY_COUNT):
      self._host = self.__Discover(node_name)
      if self._host:
        break
      time.sleep(CONNECT_RETRY_WAIT_SECS)
    if not self._host:
      raise Exception('Couldn\'t connect to device.')

    logging.debug('host=%s, port=%d' % (self._host, self._port))

    self._WaitUntilReady();

    # Update the target's hash to match the current tree's.
    self.PutFile(os.path.join(SDK_ROOT, '.hash'), TARGET_HASH_FILE_PATH)

  def IsNewInstance(self):
    return self._new_instance

  def _GetEndpoint(self):
    return (self._host, self._port)

  def _GetSshConfigPath(self):
    return self._ssh_config_path