# 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.

"""
ARIA modeling service template module
"""

# pylint: disable=too-many-lines, no-self-argument, no-member, abstract-method

from __future__ import absolute_import  # so we can import standard 'types'

from sqlalchemy import (
    Column,
    Text,
    Integer,
    Boolean,
    DateTime,
    PickleType
)
from sqlalchemy.ext.declarative import declared_attr

from ..utils import (collections, formatting)
from .mixins import TemplateModelMixin
from . import (
    relationship,
    types as modeling_types
)


class ServiceTemplateBase(TemplateModelMixin):
    """
    Template for creating :class:`Service` instances.

    Usually created by various DSL parsers, such as ARIA's TOSCA extension. However, it can also be
    created programmatically.
    """

    __tablename__ = 'service_template'

    __private_fields__ = ('substitution_template_fk',
                          'node_type_fk',
                          'group_type_fk',
                          'policy_type_fk',
                          'relationship_type_fk',
                          'capability_type_fk',
                          'interface_type_fk',
                          'artifact_type_fk')

    # region one_to_one relationships

    @declared_attr
    def substitution_template(cls):
        """
        Exposes an entire service as a single node.

        :type: :class:`SubstitutionTemplate`
        """
        return relationship.one_to_one(
            cls, 'substitution_template', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def node_types(cls):
        """
        Base for the node type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='node_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def group_types(cls):
        """
        Base for the group type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='group_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def policy_types(cls):
        """
        Base for the policy type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='policy_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def relationship_types(cls):
        """
        Base for the relationship type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='relationship_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def capability_types(cls):
        """
        Base for the capability type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='capability_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def interface_types(cls):
        """
        Base for the interface type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='interface_type_fk', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def artifact_types(cls):
        """
        Base for the artifact type hierarchy,

        :type: :class:`Type`
        """
        return relationship.one_to_one(
            cls, 'type', fk='artifact_type_fk', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region one_to_many relationships

    @declared_attr
    def services(cls):
        """
        Instantiated services.

        :type: [:class:`Service`]
        """
        return relationship.one_to_many(cls, 'service', dict_key='name')

    @declared_attr
    def node_templates(cls):
        """
        Templates for creating nodes.

        :type: {:obj:`basestring`, :class:`NodeTemplate`}
        """
        return relationship.one_to_many(cls, 'node_template', dict_key='name')

    @declared_attr
    def group_templates(cls):
        """
        Templates for creating groups.

        :type: {:obj:`basestring`, :class:`GroupTemplate`}
        """
        return relationship.one_to_many(cls, 'group_template', dict_key='name')

    @declared_attr
    def policy_templates(cls):
        """
        Templates for creating policies.

        :type: {:obj:`basestring`, :class:`PolicyTemplate`}
        """
        return relationship.one_to_many(cls, 'policy_template', dict_key='name')

    @declared_attr
    def workflow_templates(cls):
        """
        Templates for creating workflows.

        :type: {:obj:`basestring`, :class:`OperationTemplate`}
        """
        return relationship.one_to_many(cls, 'operation_template', dict_key='name')

    @declared_attr
    def outputs(cls):
        """
        Declarations for output parameters are filled in after service installation.

        :type: {:obj:`basestring`: :class:`Output`}
        """
        return relationship.one_to_many(cls, 'output', dict_key='name')

    @declared_attr
    def inputs(cls):
        """
        Declarations for externally provided parameters.

        :type: {:obj:`basestring`: :class:`Input`}
        """
        return relationship.one_to_many(cls, 'input', dict_key='name')

    @declared_attr
    def plugin_specifications(cls):
        """
        Required plugins for instantiated services.

        :type: {:obj:`basestring`: :class:`PluginSpecification`}
        """
        return relationship.one_to_many(cls, 'plugin_specification', dict_key='name')

    # endregion

    # region many_to_many relationships

    @declared_attr
    def meta_data(cls):
        """
        Associated metadata.

        :type: {:obj:`basestring`: :class:`Metadata`}
        """
        # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
        return relationship.many_to_many(cls, 'metadata', dict_key='name')

    # endregion

    # region foreign keys

    @declared_attr
    def substitution_template_fk(cls):
        """For ServiceTemplate one-to-one to SubstitutionTemplate"""
        return relationship.foreign_key('substitution_template', nullable=True)

    @declared_attr
    def node_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def group_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def policy_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def relationship_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def capability_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def interface_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def artifact_type_fk(cls):
        """For ServiceTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    main_file_name = Column(Text, doc="""
    Filename of CSAR or YAML file from which this service template was parsed.
    
    :type: :obj:`basestring`
    """)

    created_at = Column(DateTime, nullable=False, index=True, doc="""
    Creation timestamp.

    :type: :class:`~datetime.datetime`
    """)

    updated_at = Column(DateTime, doc="""
    Update timestamp.

    :type: :class:`~datetime.datetime`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('description', self.description),
            ('metadata', formatting.as_raw_dict(self.meta_data)),
            ('node_templates', formatting.as_raw_list(self.node_templates)),
            ('group_templates', formatting.as_raw_list(self.group_templates)),
            ('policy_templates', formatting.as_raw_list(self.policy_templates)),
            ('substitution_template', formatting.as_raw(self.substitution_template)),
            ('inputs', formatting.as_raw_dict(self.inputs)),
            ('outputs', formatting.as_raw_dict(self.outputs)),
            ('workflow_templates', formatting.as_raw_list(self.workflow_templates))))

    @property
    def types_as_raw(self):
        return collections.OrderedDict((
            ('node_types', formatting.as_raw(self.node_types)),
            ('group_types', formatting.as_raw(self.group_types)),
            ('policy_types', formatting.as_raw(self.policy_types)),
            ('relationship_types', formatting.as_raw(self.relationship_types)),
            ('capability_types', formatting.as_raw(self.capability_types)),
            ('interface_types', formatting.as_raw(self.interface_types)),
            ('artifact_types', formatting.as_raw(self.artifact_types))))


