# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

from ... parser.modeling import context
from ... modeling import models, functions
from ... utils import formatting
from .. import execution_plugin
from .. import decorators
from . import common


class Artifact(common.InstanceHandlerBase):

    def coerce(self, **kwargs):
        self._topology.coerce(self._model.properties, **kwargs)

    def validate(self, **kwargs):
        self._topology.validate(self._model.properties, **kwargs)

    def dump(self, out_stream):
        with out_stream.indent():
            out_stream.write(out_stream.node_style(self._model.name))
            out_stream.write(out_stream.meta_style(self._model.description))
            with out_stream.indent():
                out_stream.write('Artifact type: {0}'.format(out_stream.type_style(
                    self._model.type.name)))
                out_stream.write('Source path: {0}'.format(
                    out_stream.literal_style(self._model.source_path)))
                if self._model.target_path is not None:
                    out_stream.write('Target path: {0}'.format(
                        out_stream.literal_style(self._model.target_path)))
                if self._model.repository_url is not None:
                    out_stream.write('Repository URL: {0}'.format(
                        out_stream.literal_style(self._model.repository_url)))
                if self._model.repository_credential:
                    out_stream.write('Repository credential: {0}'.format(
                        out_stream.literal_style(self._model.repository_credential)))
                self._topology.dump(self._model.properties, out_stream, title='Properties')


class Capability(common.InstanceHandlerBase):
    def coerce(self, **kwargs):
        self._topology.coerce(self._model.properties, **kwargs)

    def validate(self, **kwargs):
        self._topology.validate(self._model.properties, **kwargs)

    def dump(self, out_stream):
        out_stream.write(out_stream.node_style(self._model.name))
        with out_stream.indent():
            out_stream.write('Type: {0}'.format(out_stream.type_style(self._model.type.name)))
            out_stream.write('Occurrences: {0:d} ({1:d}{2})'.format(
                self._model.occurrences,
                self._model.min_occurrences or 0,
                ' to {0:d}'.format(self._model.max_occurrences)
                if self._model.max_occurrences is not None
                else ' or more'))
            self._topology.dump(self._model.properties, out_stream, title='Properties')


class Group(common.ActorHandlerBase):

    def coerce(self, **kwargs):
        self._coerce(self._model.properties, self._model.interfaces, **kwargs)

    def validate(self, **kwargs):
        self._validate(self._model.properties,
                       self._model.interfaces,
                       **kwargs)

    def dump(self, out_stream):
        out_stream.write('Group: {0}'.format(out_stream.node_style(self._model.name)))
        with out_stream.indent():
            out_stream.write('Type: {0}'.format(out_stream.type_style(self._model.type.name)))
            self._topology.dump(self._model.properties, out_stream, title='Properties')
            self._topology.dump(self._model.interfaces, out_stream, title='Interfaces')
            if self._model.nodes:
                out_stream.write('Member nodes:')
                with out_stream.indent():
                    for node in self._model.nodes:
                        out_stream.write(out_stream.node_style(node.name))

    def configure_operations(self):
        for interface in self._model.interfaces.values():
            self._topology.configure_operations(interface)


class Interface(common.ActorHandlerBase):
    def coerce(self, **kwargs):
        self._coerce(self._model.inputs, self._model.operations, **kwargs)

    def validate(self, **kwargs):
        self._validate(self._model.inputs,
                       self._model.operations,
                       **kwargs)

    def dump(self, out_stream):
        out_stream.write(out_stream.node_style(self._model.name))
        if self._model.description:
            out_stream.write(out_stream.meta_style(self._model.description))
        with out_stream.indent():
            out_stream.write('Interface type: {0}'.format(
                out_stream.type_style(self._model.type.name)))
            self._topology.dump(self._model.inputs, out_stream, title='Inputs')
            self._topology.dump(self._model.operations, out_stream, title='Operations')

    def configure_operations(self):
        for operation in self._model.operations.values():
            self._topology.configure_operations(operation)


