# Copyright 2018 - 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.
r"""Instance class.

Define the instance class used to hold details about an AVD instance.

The instance class will hold details about AVD instances (remote/local) used to
enable users to understand what instances they've created. This will be leveraged
for the list, delete, and reconnect commands.

The details include:
- instance name (for remote instances)
- creation date/instance duration
- instance image details (branch/target/build id)
- and more!
"""

import collections
import logging
import re
import subprocess

from acloud.internal import constants

logger = logging.getLogger(__name__)

_COMMAND_PS = ["ps", "aux"]
_RE_GROUP_ADB = "local_adb_port"
_RE_GROUP_VNC = "local_vnc_port"
_RE_SSH_TUNNEL_PATTERN = (r"((.*\s*-L\s)(?P<%s>\d+):127.0.0.1:%s)"
                          r"((.*\s*-L\s)(?P<%s>\d+):127.0.0.1:%s)"
                          r"(.+%s)")

_COMMAND_PS_LAUNCH_CVD = ["ps", "-eo", "lstart,cmd"]
_RE_LAUNCH_CVD = re.compile(r"(?P<date_str>^[^/]+)(.*launch_cvd --daemon )+"
                            r"((.*\s*-cpus\s)(?P<cpu>\d+))?"
                            r"((.*\s*-x_res\s)(?P<x_res>\d+))?"
                            r"((.*\s*-y_res\s)(?P<y_res>\d+))?"
                            r"((.*\s*-dpi\s)(?P<dpi>\d+))?"
                            r"((.*\s*-memory_mb\s)(?P<memory>\d+))?"
                            r"((.*\s*-blank_data_image_mb\s)(?P<disk>\d+))?")
_FULL_NAME_STRING = "device serial: %(device_serial)s (%(instance_name)s)"
ForwardedPorts = collections.namedtuple("ForwardedPorts",
                                        [constants.VNC_PORT, constants.ADB_PORT])

class Instance(object):
    """Class to store data of instance."""

    def __init__(self):
        self._name = None
        self._fullname = None
        self._status = None
        self._display = None  # Resolution and dpi
        self._ip = None
        self._adb_port = None  # adb port which is forwarding to remote
        self._vnc_port = None  # vnc port which is forwarding to remote
        self._is_connected = None  # True if ssh tunnel is still connected
        self._createtime = None
        self._avd_type = None
        self._avd_flavor = None
        self._is_local = None  # True if this is a local instance

    def __repr__(self):
        """Let's make it easy to see what this class is holding."""
        indent = " " * 3
        representation = []
        representation.append(" name: %s" % self._name)
        representation.append("%s IP: %s" % (indent, self._ip))
        representation.append("%s create time: %s" %
                              (indent, self._createtime))
        representation.append("%s status: %s" %
                              (indent, self._status))

        if self._adb_port:
            representation.append("%s adb serial: 127.0.0.1:%s" %
                                  (indent, self._adb_port))
        else:
            representation.append("%s adb serial: disconnected" % indent)

            representation.append("%s avd type: %s" %
                                  (indent, self._avd_type))
            representation.append("%s display: %s" %
                                  (indent, self._display))

        return "\n".join(representation)

    @property
    def name(self):
        """Return the instance name."""
        return self._name

    @property
    def fullname(self):
        """Return the instance full name."""
        return self._fullname

    @property
    def ip(self):
        """Return the ip."""
        return self._ip

    @property
    def status(self):
        """Return status."""
        return self._status

    @property
    def display(self):
        """Return display."""
        return self._display

    @property
    def forwarding_adb_port(self):
        """Return the adb port."""
        return self._adb_port

    @property
    def forwarding_vnc_port(self):
        """Return the vnc port."""
        return self._vnc_port

    @property
    def is_connected(self):
        """Return the connect status."""
        return self._is_connected

    @property
    def createtime(self):
        """Return create time."""
        return self._createtime

    @property
    def avd_type(self):
        """Return avd_type."""
        return self._avd_type

    @property
    def avd_flavor(self):
        """Return avd_flavor."""
        return self._avd_flavor

    @property
    def islocal(self):
        """Return if it is a local instance."""
        return self._is_local


