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

import logging
import os
import remote_cmd
import subprocess
import sys
import tempfile
import time

_SHUTDOWN_CMD = ['dm', 'poweroff']
_ATTACH_MAX_RETRIES = 10
_ATTACH_RETRY_INTERVAL = 1


class FuchsiaTargetException(Exception):
  def __init__(self, message):
    super(FuchsiaTargetException, self).__init__(message)


class Target(object):
  """Base class representing a Fuchsia deployment target."""

  def __init__(self, output_dir, target_cpu):
    self._output_dir = output_dir
    self._started = False
    self._dry_run = False
    self._target_cpu = target_cpu

  # Functions used by the Python context manager for teardown.
  def __enter__(self):
    return self
  def __exit__(self, exc_type, exc_val, exc_tb):
    return self

  def Start(self):
    """Handles the instantiation and connection process for the Fuchsia
    target instance."""

    pass

  def IsStarted(self):
    """Returns True if the Fuchsia target instance is ready to accept
    commands."""

    return self._started

  def IsNewInstance(self):
    """Returns True if the connected target instance is newly provisioned."""

    return True

  def RunCommandPiped(self, command, **kwargs):
    """Starts a remote command and immediately returns a Popen object for the
    command. The caller may interact with the streams, inspect the status code,
    wait on command termination, etc.

    command: A list of strings representing the command and arguments.
    kwargs: A dictionary of parameters to be passed to subprocess.Popen().
            The parameters can be used to override stdin and stdout, for
            example.

    Returns: a Popen object.

    Note: method does not block."""

    self._AssertIsStarted()
    logging.debug('running (non-blocking) \'%s\'.' % ' '.join(command))
    host, port = self._GetEndpoint()
    return remote_cmd.RunPipedSsh(self._GetSshConfigPath(), host, port, command,
                                  **kwargs)

  def RunCommand(self, command, silent=False):
    """Executes a remote command and waits for it to finish executing.

    Returns the exit code of the command."""

    self._AssertIsStarted()
    logging.debug('running \'%s\'.' % ' '.join(command))
    host, port = self._GetEndpoint()
    return remote_cmd.RunSsh(self._GetSshConfigPath(), host, port, command,
                             silent)

  def PutFile(self, source, dest, recursive=False):
    """Copies a file from the local filesystem to the target filesystem.

    source: The path of the file being copied.
    dest: The path on the remote filesystem which will be copied to.
    recursive: If true, performs a recursive copy."""

    assert type(source) is str
    self.PutFiles([source], dest, recursive)

  def PutFiles(self, sources, dest, recursive=False):
    """Copies files from the local filesystem to the target filesystem.

    sources: List of local file paths to copy from, or a single path.
    dest: The path on the remote filesystem which will be copied to.
    recursive: If true, performs a recursive copy."""

    assert type(sources) is tuple or type(sources) is list
    self._AssertIsStarted()
    host, port = self._GetEndpoint()
    logging.debug('copy local:%s => remote:%s' % (sources, dest))
    command = remote_cmd.RunScp(self._GetSshConfigPath(), host, port,
                                sources, dest, remote_cmd.COPY_TO_TARGET,
                                recursive)

  def GetFile(self, source, dest):
    """Copies a file from the target filesystem to the local filesystem.

    source: The path of the file being copied.
    dest: The path on the local filesystem which will be copied to."""
    assert type(source) is str
    self.GetFiles([source], dest)

  def GetFiles(self, sources, dest):
    """Copies files from the target filesystem to the local filesystem.

    sources: List of remote file paths to copy.
    dest: The path on the local filesystem which will be copied to."""
    assert type(sources) is tuple or type(sources) is list
    self._AssertIsStarted()
    host, port = self._GetEndpoint()
    logging.debug('copy remote:%s => local:%s' % (sources, dest))
    return remote_cmd.RunScp(self._GetSshConfigPath(), host, port,
                             sources, dest, remote_cmd.COPY_FROM_TARGET)

  def _GetEndpoint(self):
    """Returns a (host, port) tuple for the SSH connection to the target."""
    raise NotImplementedError

  def _GetTargetSdkArch(self):
    """Returns the Fuchsia SDK architecture name for the target CPU."""
    if self._target_cpu == 'arm64':
      return 'aarch64'
    elif self._target_cpu == 'x64':
      return 'x86_64'
    raise FuchsiaTargetException('Unknown target_cpu:' + self._target_cpu)

  def _AssertIsStarted(self):
    assert self.IsStarted()

  def _WaitUntilReady(self, retries=_ATTACH_MAX_RETRIES):
    logging.info('Connecting to Fuchsia using SSH.')
    for _ in xrange(retries+1):
      host, port = self._GetEndpoint()
      if remote_cmd.RunSsh(self._GetSshConfigPath(), host, port, ['true'],
                           True) == 0:
        logging.info('Connected!')
        self._started = True
        return True
      time.sleep(_ATTACH_RETRY_INTERVAL)
    logging.error('Timeout limit reached.')
    raise FuchsiaTargetException('Couldn\'t connect using SSH.')

  def _GetSshConfigPath(self, path):
    raise NotImplementedError

  def _GetTargetSdkArch(self):
    """Returns the Fuchsia SDK architecture name for the target CPU."""
    if self._target_cpu == 'arm64':
      return 'aarch64'
    elif self._target_cpu == 'x64':
      return 'x86_64'
    raise Exception('Unknown target_cpu %s:' % self._target_cpu)