class NodeTemplateBase(TemplateModelMixin):
    """
    Template for creating zero or more :class:`Node` instances, which are typed vertices in the
    service topology.
    """

    __tablename__ = 'node_template'

    __private_fields__ = ('type_fk',
                          'service_template_fk')

    # region one_to_many relationships

    @declared_attr
    def nodes(cls):
        """
        Instantiated nodes.

        :type: [:class:`Node`]
        """
        return relationship.one_to_many(cls, 'node')

    @declared_attr
    def interface_templates(cls):
        """
        Associated interface templates.

        :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
        """
        return relationship.one_to_many(cls, 'interface_template', dict_key='name')

    @declared_attr
    def artifact_templates(cls):
        """
        Associated artifacts.

        :type: {:obj:`basestring`: :class:`ArtifactTemplate`}
        """
        return relationship.one_to_many(cls, 'artifact_template', dict_key='name')

    @declared_attr
    def capability_templates(cls):
        """
        Associated exposed capability templates.

        :type: {:obj:`basestring`: :class:`CapabilityTemplate`}
        """
        return relationship.one_to_many(cls, 'capability_template', dict_key='name')

    @declared_attr
    def requirement_templates(cls):
        """
        Associated potential relationships with other nodes.

        :type: [:class:`RequirementTemplate`]
        """
        return relationship.one_to_many(cls, 'requirement_template', other_fk='node_template_fk')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    @declared_attr
    def attributes(cls):
        """
        Declarations for associated mutable parameters.

        :type: {:obj:`basestring`: :class:`Attribute`}
        """
        return relationship.one_to_many(cls, 'attribute', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def type(cls):
        """
        Node type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def service_template(cls):
        """
        Containing service template.

        :type: :class:`ServiceTemplate`
        """
        return relationship.many_to_one(cls, 'service_template')

    # endregion

    # region association proxies

    @declared_attr
    def service_template_name(cls):
        return relationship.association_proxy('service_template', 'name')

    @declared_attr
    def type_name(cls):
        return relationship.association_proxy('type', 'name')

    # endregion

    # region foreign_keys

    @declared_attr
    def type_fk(cls):
        """For NodeTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def service_template_fk(cls):
        """For ServiceTemplate one-to-many to NodeTemplate"""
        return relationship.foreign_key('service_template')

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    directives = Column(PickleType, doc="""
    Directives that apply to this node template.

    :type: [:obj:`basestring`]
    """)

    default_instances = Column(Integer, default=1, doc="""
    Default number nodes that will appear in the service.

    :type: :obj:`int`
    """)

    min_instances = Column(Integer, default=0, doc="""
    Minimum number nodes that will appear in the service.

    :type: :obj:`int`
    """)

    max_instances = Column(Integer, default=None, doc="""
    Maximum number nodes that will appear in the service.

    :type: :obj:`int`
    """)

    target_node_template_constraints = Column(PickleType, doc="""
    Constraints for filtering relationship targets.

    :type: [:class:`NodeTemplateConstraint`]
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('properties', formatting.as_raw_dict(self.properties)),
            ('attributes', formatting.as_raw_dict(self.properties)),
            ('interface_templates', formatting.as_raw_list(self.interface_templates)),
            ('artifact_templates', formatting.as_raw_list(self.artifact_templates)),
            ('capability_templates', formatting.as_raw_list(self.capability_templates)),
            ('requirement_templates', formatting.as_raw_list(self.requirement_templates))))

    def is_target_node_template_valid(self, target_node_template):
        """
        Checks if ``target_node_template`` matches all our ``target_node_template_constraints``.
        """

        if self.target_node_template_constraints:
            for node_template_constraint in self.target_node_template_constraints:
                if not node_template_constraint.matches(self, target_node_template):
                    return False
        return True

    @property
    def _next_index(self):
        """
        Next available node index.

        :returns: node index
        :rtype: int
        """

        max_index = 0
        if self.nodes:
            max_index = max(int(n.name.rsplit('_', 1)[-1]) for n in self.nodes)
        return max_index + 1

    @property
    def _next_name(self):
        """
        Next available node name.

        :returns: node name
        :rtype: basestring
        """

        return '{name}_{index}'.format(name=self.name, index=self._next_index)

    @property
    def scaling(self):
        scaling = {}

        def extract_property(properties, name):
            if name in scaling:
                return
            prop = properties.get(name)
            if (prop is not None) and (prop.type_name == 'integer') and (prop.value is not None):
                scaling[name] = prop.value

        def extract_properties(properties):
            extract_property(properties, 'min_instances')
            extract_property(properties, 'max_instances')
            extract_property(properties, 'default_instances')

        # From our scaling capabilities
        for capability_template in self.capability_templates.itervalues():
            if capability_template.type.role == 'scaling':
                extract_properties(capability_template.properties)

        # From service scaling policies
        for policy_template in self.service_template.policy_templates.itervalues():
            if policy_template.type.role == 'scaling':
                if policy_template.is_for_node_template(self.name):
                    extract_properties(policy_template.properties)

        # Defaults
        scaling.setdefault('min_instances', 0)
        scaling.setdefault('max_instances', 1)
        scaling.setdefault('default_instances', 1)

        return scaling


class GroupTemplateBase(TemplateModelMixin):
    """
    Template for creating a :class:`Group` instance, which is a typed logical container for zero or
    more :class:`Node` instances.
    """

    __tablename__ = 'group_template'

    __private_fields__ = ('type_fk',
                          'service_template_fk')

    # region one_to_many relationships

    @declared_attr
    def groups(cls):
        """
        Instantiated groups.

        :type: [:class:`Group`]
        """
        return relationship.one_to_many(cls, 'group')

    @declared_attr
    def interface_templates(cls):
        """
        Associated interface templates.

        :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
        """
        return relationship.one_to_many(cls, 'interface_template', dict_key='name')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def service_template(cls):
        """
        Containing service template.

        :type: :class:`ServiceTemplate`
        """
        return relationship.many_to_one(cls, 'service_template')

    @declared_attr
    def type(cls):
        """
        Group type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region many_to_many relationships

    @declared_attr
    def node_templates(cls):
        """
        Nodes instantiated by these templates will be members of the group.

        :type: [:class:`NodeTemplate`]
        """
        return relationship.many_to_many(cls, 'node_template')

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For GroupTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def service_template_fk(cls):
        """For ServiceTemplate one-to-many to GroupTemplate"""
        return relationship.foreign_key('service_template')

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('properties', formatting.as_raw_dict(self.properties)),
            ('interface_templates', formatting.as_raw_list(self.interface_templates))))

    def contains_node_template(self, name):
        for node_template in self.node_templates:
            if node_template.name == name:
                return True
        return False


