##############################################################################
# Copyright (c) 2017 ZTE Corporation and others.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################
import os
import time

from oslo_config import cfg

from doctor_tests.identity_auth import get_identity_auth
from doctor_tests.identity_auth import get_session
from doctor_tests.os_clients import neutron_client
from doctor_tests.os_clients import nova_client

OPTS = [
    cfg.StrOpt('flavor',
               default='m1.tiny',
               help='the name of flavor',
               required=True),
    cfg.IntOpt('instance_count',
               default=os.environ.get('VM_COUNT', 1),
               help='the count of instance',
               required=True),
    cfg.StrOpt('instance_basename',
               default='doctor_vm',
               help='the base name of instance',
               required=True),
]


class Instance(object):

    def __init__(self, conf, log):
        self.conf = conf
        self.log = log
        self.auth = get_identity_auth(username=self.conf.doctor_user,
                                      password=self.conf.doctor_passwd,
                                      project=self.conf.doctor_project)
        self.nova = \
            nova_client(conf.nova_version,
                        get_session(auth=self.auth))
        self.neutron = neutron_client(get_session(auth=self.auth))
        self.servers = {}
        self.vm_names = []

    def create(self):
        self.log.info('instance create start......')

        # get flavor, image and network for vm boot
        flavors = {flavor.name: flavor for flavor in self.nova.flavors.list()}
        flavor = flavors.get(self.conf.flavor)
        image = self.nova.glance.find_image(self.conf.image_name)
        network = \
            self.neutron.list_networks(name=self.conf.net_name)['networks'][0]
        nics = {'net-id': network['id']}

        self.servers = \
            {getattr(server, 'name'): server
             for server in self.nova.servers.list()}
        for i in range(0, self.conf.instance_count):
            vm_name = "%s%d" % (self.conf.instance_basename, i)
            self.vm_names.append(vm_name)
            if vm_name not in self.servers:
                server = self.nova.servers.create(vm_name, image,
                                                  flavor, nics=[nics])
                self.servers[vm_name] = server
                time.sleep(0.1)

        self.log.info('instance create end......')

    def delete(self):
        self.log.info('instance delete start.......')

        for vm_name in self.vm_names:
            if vm_name in self.servers:
                self.nova.servers.delete(self.servers[vm_name])
                time.sleep(0.1)

        # check that all vms are deleted
        while self.nova.servers.list():
            time.sleep(0.1)
        self.servers.clear()
        del self.vm_names[:]

        self.log.info('instance delete end.......')

    def wait_for_vm_launch(self):
        self.log.info('wait for vm launch start......')

        wait_time = 60
        count = 0
        while count < wait_time:
            active_count = 0
            for vm_name in self.vm_names:
                server = self.nova.servers.get(self.servers[vm_name])
                server_status = getattr(server, 'status').lower()
                if 'active' == server_status:
                    active_count += 1
                elif 'error' == server_status:
                    raise Exception('vm launched with error state')
                else:
                    time.sleep(2)
                    count += 1
                    continue
            if active_count == self.conf.instance_count:
                self.log.info('wait for vm launch end......')
                return
            count += 1
            time.sleep(2)
        raise Exception('time out for vm launch')