#    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 ironic_tempest_plugin.tests.scenario import baremetal_manager
from tempest import config
from tempest import test  # noqa

from ironic_inspector.test.inspector_tempest_plugin.tests import manager

CONF = config.CONF

ProvisionStates = baremetal_manager.BaremetalProvisionStates


class InspectorDiscoveryTest(manager.InspectorScenarioTest):
    @classmethod
    def skip_checks(cls):
        super(InspectorDiscoveryTest, cls).skip_checks()
        if not CONF.baremetal_introspection.auto_discovery_feature:
            msg = ("Please, provide a value for node_not_found_hook in "
                   "processing section of inspector.conf for enable "
                   "auto-discovery feature.")
            raise cls.skipException(msg)

    def setUp(self):
        super(InspectorDiscoveryTest, self).setUp()

        discovered_node = self._get_discovery_node()
        self.node_info = self._get_node_info(discovered_node)

        rule = self._generate_discovery_rule(self.node_info)

        self.rule_import_from_dict(rule)
        self.addCleanup(self.rule_purge)

    def _get_node_info(self, node_uuid):
        node = self.node_show(node_uuid)
        ports = self.node_port_list(node_uuid)
        node['port_macs'] = [port['address'] for port in ports]
        return node

    def _get_discovery_node(self):
        nodes = self.node_list()

        discovered_node = None
        for node in nodes:
            if (node['provision_state'] == ProvisionStates.AVAILABLE or
                    node['provision_state'] == ProvisionStates.ENROLL or
                    node['provision_state'] is ProvisionStates.NOSTATE):
                discovered_node = node['uuid']
                break

        self.assertIsNotNone(discovered_node)
        return discovered_node

    def _generate_discovery_rule(self, node):
        rule = dict()
        rule["description"] = "Node %s discovery rule" % node['name']
        rule["actions"] = [
            {"action": "set-attribute", "path": "/name",
             "value": "%s" % node['name']},
            {"action": "set-attribute", "path": "/driver",
             "value": "%s" % node['driver']},
        ]

        for key, value in node['driver_info'].items():
            rule["actions"].append(
                {"action": "set-attribute", "path": "/driver_info/%s" % key,
                 "value": "%s" % value})
        rule["conditions"] = [
            {"op": "eq", "field": "data://auto_discovered", "value": True}
        ]
        return rule

    def verify_node_introspection_data(self, node):
        data = self.introspection_data(node['uuid'])
        self.assertEqual(data['cpu_arch'],
                         self.flavor['properties']['cpu_arch'])
        self.assertEqual(int(data['memory_mb']),
                         int(self.flavor['ram']))
        self.assertEqual(int(data['cpus']), int(self.flavor['vcpus']))

    def verify_node_flavor(self, node):
        expected_cpus = self.flavor['vcpus']
        expected_memory_mb = self.flavor['ram']
        expected_cpu_arch = self.flavor['properties']['cpu_arch']
        disk_size = self.flavor['disk']
        ephemeral_size = self.flavor['OS-FLV-EXT-DATA:ephemeral']
        expected_local_gb = disk_size + ephemeral_size

        self.assertEqual(expected_cpus,
                         int(node['properties']['cpus']))
        self.assertEqual(expected_memory_mb,
                         int(node['properties']['memory_mb']))
        self.assertEqual(expected_local_gb,
                         int(node['properties']['local_gb']))
        self.assertEqual(expected_cpu_arch,
                         node['properties']['cpu_arch'])

    def verify_node_driver_info(self, node_info, inspected_node):
        for key in node_info['driver_info']:
            self.assertEqual(six.text_type(node_info['driver_info'][key]),
                             inspected_node['driver_info'].get(key))

    @test.idempotent_id('dd3abe5e-0d23-488d-bb4e-344cdeff7dcb')
    @test.services('baremetal', 'compute')
    def test_berametal_auto_discovery(self):
        """This test case follows this set of operations:

           * Choose appropriate node, based on provision state;
           * Get node info;
           * Generate discovery rule;
           * Delete discovered node from ironic;
           * Start baremetal vm via virsh;
           * Wating for node introspection;
           * Verify introspected node.
        """
        # NOTE(aarefiev): workaround for infra, 'tempest' user doesn't
        # have virsh privileges, so lets power on the node via ironic
        # and then delete it. Because of node is blacklisted in inspector
        # we can't just power on it, therefor start introspection is used
        # to whitelist discovered node first.
        self.baremetal_client.set_node_provision_state(
            self.node_info['uuid'], 'manage')
        self.introspection_start(self.node_info['uuid'])
        self.wait_power_state(
            self.node_info['uuid'],
            baremetal_manager.BaremetalPowerStates.POWER_ON)
        self.node_delete(self.node_info['uuid'])

        self.wait_for_node(self.node_info['name'])

        inspected_node = self.node_show(self.node_info['name'])
        self.verify_node_flavor(inspected_node)
        self.verify_node_introspection_data(inspected_node)
        self.verify_node_driver_info(self.node_info, inspected_node)