class LocalInstance(Instance):
    """Class to store data of local instance."""

    # pylint: disable=protected-access
    def __new__(cls):
        """Initialize a localInstance object.

        Gather local instance information from launch_cvd process.

        returns:
            Instance object if launch_cvd process is found otherwise return None.
        """
        process_output = subprocess.check_output(_COMMAND_PS_LAUNCH_CVD)
        for line in process_output.splitlines():
            match = _RE_LAUNCH_CVD.match(line)
            if match:
                local_instance = Instance()
                x_res = match.group("x_res")
                y_res = match.group("y_res")
                dpi = match.group("dpi")
                date_str = match.group("date_str").strip()
                local_instance._name = constants.LOCAL_INS_NAME
                local_instance._fullname = (_FULL_NAME_STRING %
                                            {"device_serial": "127.0.0.1:%d" %
                                                              constants.DEFAULT_ADB_PORT,
                                             "instance_name": local_instance._name})
                local_instance._createtime = date_str
                local_instance._avd_type = constants.TYPE_CF
                local_instance._ip = "127.0.0.1"
                local_instance._status = constants.INS_STATUS_RUNNING
                local_instance._adb_port = constants.DEFAULT_ADB_PORT
                local_instance._vnc_port = constants.DEFAULT_VNC_PORT
                local_instance._display = ("%sx%s (%s)" % (x_res, y_res, dpi))
                local_instance._is_local = True
                return local_instance
        return None


class RemoteInstance(Instance):
    """Class to store data of remote instance."""

    def __init__(self, gce_instance):
        """Process the args into class vars.

        RemoteInstace initialized by gce dict object.
        Reference:
        https://cloud.google.com/compute/docs/reference/rest/v1/instances/get

        Args:
            gce_instance: dict object queried from gce.
        """
        super(RemoteInstance, self).__init__()
        self._ProcessGceInstance(gce_instance)
        self._is_local = False

    def _ProcessGceInstance(self, gce_instance):
        """Parse the required data from gce_instance to local variables.

        We also gather more details on client side including the forwarding adb port
        and vnc port which will be used to determine the status of connection.

        Args:
           gce_instance: dict object queried from gce.
        """
        self._name = gce_instance.get(constants.INS_KEY_NAME)

        # TODO(b/119291750): calculate the elapsed time since instance has been created.
        self._createtime = gce_instance.get(constants.INS_KEY_CREATETIME)
        self._status = gce_instance.get(constants.INS_KEY_STATUS)

        ip = None
        for network_interface in gce_instance.get("networkInterfaces"):
            for access_config in network_interface.get("accessConfigs"):
                ip = access_config.get("natIP")

        # Find ssl tunnel info.
        if ip:
            forwarded_ports = self._GetAdbVncPortFromSSHTunnel(ip)
            self._ip = ip
            self._adb_port = forwarded_ports.adb_port
            self._vnc_port = forwarded_ports.vnc_port
            if self._adb_port:
                self._is_connected = True
                self._fullname = (_FULL_NAME_STRING %
                                  {"device_serial": "127.0.0.1:%d" % self._adb_port,
                                   "instance_name": self._name})
            else:
                self._is_connected = False
                self._fullname = (_FULL_NAME_STRING %
                                  {"device_serial": "not connected",
                                   "instance_name": self._name})

        # Find avd type from labels
        labels = gce_instance.get("labels")
        self._avd_type = labels[constants.LABEL_TYPE]
        self._avd_flavor = labels[constants.LABEL_FLAVOR]

        # Get display information.
        for metadata in gce_instance.get("metadata", {}).get("items", []):
            if metadata["key"] == constants.INS_KEY_DISPLAY:
                self._display = metadata["value"]
                break

    @staticmethod
    def _GetAdbVncPortFromSSHTunnel(ip):
        """Get forwarding adb and vnc port from ssh tunnel.

        Args:
            ip: String, ip address.

        Returns:
            NamedTuple ForwardedPorts(vnc_port, adb_port) holding the ports
            used in the ssh forwarded call. Both fields are integers.
        """
        process_output = subprocess.check_output(_COMMAND_PS)
        re_pattern = re.compile(_RE_SSH_TUNNEL_PATTERN %
                                (_RE_GROUP_VNC, constants.DEFAULT_VNC_PORT,
                                 _RE_GROUP_ADB, constants.DEFAULT_ADB_PORT, ip))

        adb_port = None
        vnc_port = None
        for line in process_output.splitlines():
            match = re_pattern.match(line)
            if match:
                adb_port = int(match.group(_RE_GROUP_ADB))
                vnc_port = int(match.group(_RE_GROUP_VNC))
                break

        logger.debug(("grathering detail for ssh tunnel. "
                      "IP:%s, forwarding (adb:%d, vnc:%d)"), ip, adb_port,
                     vnc_port)

        return ForwardedPorts(vnc_port=vnc_port, adb_port=adb_port)