class PolicyTemplateBase(TemplateModelMixin):
    """
    Template for creating a :class:`Policy` instance, which is a typed set of orchestration hints
    applied to zero or more :class:`Node` or :class:`Group` instances.
    """

    __tablename__ = 'policy_template'

    __private_fields__ = ('type_fk',
                          'service_template_fk')

    # region one_to_many relationships

    @declared_attr
    def policies(cls):
        """
        Instantiated policies.

        :type: [:class:`Policy`]
        """
        return relationship.one_to_many(cls, 'policy')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def service_template(cls):
        """
        Containing service template.

        :type: :class:`ServiceTemplate`
        """
        return relationship.many_to_one(cls, 'service_template')

    @declared_attr
    def type(cls):
        """
        Policy type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region many_to_many relationships

    @declared_attr
    def node_templates(cls):
        """
        Policy will be enacted on all nodes instantiated by these templates.

        :type: {:obj:`basestring`: :class:`NodeTemplate`}
        """
        return relationship.many_to_many(cls, 'node_template')

    @declared_attr
    def group_templates(cls):
        """
        Policy will be enacted on all nodes in all groups instantiated by these templates.

        :type: {:obj:`basestring`: :class:`GroupTemplate`}
        """
        return relationship.many_to_many(cls, 'group_template')

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For PolicyTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def service_template_fk(cls):
        """For ServiceTemplate one-to-many to PolicyTemplate"""
        return relationship.foreign_key('service_template')

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('properties', formatting.as_raw_dict(self.properties))))

    def is_for_node_template(self, name):
        for node_template in self.node_templates:
            if node_template.name == name:
                return True
        for group_template in self.group_templates:
            if group_template.contains_node_template(name):
                return True
        return False

    def is_for_group_template(self, name):
        for group_template in self.group_templates:
            if group_template.name == name:
                return True
        return False


class SubstitutionTemplateBase(TemplateModelMixin):
    """
    Template for creating a :class:`Substitution` instance, which exposes an entire instantiated
    service as a single node.
    """

    __tablename__ = 'substitution_template'

    __private_fields__ = ('node_type_fk',)

    # region one_to_many relationships

    @declared_attr
    def substitutions(cls):
        """
        Instantiated substitutions.

        :type: [:class:`Substitution`]
        """
        return relationship.one_to_many(cls, 'substitution')

    @declared_attr
    def mappings(cls):
        """
        Map requirement and capabilities to exposed node.

        :type: {:obj:`basestring`: :class:`SubstitutionTemplateMapping`}
        """
        return relationship.one_to_many(cls, 'substitution_template_mapping', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def node_type(cls):
        """
        Exposed node type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def node_type_fk(cls):
        """For SubstitutionTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    # endregion

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('node_type_name', self.node_type.name),
            ('mappings', formatting.as_raw_dict(self.mappings))))


class SubstitutionTemplateMappingBase(TemplateModelMixin):
    """
    Used by :class:`SubstitutionTemplate` to map a capability template or a requirement template to
    the exposed node.

    The :attr:`name` field should match the capability or requirement name on the exposed node's
    type.

    Only one of :attr:`capability_template` and :attr:`requirement_template` can be set.
    """

    __tablename__ = 'substitution_template_mapping'

    __private_fields__ = ('substitution_template_fk',
                          'capability_template_fk',
                          'requirement_template_fk')

    # region one_to_one relationships

    @declared_attr
    def capability_template(cls):
        """
        Capability template to expose (can be ``None``).

        :type: :class:`CapabilityTemplate`
        """
        return relationship.one_to_one(
            cls, 'capability_template', back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def requirement_template(cls):
        """
        Requirement template to expose (can be ``None``).

        :type: :class:`RequirementTemplate`
        """
        return relationship.one_to_one(
            cls, 'requirement_template', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region many_to_one relationships

    @declared_attr
    def substitution_template(cls):
        """
        Containing substitution template.

        :type: :class:`SubstitutionTemplate`
        """
        return relationship.many_to_one(cls, 'substitution_template', back_populates='mappings')

    # endregion

    # region foreign keys

    @declared_attr
    def substitution_template_fk(cls):
        """For SubstitutionTemplate one-to-many to SubstitutionTemplateMapping"""
        return relationship.foreign_key('substitution_template')

    @declared_attr
    def capability_template_fk(cls):
        """For SubstitutionTemplate one-to-one to CapabilityTemplate"""
        return relationship.foreign_key('capability_template', nullable=True)

    @declared_attr
    def requirement_template_fk(cls):
        """For SubstitutionTemplate one-to-one to RequirementTemplate"""
        return relationship.foreign_key('requirement_template', nullable=True)

    # endregion

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),))


class RequirementTemplateBase(TemplateModelMixin):
    """
    Template for creating :class:`Relationship` instances, which are optionally-typed edges in the
    service topology, connecting a :class:`Node` to a :class:`Capability` of another node.

    Note that there is no equivalent "Requirement" instance model. Instead, during instantiation a
    requirement template is matched with a capability and a :class:`Relationship` is instantiated.

    A requirement template *must* target a :class:`CapabilityType` or a capability name. It can
    optionally target a specific :class:`NodeType` or :class:`NodeTemplate`.

    Requirement templates may optionally contain a :class:`RelationshipTemplate`. If they do not,
    a :class:`Relationship` will be instantiated with default values.
    """

    __tablename__ = 'requirement_template'

    __private_fields__ = ('target_capability_type_fk',
                          'target_node_template_fk',
                          'target_node_type_fk',
                          'relationship_template_fk',
                          'node_template_fk')

    # region one_to_one relationships

    @declared_attr
    def target_capability_type(cls):
        """
        Target capability type.

        :type: :class:`CapabilityType`
        """
        return relationship.one_to_one(cls,
                                       'type',
                                       fk='target_capability_type_fk',
                                       back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def target_node_template(cls):
        """
        Target node template (can be ``None``).

        :type: :class:`NodeTemplate`
        """
        return relationship.one_to_one(cls,
                                       'node_template',
                                       fk='target_node_template_fk',
                                       back_populates=relationship.NO_BACK_POP)

    @declared_attr
    def relationship_template(cls):
        """
        Associated relationship template (can be ``None``).

        :type: :class:`RelationshipTemplate`
        """
        return relationship.one_to_one(cls, 'relationship_template')

    # endregion

    # region one_to_many relationships

    @declared_attr
    def relationships(cls):
        """
        Instantiated relationships.

        :type: [:class:`Relationship`]
        """
        return relationship.one_to_many(cls, 'relationship')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def node_template(cls):
        """
        Containing node template.

        :type: :class:`NodeTemplate`
        """
        return relationship.many_to_one(cls, 'node_template', fk='node_template_fk')

    @declared_attr
    def target_node_type(cls):
        """
        Target node type (can be ``None``).

        :type: :class:`Type`
        """
        return relationship.many_to_one(
            cls, 'type', fk='target_node_type_fk', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def target_node_type_fk(cls):
        """For RequirementTemplate many-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def target_node_template_fk(cls):
        """For RequirementTemplate one-to-one to NodeTemplate"""
        return relationship.foreign_key('node_template', nullable=True)

    @declared_attr
    def target_capability_type_fk(cls):
        """For RequirementTemplate one-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    @declared_attr
    def node_template_fk(cls):
        """For NodeTemplate one-to-many to RequirementTemplate"""
        return relationship.foreign_key('node_template')

    @declared_attr
    def relationship_template_fk(cls):
        """For RequirementTemplate one-to-one to RelationshipTemplate"""
        return relationship.foreign_key('relationship_template', nullable=True)

    # endregion

    target_capability_name = Column(Text, doc="""
    Target capability name in node template or node type (can be ``None``).

    :type: :obj:`basestring`
    """)

    target_node_template_constraints = Column(PickleType, doc="""
    Constraints for filtering relationship targets.

    :type: [:class:`NodeTemplateConstraint`]
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('target_node_type_name', self.target_node_type.name
             if self.target_node_type is not None else None),
            ('target_node_template_name', self.target_node_template.name
             if self.target_node_template is not None else None),
            ('target_capability_type_name', self.target_capability_type.name
             if self.target_capability_type is not None else None),
            ('target_capability_name', self.target_capability_name),
            ('relationship_template', formatting.as_raw(self.relationship_template))))


