from ZabbixJSON import listofdicts_to_zabbix_json


class VM(object):
    """
    Proxmox Virtual Machine API Parameters
    """
    instances = list()

    def __init__(self, node, name, status, uptime, diskread, diskwrite, memusage, pid, vmid, netin, netout, cpus,
                 template, disk, cpuusage, maxdisk, maxmem, url, **kwargs):
        self.__class__.instances.append(self)
        self.name = name
        self.node = node.name
        self.__statusstr = status
        self.status = 1 if self.__statusstr == "running" else 0
        self.uptime = uptime
        self.diskread = diskread
        self.diskwrite = diskwrite
        self.memusage = memusage
        self.pid = pid
        self.vmid = vmid
        self.netin = netin
        self.netout = netout
        self.cpus = cpus
        self.template = template
        self.disk = disk
        self.cpuusage = cpuusage
        self.maxdisk = maxdisk
        self.maxmem = maxmem
        self.__url = url

    def __repr__(self):
        return "<%s-%s:%s>" % (self.node, self.vmid, self.name)

    @classmethod
    def get_vmnames(cls, vmnode, **kwargs):
        """
        Get Virtual Machine Names for discovery
        :param vmnode: node name with to filter VMs by
        :param kwargs: used to accept command line parameters
        :return: list of dicts in [{'#VMNAME': "$name"}] format
        """
        name_vmlist = list()
        for c in cls.instances:
            try:
                if kwargs['name'] is None:
                    if c.node == vmnode.name:
                        name_vmlist.append({'#VMNAME': c.name})
                elif kwargs['name'] is not None and kwargs['listing'] is True:
                    if c.node == vmnode.name and c.name == kwargs['name']:
                        name_vmlist.append({'#VMNAME': c.name})
            except KeyError:
                return [c.name for c in cls.instances if c.node == vmnode.name]
        return name_vmlist

    def get_vminfo(self, parameter=None):
        """
        Get Virtual Machine data
        :param parameter: Specific VM stat e.g.: CPU Usage, use if you want to get one parameter for Zabbix
        :return: list od dicts with vm params
        """
        if parameter is not None:
            vm_params = self.__getattribute__(parameter)
            return vm_params
        else:
            vm_params = list()
            for param in vars(self):
                if not param.startswith('__'):
                    vm_params.append({'#' + param.upper(): self.__getattribute__(param)})
            return listofdicts_to_zabbix_json(vm_params)

    def get_diskvmlist(self):
        """
        Gets list of dicts blockdevices configured in VM for use in Zabbix Discovery
        :return: list of dicts blockdevices
        """
        blockdevices = list()
        try:
            for disk in self.det_blockstat.keys():
                blockdevices.append({'#DISKNAME': disk})
        except AttributeError:
            print "Could not find disks for machine "
        return blockdevices

    def get_diskvminfo(self, disk, parameter=None):
        """
        Gets VM blockdevice stats
        :param disk: disk name in vm
        :param parameter: if specified get specific param
        :return: list of dicts with params or just param value for specific element
        """
        if parameter is not None:
            for diskname, param in self.det_blockstat.items():
                if diskname == disk:
                    for p, v in param.iteritems():
                        if p == parameter:
                            return v
        else:
            disk_params = list()
            for diskname, param in self.det_blockstat.items():
                if diskname == disk:
                    disk_params.append(param)
            return listofdicts_to_zabbix_json(disk_params)