class Node(common.ActorHandlerBase):
    def coerce(self, **kwargs):
        self._coerce(self._model.properties,
                     self._model.attributes,
                     self._model.interfaces,
                     self._model.artifacts,
                     self._model.capabilities,
                     self._model.outbound_relationships,
                     **kwargs)

    def validate(self, **kwargs):
        if len(self._model.name) > context.ID_MAX_LENGTH:
            self._topology.report(
                '"{0}" has an ID longer than the limit of {1:d} characters: {2:d}'.format(
                    self._model.name, context.ID_MAX_LENGTH, len(self._model.name)),
                level=self._topology.Issue.BETWEEN_INSTANCES)

        self._validate(self._model.properties,
                       self._model.attributes,
                       self._model.interfaces,
                       self._model.artifacts,
                       self._model.capabilities,
                       self._model.outbound_relationships)

    def dump(self, out_stream):
        out_stream.write('Node: {0}'.format(out_stream.node_style(self._model.name)))
        with out_stream.indent():
            out_stream.write('Type: {0}'.format(out_stream.type_style(self._model.type.name)))
            out_stream.write('Template: {0}'.format(
                out_stream.node_style(self._model.node_template.name)))
            self._topology.dump(self._model.properties, out_stream, title='Properties')
            self._topology.dump(self._model.attributes, out_stream, title='Attributes')
            self._topology.dump(self._model.interfaces, out_stream, title='Interfaces')
            self._topology.dump(self._model.artifacts, out_stream, title='Artifacts')
            self._topology.dump(self._model.capabilities, out_stream, title='Capabilities')
            self._topology.dump(self._model.outbound_relationships, out_stream,
                                title='Relationships')

    def configure_operations(self):
        for interface in self._model.interfaces.values():
            self._topology.configure_operations(interface)
        for relationship in self._model.outbound_relationships:
            self._topology.configure_operations(relationship)

    def validate_capabilities(self):
        satisfied = False
        for capability in self._model.capabilities.itervalues():
            if not capability.has_enough_relationships:
                self._topology.report(
                    'capability "{0}" of node "{1}" requires at least {2:d} '
                    'relationships but has {3:d}'.format(capability.name,
                                                         self._model.name,
                                                         capability.min_occurrences,
                                                         capability.occurrences),
                    level=self._topology.Issue.BETWEEN_INSTANCES)
                satisfied = False
        return satisfied

    def satisfy_requirements(self):
        satisfied = True
        for requirement_template in self._model.node_template.requirement_templates:

            # Since we try and satisfy requirements, which are node template bound, and use that
            # information in the creation of the relationship, Some requirements may have been
            # satisfied by a previous run on that node template.
            # The entire mechanism of satisfying requirements needs to be refactored.
            if any(rel.requirement_template == requirement_template
                   for rel in self._model.outbound_relationships):
                continue

            # Find target template
            target_node_template, target_node_capability = self._find_target(requirement_template)
            if target_node_template is not None:
                satisfied = self._satisfy_capability(
                    target_node_capability, target_node_template, requirement_template)
            else:
                self._topology.report('requirement "{0}" of node "{1}" has no target node template'.
                                      format(requirement_template.name, self._model.name),
                                      level=self._topology.Issue.BETWEEN_INSTANCES)
                satisfied = False
        return satisfied

    def _satisfy_capability(self, target_node_capability, target_node_template,
                            requirement_template):
        # Find target nodes
        target_nodes = target_node_template.nodes
        if target_nodes:
            target_node = None
            target_capability = None

            if target_node_capability is not None:
                # Relate to the first target node that has capacity
                for node in target_nodes:
                    a_target_capability = node.capabilities.get(target_node_capability.name)
                    if a_target_capability.relate():
                        target_node = node
                        target_capability = a_target_capability
                        break
            else:
                # Use first target node
                target_node = target_nodes[0]

            if target_node is not None:
                if requirement_template.relationship_template is not None:
                    relationship_model = self._topology.instantiate(
                        requirement_template.relationship_template)
                else:
                    relationship_model = models.Relationship()
                relationship_model.name = requirement_template.name
                relationship_model.requirement_template = requirement_template
                relationship_model.target_node = target_node
                relationship_model.target_capability = target_capability
                self._model.outbound_relationships.append(relationship_model)
                return True
            else:
                self._topology.report(
                    'requirement "{0}" of node "{1}" targets node '
                    'template "{2}" but its instantiated nodes do not '
                    'have enough capacity'.format(
                        requirement_template.name, self._model.name, target_node_template.name),
                    level=self._topology.Issue.BETWEEN_INSTANCES)
                return False
        else:
            self._topology.report(
                'requirement "{0}" of node "{1}" targets node template '
                '"{2}" but it has no instantiated nodes'.format(
                    requirement_template.name, self._model.name, target_node_template.name),
                level=self._topology.Issue.BETWEEN_INSTANCES)
            return False

    def _find_target(self, requirement_template):
        # We might already have a specific node template from the requirement template, so
        # we'll just verify it
        if requirement_template.target_node_template is not None:
            if not self._model.node_template.is_target_node_template_valid(
                    requirement_template.target_node_template):
                self._topology.report(
                    'requirement "{0}" of node template "{1}" is for node '
                    'template "{2}" but it does not match constraints'.format(
                        requirement_template.name,
                        requirement_template.target_node_template.name,
                        self._model.node_template.name),
                    level=self._topology.Issue.BETWEEN_TYPES)
            if (requirement_template.target_capability_type is not None or
                    requirement_template.target_capability_name is not None):
                target_node_capability = self._get_capability(requirement_template)
                if target_node_capability is None:
                    return None, None
            else:
                target_node_capability = None

            return requirement_template.target_node_template, target_node_capability

        # Find first node that matches the type
        elif requirement_template.target_node_type is not None:
            for target_node_template in \
                    self._model.node_template.service_template.node_templates.itervalues():
                if requirement_template.target_node_type.get_descendant(
                        target_node_template.type.name) is None:
                    continue

                if not self._model.node_template.is_target_node_template_valid(
                        target_node_template):
                    continue

                target_node_capability = self._get_capability(requirement_template,
                                                              target_node_template)

                if target_node_capability is None:
                    continue

                return target_node_template, target_node_capability

        # Find the first node which has a capability of the required type
        elif requirement_template.target_capability_type is not None:
            for target_node_template in \
                    self._model.node_template.service_template.node_templates.itervalues():
                target_node_capability = \
                    self._get_capability(requirement_template, target_node_template)
                if target_node_capability:
                    return target_node_template, target_node_capability

        return None, None

    def _get_capability(self, requirement_template, target_node_template=None):
        target_node_template = target_node_template or requirement_template.target_node_template

        for capability_template in target_node_template.capability_templates.values():
            if self._satisfies_requirement(
                    capability_template, requirement_template, target_node_template):
                return capability_template

        return None

    def _satisfies_requirement(
            self, capability_template, requirement_template, target_node_template):
        # Do we match the required capability type?
        if (requirement_template.target_capability_type and
                requirement_template.target_capability_type.get_descendant(
                    capability_template.type.name) is None):
            return False

        # Are we in valid_source_node_types?
        if capability_template.valid_source_node_types:
            for valid_source_node_type in capability_template.valid_source_node_types:
                if valid_source_node_type.get_descendant(
                        self._model.node_template.type.name) is None:
                    return False

        # Apply requirement constraints
        if requirement_template.target_node_template_constraints:
            for node_template_constraint in requirement_template.target_node_template_constraints:
                if not node_template_constraint.matches(
                        self._model.node_template, target_node_template):
                    return False

        return True