class RelationshipTemplateBase(TemplateModelMixin):
    """
    Optional addition to a :class:`RequirementTemplate`.

    Note that a relationship template here is not exactly equivalent to a relationship template
    entity in TOSCA. For example, a TOSCA requirement specifying a relationship type rather than a
    relationship template would still be represented here as a relationship template.
    """

    __tablename__ = 'relationship_template'

    __private_fields__ = ('type_fk',)

    # region one_to_many relationships

    @declared_attr
    def relationships(cls):
        """
        Instantiated relationships.

        :type: [:class:`Relationship`]
        """
        return relationship.one_to_many(cls, 'relationship')

    @declared_attr
    def interface_templates(cls):
        """
        Associated interface templates.

        :type: {:obj:`basestring`: :class:`InterfaceTemplate`}
        """
        return relationship.one_to_many(cls, 'interface_template', dict_key='name')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def type(cls):
        """
        Relationship type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For RelationshipTemplate many-to-one to Type"""
        return relationship.foreign_key('type', nullable=True)

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('type_name', self.type.name if self.type is not None else None),
            ('name', self.name),
            ('description', self.description),
            ('properties', formatting.as_raw_dict(self.properties)),
            ('interface_templates', formatting.as_raw_list(self.interface_templates))))


class CapabilityTemplateBase(TemplateModelMixin):
    """
    Template for creating :class:`Capability` instances, typed attachments which serve two purposes:
    to provide extra properties and attributes to :class:`Node` instances, and to expose targets for
    :class:`Relationship` instances from other nodes.
    """

    __tablename__ = 'capability_template'

    __private_fields__ = ('type_fk',
                          'node_template_fk')

    # region one_to_many relationships

    @declared_attr
    def capabilities(cls):
        """
        Instantiated capabilities.

        :type: [:class:`Capability`]
        """
        return relationship.one_to_many(cls, 'capability')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def node_template(cls):
        """
        Containing node template.

        :type: :class:`NodeTemplate`
        """
        return relationship.many_to_one(cls, 'node_template')

    @declared_attr
    def type(cls):
        """
        Capability type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region many_to_many relationships

    @declared_attr
    def valid_source_node_types(cls):
        """
        Reject requirements that are not from these node types.

        :type: [:class:`Type`]
        """
        return relationship.many_to_many(cls, 'type', prefix='valid_sources')

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For CapabilityTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def node_template_fk(cls):
        """For NodeTemplate one-to-many to CapabilityTemplate"""
        return relationship.foreign_key('node_template')

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    min_occurrences = Column(Integer, default=None, doc="""
    Minimum number of requirement matches required.

    :type: :obj:`int`
    """)

    max_occurrences = Column(Integer, default=None, doc="""
    Maximum number of requirement matches allowed.

    :type: :obj:`int`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('min_occurrences', self.min_occurrences),
            ('max_occurrences', self.max_occurrences),
            ('valid_source_node_types', [v.name for v in self.valid_source_node_types]),
            ('properties', formatting.as_raw_dict(self.properties))))


