# Copyright (c) 2014 VMware, Inc.
# All Rights Reserved.
#
#    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.

import six

from nova import exception
from nova.i18n import _


class CpuDiagnostics(object):

    def __init__(self, time=0):
        """Create a new CpuDiagnostics object

        :param time: CPU Time in nano seconds (Integer)
        """
        self.time = time


class NicDiagnostics(object):

    def __init__(self, mac_address='00:00:00:00:00:00',
                 rx_octets=0, rx_errors=0, rx_drop=0, rx_packets=0,
                 tx_octets=0, tx_errors=0, tx_drop=0, tx_packets=0):
        """Create a new NicDiagnostics object

        :param mac_address: Mac address of the interface (String)
        :param rx_octets: Received octets (Integer)
        :param rx_errors: Received errors (Integer)
        :param rx_drop: Received packets dropped (Integer)
        :param rx_packets: Received packets (Integer)
        :param tx_octets: Transmitted Octets (Integer)
        :param tx_errors: Transmit errors (Integer)
        :param tx_drop: Transmit dropped packets (Integer)
        :param tx_packets: Transmit packets (Integer)
        """
        self.mac_address = mac_address
        self.rx_octets = rx_octets
        self.rx_errors = rx_errors
        self.rx_drop = rx_drop
        self.rx_packets = rx_packets
        self.tx_octets = tx_octets
        self.tx_errors = tx_errors
        self.tx_drop = tx_drop
        self.tx_packets = tx_packets


class DiskDiagnostics(object):

    def __init__(self, id='', read_bytes=0, read_requests=0,
                 write_bytes=0, write_requests=0, errors_count=0):
        """Create a new DiskDiagnostics object

        :param id: Disk ID (String)
        :param read_bytes: Disk reads in bytes(Integer)
        :param read_requests: Read requests (Integer)
        :param write_bytes: Disk writes in bytes (Integer)
        :param write_requests: Write requests (Integer)
        :param errors_count: Disk errors (Integer)
        """
        self.id = id
        self.read_bytes = read_bytes
        self.read_requests = read_requests
        self.write_bytes = write_bytes
        self.write_requests = write_requests
        self.errors_count = errors_count


class MemoryDiagnostics(object):

    def __init__(self, maximum=0, used=0):
        """Create a new MemoryDiagnostics object

        :param maximum: Amount of memory provisioned for the VM in MB (Integer)
        :param used: Amount of memory used by the VM in MB (Integer)
        """
        self.maximum = maximum
        self.used = used


class Diagnostics(object):

    # Version 1.0: Initial version
    version = '1.0'

    def __init__(self, state=None, driver=None, hypervisor_os=None,
                 uptime=0, cpu_details=None, nic_details=None,
                 disk_details=None, config_drive=False):
        """Create a new diagnostics object

        :param state: The current state of the VM. Example values are:
                      'pending', 'running', 'paused', 'shutdown', 'crashed',
                      'suspended' and 'building' (String)
        :param driver: A string denoting the driver on which the VM is running.
                       Examples may be: 'libvirt', 'xenapi', 'hyperv' and
                       'vmwareapi' (String)
        :param hypervisor_os: A string denoting the hypervisor OS (String)
        :param uptime: The amount of time in seconds that the VM has been
                       running (Integer)
        :param cpu_details: And array of CpuDiagnostics or None.
        :param nic_details: And array of NicDiagnostics or None.
        :param disk_details: And array of DiskDiagnostics or None.
        :param config_drive: Indicates if the config drive is supported on the
                             instance (Boolean)
        """

        self.state = state
        self.driver = driver
        self.hypervisor_os = hypervisor_os
        self.uptime = uptime
        self.config_drive = config_drive
        if cpu_details:
            self._validate_type(cpu_details, CpuDiagnostics, 'cpu_details')
            self.cpu_details = cpu_details
        else:
            self.cpu_details = []
        if nic_details:
            self._validate_type(nic_details, NicDiagnostics, 'nic_details')
            self.nic_details = nic_details
        else:
            self.nic_details = []
        if disk_details:
            self._validate_type(disk_details, DiskDiagnostics, 'disk_details')
            self.disk_details = disk_details
        else:
            self.disk_details = []
        self.memory_details = MemoryDiagnostics()

    def _validate_type(self, input, type, str_input):
        if not isinstance(input, list):
            reason = _("Invalid type for %s") % str_input
            raise exception.InvalidInput(reason=reason)
        for i in input:
            if not isinstance(i, type):
                reason = _("Invalid type for %s entry") % str_input
                raise exception.InvalidInput(reason=reason)

    def add_cpu(self, time=0):
        self.cpu_details.append(CpuDiagnostics(time=time))

    def add_nic(self, mac_address='00:00:00:00:00:00',
                rx_octets=0, rx_errors=0, rx_drop=0, rx_packets=0,
                tx_octets=0, tx_errors=0, tx_drop=0, tx_packets=0):
        self.nic_details.append(NicDiagnostics(mac_address=mac_address,
                                               rx_octets=rx_octets,
                                               rx_errors=rx_errors,
                                               rx_drop=rx_drop,
                                               rx_packets=rx_packets,
                                               tx_octets=tx_octets,
                                               tx_errors=tx_errors,
                                               tx_drop=tx_drop,
                                               tx_packets=tx_packets))

    def add_disk(self, id='', read_bytes=0, read_requests=0,
                 write_bytes=0, write_requests=0, errors_count=0):
        self.disk_details.append(DiskDiagnostics(id=id,
                                                 read_bytes=read_bytes,
                                                 read_requests=read_requests,
                                                 write_bytes=write_bytes,
                                                 write_requests=write_requests,
                                                 errors_count=errors_count))

    def serialize(self):
        s = {}
        for k, v in six.iteritems(self.__dict__):
            # Treat case of CpuDiagnostics, NicDiagnostics and
            # DiskDiagnostics - these are lists
            if isinstance(v, list):
                l = []
                for value in v:
                    l.append(value.__dict__)
                s[k] = l
            # Treat case of MemoryDiagnostics
            elif isinstance(v, MemoryDiagnostics):
                s[k] = v.__dict__
            else:
                s[k] = v
        s['version'] = self.version
        return s