class Operation(common.ActorHandlerBase):
    def coerce(self, **kwargs):
        self._coerce(self._model.inputs,
                     self._model.configurations,
                     self._model.arguments,
                     **kwargs)

    def validate(self, **kwargs):
        self._validate(self._model.inputs,
                       self._model.configurations,
                       self._model.arguments,
                       **kwargs)

    def dump(self, out_stream):
        out_stream.write(out_stream.node_style(self._model.name))
        if self._model.description:
            out_stream.write(out_stream.meta_style(self._model.description))
        with out_stream.indent():
            if self._model.implementation is not None:
                out_stream.write('Implementation: {0}'.format(
                    out_stream.literal_style(self._model.implementation)))
            if self._model.dependencies:
                out_stream.write(
                    'Dependencies: {0}'.format(', '.join((str(out_stream.literal_style(v))
                                                          for v in self._model.dependencies))))
            self._topology.dump(self._model.inputs, out_stream, title='Inputs')
            if self._model.executor is not None:
                out_stream.write('Executor: {0}'.format(out_stream.literal_style(
                    self._model.executor)))
            if self._model.max_attempts is not None:
                out_stream.write('Max attempts: {0}'.format(out_stream.literal_style(
                    self._model.max_attempts)))
            if self._model.retry_interval is not None:
                out_stream.write('Retry interval: {0}'.format(
                    out_stream.literal_style(self._model.retry_interval)))
            if self._model.plugin is not None:
                out_stream.write('Plugin: {0}'.format(
                    out_stream.literal_style(self._model.plugin.name)))
            self._topology.dump(self._model.configurations, out_stream, title='Configuration')
            if self._model.function is not None:
                out_stream.write('Function: {0}'.format(out_stream.literal_style(
                    self._model.function)))
            self._topology.dump(self._model.arguments, out_stream, title='Arguments')

    def configure_operations(self):
        if self._model.implementation is None and self._model.function is None:
            return

        if (self._model.interface is not None and
                self._model.plugin is None and
                self._model.function is None):
            # ("interface" is None for workflow operations, which do not currently use "plugin")
            # The default (None) plugin is the execution plugin
            execution_plugin.instantiation.configure_operation(self._model, self._topology)
        else:
            # In the future plugins may be able to add their own "configure_operation" hook that
            # can validate the configuration and otherwise create specially derived arguments. For
            # now, we just send all configuration parameters as arguments without validation.
            for key, conf in self._model.configurations.items():
                self._model.arguments[key] = self._topology.instantiate(conf.as_argument())

        if self._model.interface is not None:
            # Send all interface inputs as extra arguments
            # ("interface" is None for workflow operations)
            # Note that they will override existing arguments of the same names
            for key, input in self._model.interface.inputs.items():
                self._model.arguments[key] = self._topology.instantiate(input.as_argument())

        # Send all inputs as extra arguments
        # Note that they will override existing arguments of the same names
        for key, input in self._model.inputs.items():
            self._model.arguments[key] = self._topology.instantiate(input.as_argument())

        # Check for reserved arguments
        used_reserved_names = set(decorators.OPERATION_DECORATOR_RESERVED_ARGUMENTS).intersection(
            self._model.arguments.keys())
        if used_reserved_names:
            self._topology.report(
                'using reserved arguments in operation "{0}": {1}'.format(
                    self._model.name, formatting.string_list_as_string(used_reserved_names)),
                level=self._topology.Issue.EXTERNAL)