class InterfaceTemplateBase(TemplateModelMixin):
    """
    Template for creating :class:`Interface` instances, which are typed bundles of
    :class:`Operation` instances.

    Can be associated with a :class:`NodeTemplate`, a :class:`GroupTemplate`, or a
    :class:`RelationshipTemplate`.
    """

    __tablename__ = 'interface_template'

    __private_fields__ = ('type_fk',
                          'node_template_fk',
                          'group_template_fk',
                          'relationship_template_fk')

    # region one_to_many relationships

    @declared_attr
    def inputs(cls):
        """
        Declarations for externally provided parameters that can be used by all operations of the
        interface.

        :type: {:obj:`basestring`: :class:`Input`}
        """
        return relationship.one_to_many(cls, 'input', dict_key='name')

    @declared_attr
    def interfaces(cls):
        """
        Instantiated interfaces.

        :type: [:class:`Interface`]
        """
        return relationship.one_to_many(cls, 'interface')

    @declared_attr
    def operation_templates(cls):
        """
        Associated operation templates.

        :type: {:obj:`basestring`: :class:`OperationTemplate`}
        """
        return relationship.one_to_many(cls, 'operation_template', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def node_template(cls):
        """
        Containing node template (can be ``None``).

        :type: :class:`NodeTemplate`
        """
        return relationship.many_to_one(cls, 'node_template')

    @declared_attr
    def group_template(cls):
        """
        Containing group template (can be ``None``).

        :type: :class:`GroupTemplate`
        """
        return relationship.many_to_one(cls, 'group_template')

    @declared_attr
    def relationship_template(cls):
        """
        Containing relationship template (can be ``None``).

        :type: :class:`RelationshipTemplate`
        """
        return relationship.many_to_one(cls, 'relationship_template')

    @declared_attr
    def type(cls):
        """
        Interface type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For InterfaceTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def node_template_fk(cls):
        """For NodeTemplate one-to-many to InterfaceTemplate"""
        return relationship.foreign_key('node_template', nullable=True)

    @declared_attr
    def group_template_fk(cls):
        """For GroupTemplate one-to-many to InterfaceTemplate"""
        return relationship.foreign_key('group_template', nullable=True)

    @declared_attr
    def relationship_template_fk(cls):
        """For RelationshipTemplate one-to-many to InterfaceTemplate"""
        return relationship.foreign_key('relationship_template', nullable=True)

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('inputs', formatting.as_raw_dict(self.inputs)),                                        # pylint: disable=no-member
            # TODO fix self.properties reference
            ('operation_templates', formatting.as_raw_list(self.operation_templates))))


class OperationTemplateBase(TemplateModelMixin):
    """
    Template for creating :class:`Operation` instances, which are entry points to Python functions
    called as part of a workflow execution.
    """

    __tablename__ = 'operation_template'

    __private_fields__ = ('service_template_fk',
                          'interface_template_fk',
                          'plugin_fk')

    # region one_to_one relationships

    @declared_attr
    def plugin_specification(cls):
        """
        Associated plugin specification.

        :type: :class:`PluginSpecification`
        """
        return relationship.one_to_one(
            cls, 'plugin_specification', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region one_to_many relationships

    @declared_attr
    def operations(cls):
        """
        Instantiated operations.

        :type: [:class:`Operation`]
        """
        return relationship.one_to_many(cls, 'operation')

    @declared_attr
    def inputs(cls):
        """
        Declarations for parameters provided to the :attr:`implementation`.

        :type: {:obj:`basestring`: :class:`Input`}
        """
        return relationship.one_to_many(cls, 'input', dict_key='name')

    @declared_attr
    def configurations(cls):
        """
        Configuration parameters for the operation instance Python :attr:`function`.

        :type: {:obj:`basestring`: :class:`Configuration`}
        """
        return relationship.one_to_many(cls, 'configuration', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def service_template(cls):
        """
        Containing service template (can be ``None``). For workflow operation templates.

        :type: :class:`ServiceTemplate`
        """
        return relationship.many_to_one(cls, 'service_template',
                                        back_populates='workflow_templates')

    @declared_attr
    def interface_template(cls):
        """
        Containing interface template (can be ``None``).

        :type: :class:`InterfaceTemplate`
        """
        return relationship.many_to_one(cls, 'interface_template')

    # endregion

    # region foreign keys

    @declared_attr
    def service_template_fk(cls):
        """For ServiceTemplate one-to-many to OperationTemplate"""
        return relationship.foreign_key('service_template', nullable=True)

    @declared_attr
    def interface_template_fk(cls):
        """For InterfaceTemplate one-to-many to OperationTemplate"""
        return relationship.foreign_key('interface_template', nullable=True)

    @declared_attr
    def plugin_specification_fk(cls):
        """For OperationTemplate one-to-one to PluginSpecification"""
        return relationship.foreign_key('plugin_specification', nullable=True)

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    relationship_edge = Column(Boolean, doc="""
    When ``True`` specifies that the operation is on the relationship's target edge; ``False`` is
    the source edge (only used by operations on relationships)

    :type: :obj:`bool`
    """)

    implementation = Column(Text, doc="""
    Implementation (usually the name of an artifact).

    :type: :obj:`basestring`
    """)

    dependencies = Column(modeling_types.StrictList(item_cls=basestring), doc="""
    Dependencies (usually names of artifacts).

    :type: [:obj:`basestring`]
    """)

    function = Column(Text, doc="""
    Full path to Python function.

    :type: :obj:`basestring`
    """)

    executor = Column(Text, doc="""
    Name of executor.

    :type: :obj:`basestring`
    """)

    max_attempts = Column(Integer, doc="""
    Maximum number of attempts allowed in case of task failure.

    :type: :obj:`int`
    """)

    retry_interval = Column(Integer, doc="""
    Interval between task retry attemps (in seconds).

    :type: :obj:`float`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('implementation', self.implementation),
            ('dependencies', self.dependencies),
            ('inputs', formatting.as_raw_dict(self.inputs))))


class ArtifactTemplateBase(TemplateModelMixin):
    """
    Template for creating an :class:`Artifact` instance, which is a typed file, either provided in a
    CSAR or downloaded from a repository.
    """

    __tablename__ = 'artifact_template'

    __private_fields__ = ('type_fk',
                          'node_template_fk')

    # region one_to_many relationships

    @declared_attr
    def artifacts(cls):
        """
        Instantiated artifacts.

        :type: [:class:`Artifact`]
        """
        return relationship.one_to_many(cls, 'artifact')

    @declared_attr
    def properties(cls):
        """
        Declarations for associated immutable parameters.

        :type: {:obj:`basestring`: :class:`Property`}
        """
        return relationship.one_to_many(cls, 'property', dict_key='name')

    # endregion

    # region many_to_one relationships

    @declared_attr
    def node_template(cls):
        """
        Containing node template.

        :type: :class:`NodeTemplate`
        """
        return relationship.many_to_one(cls, 'node_template')

    @declared_attr
    def type(cls):
        """
        Artifact type.

        :type: :class:`Type`
        """
        return relationship.many_to_one(cls, 'type', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def type_fk(cls):
        """For ArtifactTemplate many-to-one to Type"""
        return relationship.foreign_key('type')

    @declared_attr
    def node_template_fk(cls):
        """For NodeTemplate one-to-many to ArtifactTemplate"""
        return relationship.foreign_key('node_template')

    # endregion

    description = Column(Text, doc="""
    Human-readable description.

    :type: :obj:`basestring`
    """)

    source_path = Column(Text, doc="""
    Source path (in CSAR or repository).

    :type: :obj:`basestring`
    """)

    target_path = Column(Text, doc="""
    Path at which to install at destination.

    :type: :obj:`basestring`
    """)

    repository_url = Column(Text, doc="""
    Repository URL.

    :type: :obj:`basestring`
    """)

    repository_credential = Column(modeling_types.StrictDict(basestring, basestring), doc="""
    Credentials for accessing the repository.

    :type: {:obj:`basestring`, :obj:`basestring`}
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('description', self.description),
            ('type_name', self.type.name),
            ('source_path', self.source_path),
            ('target_path', self.target_path),
            ('repository_url', self.repository_url),
            ('repository_credential', formatting.as_agnostic(self.repository_credential)),
            ('properties', formatting.as_raw_dict(self.properties))))


class PluginSpecificationBase(TemplateModelMixin):
    """
    Requirement for a :class:`Plugin`.

    The actual plugin to be selected depends on those currently installed in ARIA.
    """

    __tablename__ = 'plugin_specification'

    __private_fields__ = ('service_template_fk',
                          'plugin_fk')

    # region many_to_one relationships

    @declared_attr
    def service_template(cls):
        """
        Containing service template.

        :type: :class:`ServiceTemplate`
        """
        return relationship.many_to_one(cls, 'service_template')

    @declared_attr
    def plugin(cls):                                                                                # pylint: disable=method-hidden
        """
        Matched plugin.

        :type: :class:`Plugin`
        """
        return relationship.many_to_one(cls, 'plugin', back_populates=relationship.NO_BACK_POP)

    # endregion

    # region foreign keys

    @declared_attr
    def service_template_fk(cls):
        """For ServiceTemplate one-to-many to PluginSpecification"""
        return relationship.foreign_key('service_template', nullable=True)

    @declared_attr
    def plugin_fk(cls):
        """For PluginSpecification many-to-one to Plugin"""
        return relationship.foreign_key('plugin', nullable=True)

    # endregion

    version = Column(Text, doc="""
    Minimum plugin version.

    :type: :obj:`basestring`
    """)

    enabled = Column(Boolean, nullable=False, default=True, doc="""
    Whether the plugin is enabled.

    :type: :obj:`bool`
    """)

    @property
    def as_raw(self):
        return collections.OrderedDict((
            ('name', self.name),
            ('version', self.version),
            ('enabled', self.enabled)))