class Policy(common.InstanceHandlerBase):
    def coerce(self, **kwargs):
        self._topology.coerce(self._model.properties, **kwargs)

    def validate(self, **kwargs):
        self._topology.validate(self._model.properties, **kwargs)

    def dump(self, out_stream):
        out_stream.write('Policy: {0}'.format(out_stream.node_style(self._model.name)))
        with out_stream.indent():
            out_stream.write('Type: {0}'.format(out_stream.type_style(self._model.type.name)))
            self._topology.dump(self._model.properties, out_stream, title='Properties')
            if self._model.nodes:
                out_stream.write('Target nodes:')
                with out_stream.indent():
                    for node in self._model.nodes:
                        out_stream.write(out_stream.node_style(node.name))
            if self._model.groups:
                out_stream.write('Target groups:')
                with out_stream.indent():
                    for group in self._model.groups:
                        out_stream.write(out_stream.node_style(group.name))


class Relationship(common.ActorHandlerBase):
    def coerce(self, **kwargs):
        self._coerce(self._model.properties,
                     self._model.interfaces,
                     **kwargs)

    def validate(self, **kwargs):
        self._validate(self._model.properties,
                       self._model.interfaces,
                       **kwargs)

    def dump(self, out_stream):
        if self._model.name:
            out_stream.write('{0} ->'.format(out_stream.node_style(self._model.name)))
        else:
            out_stream.write('->')
        with out_stream.indent():
            out_stream.write('Node: {0}'.format(out_stream.node_style(
                self._model.target_node.name)))
            if self._model.target_capability:
                out_stream.write('Capability: {0}'.format(out_stream.node_style(
                    self._model.target_capability.name)))
            if self._model.type is not None:
                out_stream.write('Relationship type: {0}'.format(
                    out_stream.type_style(self._model.type.name)))
            if (self._model.relationship_template is not None and
                    self._model.relationship_template.name):
                out_stream.write('Relationship template: {0}'.format(
                    out_stream.node_style(self._model.relationship_template.name)))
            self._topology.dump(self._model.properties, out_stream, title='Properties')
            self._topology.dump(self._model.interfaces, out_stream, title='Interfaces')

    def configure_operations(self):
        for interface in self._model.interfaces.values():
            self._topology.configure_operations(interface)


class Service(common.ActorHandlerBase):
    def coerce(self, **kwargs):
        self._coerce(self._model.meta_data,
                     self._model.nodes,
                     self._model.groups,
                     self._model.policies,
                     self._model.substitution,
                     self._model.inputs,
                     self._model.outputs,
                     self._model.workflows,
                     **kwargs)

    def validate(self, **kwargs):
        self._validate(self._model.meta_data,
                       self._model.nodes,
                       self._model.groups,
                       self._model.policies,
                       self._model.substitution,
                       self._model.inputs,
                       self._model.outputs,
                       self._model.workflows,
                       **kwargs)

    def dump(self, out_stream):
        if self._model.description is not None:
            out_stream.write(out_stream.meta_style(self._model.description))
        self._topology.dump(self._model.meta_data, out_stream, title='Metadata')
        self._topology.dump(self._model.nodes, out_stream)
        self._topology.dump(self._model.groups, out_stream)
        self._topology.dump(self._model.policies, out_stream)
        self._topology.dump(self._model.substitution, out_stream)
        self._topology.dump(self._model.inputs, out_stream, title='Inputs')
        self._topology.dump(self._model.outputs, out_stream, title='Outputs')
        self._topology.dump(self._model.workflows, out_stream, title='Workflows')

    def configure_operations(self):
        for node in self._model.nodes.itervalues():
            self._topology.configure_operations(node)
        for group in self._model.groups.itervalues():
            self._topology.configure_operations(group)
        for operation in self._model.workflows.itervalues():
            self._topology.configure_operations(operation)

    def validate_capabilities(self):
        satisfied = True
        for node in self._model.nodes.values():
            if not self._topology.validate_capabilities(node):
                satisfied = False
        return satisfied

    def satisfy_requirements(self):
        return all(self._topology.satisfy_requirements(node)
                   for node in self._model.nodes.values())


class Substitution(common.InstanceHandlerBase):
    def coerce(self, **kwargs):
        self._topology.coerce(self._model.mappings, **kwargs)

    def validate(self, **kwargs):
        self._topology.validate(self._model.mappings, **kwargs)

    def dump(self, out_stream):
        out_stream.write('Substitution:')
        with out_stream.indent():
            out_stream.write('Node type: {0}'.format(out_stream.type_style(
                self._model.node_type.name)))
            self._topology.dump(self._model.mappings, out_stream, title='Mappings')


class SubstitutionMapping(common.InstanceHandlerBase):

    def coerce(self, **kwargs):
        pass

    def validate(self, **_):
        if (self._model.capability is None) and (self._model.requirement_template is None):
            self._topology.report(
                'mapping "{0}" refers to neither capability nor a requirement'
                ' in node: {1}'.format(
                    self._model.name, formatting.safe_repr(self._model.node_style.name)),
                level=self._topology.Issue.BETWEEN_TYPES)

    def dump(self, out_stream):
        if self._model.capability is not None:
            out_stream.write('{0} -> {1}.{2}'.format(
                out_stream.node_style(self._model.name),
                out_stream.node_style(self._model.capability.node.name),
                out_stream.node_style(self._model.capability.name)))
        else:
            out_stream.write('{0} -> {1}.{2}'.format(
                out_stream.node_style(self._model.name),
                out_stream.node_style(self._model.node.name),
                out_stream.node_style(self._model.requirement_template.name)))


class Metadata(common.InstanceHandlerBase):

    def dump(self, out_stream):
        out_stream.write('{0}: {1}'.format(
            out_stream.property_style(self._model.name),
            out_stream.literal_style(self._model.value)))

    def coerce(self, **_):
        pass

    def instantiate(self, instance_cls):
        return instance_cls(name=self._model.name, value=self._model.value)

    def validate(self):
        pass


class _Parameter(common.InstanceHandlerBase):

    def dump(self, out_stream):
        if self._model.type_name is not None:
            out_stream.write('{0}: {1} ({2})'.format(
                out_stream.property_style(self._model.name),
                out_stream.literal_style(formatting.as_raw(self._model.value)),
                out_stream.type_style(self._model.type_name)))
        else:
            out_stream.write('{0}: {1}'.format(
                out_stream.property_style(self._model.name),
                out_stream.literal_style(formatting.as_raw(self._model.value))))
        if self._model.description:
            out_stream.write(out_stream.meta_style(self._model.description))

    def instantiate(self, instance_cls, **kwargs):
        return instance_cls(
            name=self._model.name,                                                                  # pylint: disable=unexpected-keyword-arg
            type_name=self._model.type_name,
            _value=self._model._value,
            description=self._model.description
        )

    def validate(self):
        pass

    def coerce(self, report_issues):                                                                # pylint: disable=arguments-differ
        value = self._model._value
        if value is not None:
            evaluation = functions.evaluate(value, self._model, report_issues)
            if (evaluation is not None) and evaluation.final:
                # A final evaluation can safely replace the existing value
                self._model._value = evaluation.value


class Attribute(_Parameter):
    pass


class Input(_Parameter):
    pass


class Output(_Parameter):
    pass


class Argument(_Parameter):
    pass


class Property(_Parameter):
    pass


class Configuration(_Parameter):
    pass


class Type(common.InstanceHandlerBase):
    def coerce(self, **_):
        pass

    def dump(self, out_stream):
        if self._model.name:
            out_stream.write(out_stream.type_style(self._model.name))
        with out_stream.indent():
            for child in self._model.children:
                self._topology.dump(child, out_stream)

    def validate(self, **kwargs):
        pass