package org.openecomp.sdc.toscaparser.api;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;

import org.openecomp.sdc.toscaparser.api.SubstitutionMappings;
import org.openecomp.sdc.toscaparser.api.ToscaGraph;
import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
import org.openecomp.sdc.toscaparser.api.elements.Metadata;
import org.openecomp.sdc.toscaparser.api.elements.NodeType;
import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
import org.openecomp.sdc.toscaparser.api.functions.Function;
import org.openecomp.sdc.toscaparser.api.functions.GetAttribute;
import org.openecomp.sdc.toscaparser.api.functions.GetInput;
import org.openecomp.sdc.toscaparser.api.parameters.Input;
import org.openecomp.sdc.toscaparser.api.parameters.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TopologyTemplate {

	private static Logger log = LoggerFactory.getLogger(TopologyTemplate.class.getName());
	private static final String DESCRIPTION = "description";
	private static final String INPUTS = "inputs";
	private static final String NODE_TEMPLATES = "node_templates";
	private static final String RELATIONSHIP_TEMPLATES = "relationship_templates";
	private static final String OUTPUTS = "outputs";
	private static final String GROUPS = "groups";
	private static final String SUBSTITUTION_MAPPINGS = "substitution_mappings";
	private static final String POLICIES = "policies";
	private static final String METADATA = "metadata";
	
	private static String SECTIONS[] = {
				DESCRIPTION, INPUTS, NODE_TEMPLATES, RELATIONSHIP_TEMPLATES, 
				OUTPUTS, GROUPS,  SUBSTITUTION_MAPPINGS, POLICIES, METADATA
			};

    private LinkedHashMap<String,Object> tpl;
	Metadata metaData;
    private ArrayList<Input> inputs;
    private ArrayList<Output> outputs;
    private ArrayList<RelationshipTemplate> relationshipTemplates;
    private ArrayList<NodeTemplate> nodeTemplates;
	private LinkedHashMap<String,Object> customDefs;
	private LinkedHashMap<String,Object> relTypes;//TYPE
    private NodeTemplate subMappedNodeTemplate;
    private ArrayList<Group> groups;
    private ArrayList<Policy> policies;
    private LinkedHashMap<String,Object> parsedParams = null;//TYPE
    private String description;
    private ToscaGraph graph;
    private SubstitutionMappings substitutionMappings;
	
	public TopologyTemplate(
			LinkedHashMap<String,Object> _template, 
			LinkedHashMap<String,Object> _customDefs,
			LinkedHashMap<String,Object> _relTypes,//TYPE
            LinkedHashMap<String, Object> _parsedParams,
            NodeTemplate  _subMappedNodeTemplate) {

		tpl = _template;
		if(tpl != null) {
			subMappedNodeTemplate = _subMappedNodeTemplate;
			metaData = _metaData();
			customDefs = _customDefs;
			relTypes = _relTypes;
			parsedParams = _parsedParams;
			_validateField();
			description = _tplDescription();
			inputs = _inputs();
	        relationshipTemplates =_relationshipTemplates();
	        nodeTemplates = _nodeTemplates();
	        outputs = _outputs();
	        if(nodeTemplates != null) {
	        	graph = new ToscaGraph(nodeTemplates);
	        }
	        groups = _groups();
	        policies = _policies();
	        _processIntrinsicFunctions();
            substitutionMappings = _substitutionMappings();
		}
	}

	@SuppressWarnings("unchecked")
	private ArrayList<Input> _inputs() {
		ArrayList<Input> alInputs = new ArrayList<>();
		for(String name: _tplInputs().keySet()) {
			Object attrs = _tplInputs().get(name);
			Input input = new Input(name,(LinkedHashMap<String,Object>)attrs);
            if(parsedParams != null && parsedParams.get(name) != null) {
            	input.validate(parsedParams.get(name));
            }
            else {
                Object _default = input.getDefault();
                if(_default != null) {
                    input.validate(_default);
                }
            }
            if((parsedParams != null && parsedParams.get(input.getName()) == null || parsedParams == null)
            		 && input.isRequired() && input.getDefault() == null) {
            	log.error("Log warning: TopologyTemplate - _inputs - The required parameter {} is not provided", input.getName());
            }
            alInputs.add(input);
		}
        return alInputs;
		
	}

	private Metadata _metaData() {
        if(tpl.get(METADATA) != null) {
        	return (Metadata)tpl.get(METADATA);
        }
        else {
        	return new Metadata(new LinkedHashMap<>());
        }
	
	}

	private ArrayList<NodeTemplate> _nodeTemplates() {
		ArrayList<NodeTemplate> alNodeTemplates = new ArrayList<>();
		LinkedHashMap<String,Object> tpls = _tplNodeTemplates();
		if(tpls != null) {
			for(String name: tpls.keySet()) {
				NodeTemplate tpl = new NodeTemplate(name,
													tpls,
													customDefs,
													relationshipTemplates,
													relTypes);
				if(tpl.getTypeDefinition() != null) {
					boolean b = NodeType.TOSCA_DEF.get(tpl.getType()) != null;
					if(b || (tpl.getCustomDef() != null && !tpl.getCustomDef().isEmpty())) {
						tpl.validate();
						alNodeTemplates.add(tpl);
					}
				}
			}
		}
		return alNodeTemplates;
	}
	
	@SuppressWarnings("unchecked")
	private ArrayList<RelationshipTemplate> _relationshipTemplates() {
		ArrayList<RelationshipTemplate> alRelationshipTemplates = new ArrayList<>();
		LinkedHashMap<String,Object> tpls = _tplRelationshipTemplates();
		if(tpls != null) {
			for(String name: tpls.keySet()) {
				RelationshipTemplate tpl = new RelationshipTemplate(
						(LinkedHashMap<String,Object>)tpls.get(name),name,customDefs,null,null);
						
				alRelationshipTemplates.add(tpl);
			}
		}
		return alRelationshipTemplates;
	}
	
	private ArrayList<Output> _outputs() {
		ArrayList<Output> alOutputs = new ArrayList<>();
		for(Map.Entry<String,Object> me: _tplOutputs().entrySet()) {
			String oname = me.getKey();
			LinkedHashMap<String,Object> oattrs = (LinkedHashMap<String,Object>)me.getValue(); 
			Output o = new Output(oname,oattrs);
			o.validate();
			alOutputs.add(o);
		}
		return alOutputs;
	}
	
	private SubstitutionMappings _substitutionMappings() {
		LinkedHashMap<String,Object> tplSubstitutionMapping = (LinkedHashMap<String,Object>) _tplSubstitutionMappings();
		
		//*** the commenting-out below and the weaker condition are in the Python source
		// #if tpl_substitution_mapping and self.sub_mapped_node_template:
		if(tplSubstitutionMapping != null && tplSubstitutionMapping.size() > 0) {
			return new SubstitutionMappings(tplSubstitutionMapping,
					                    nodeTemplates,
					                    inputs,
					                    outputs,
					                    groups,
					                    subMappedNodeTemplate,
					                    customDefs);
		}
		return null;
		
	}
	
	@SuppressWarnings("unchecked")
	private ArrayList<Policy> _policies() {
		ArrayList<Policy> alPolicies = new ArrayList<>();
		for(Object po: _tplPolicies()) {
			LinkedHashMap<String,Object> policy = (LinkedHashMap<String,Object>)po;
			for(Map.Entry<String,Object> me: policy.entrySet()) {
				String policyName = me.getKey();
				LinkedHashMap<String,Object> policyTpl = (LinkedHashMap<String,Object>)me.getValue();
				ArrayList<String> targetList = (ArrayList<String>)policyTpl.get("targets");
				//ArrayList<Object> targetObjects = new ArrayList<>();
				ArrayList<NodeTemplate> targetNodes = new ArrayList<>();
				ArrayList<Object> targetObjects = new ArrayList<>();
				ArrayList<Group> targetGroups = new ArrayList<>();
				String targetsType = "groups"; 
				if(targetList != null && targetList.size() >= 1) {
                    targetGroups = _getPolicyGroups(targetList);
                    if(targetGroups == null) {
                    	targetsType = "node_templates";
                        targetNodes = _getGroupMembers(targetList);
                        for(NodeTemplate nt: targetNodes) {
                        	targetObjects.add(nt);
                        }
                    }
                    else {
                    	for(Group gr: targetGroups) {
                    		targetObjects.add(gr);
                    	}
                    }
				}
                Policy policyObj = new Policy(policyName, 
                							  policyTpl,
		                                      targetObjects, 
		                                      targetsType,
		                                      customDefs);
                alPolicies.add(policyObj);
			}
		}
        return alPolicies;
	}
	
	private ArrayList<Group> _groups() {
		ArrayList<Group> groups = new ArrayList<>();
		ArrayList<NodeTemplate> memberNodes  = null;
		for(Map.Entry<String,Object> me: _tplGroups().entrySet()) {
			String groupName = me.getKey();
			LinkedHashMap<String,Object> groupTpl = (LinkedHashMap<String,Object>)me.getValue();
			ArrayList<String> memberNames = (ArrayList<String>)groupTpl.get("members");
			if(memberNames != null) {
                DataEntity.validateDatatype("list", memberNames,null,null,null);
				if(memberNames.size() < 1 || 
				       (new HashSet<String>(memberNames)).size() != memberNames.size()) {
                    ExceptionCollector.appendException(String.format(
                            "InvalidGroupTargetException: Member nodes \"%s\" should be >= 1 and not repeated",
                            memberNames.toString()));
				}
				else {
					memberNodes = _getGroupMembers(memberNames);
				}
			}
            Group group = new Group(groupName,
            						groupTpl,
            						memberNodes,
            						customDefs);
            groups.add(group);
		}
		return groups;
	}
	
	private ArrayList<NodeTemplate> _getGroupMembers(ArrayList<String> memberNames) {
		ArrayList<NodeTemplate> memberNodes = new ArrayList<>();
		_validateGroupMembers(memberNames);
		for(String member: memberNames) {
			for(NodeTemplate node: nodeTemplates) {
				if(member.equals(node.getName())) {
					memberNodes.add(node);
				}
			}
		}
		return memberNodes;
	}
	
	private ArrayList<Group> _getPolicyGroups(ArrayList<String> memberNames) {
		ArrayList<Group> memberGroups = new ArrayList<>();
		for(String member: memberNames) {
			for(Group group: groups) {
				if(member.equals(group.getName())) {
					memberGroups.add(group);
				}
			}
		}
		return memberGroups;
	}
	
	private void _validateGroupMembers(ArrayList<String> members) {
		ArrayList<String> nodeNames = new ArrayList<>();
		for(NodeTemplate node: nodeTemplates) {
			nodeNames.add(node.getName());
		}
		for(String member: members) {
			if(!nodeNames.contains(member)) {
                ExceptionCollector.appendException(String.format(
                        "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member));
			}
		}
	}
	
	// topology template can act like node template
	// it is exposed by substitution_mappings.

	public String nodetype() {
		return substitutionMappings.getNodeType();
	}
	
	public LinkedHashMap<String,Object> capabilities() {
		return substitutionMappings.getCapabilities();
	}
	
	public LinkedHashMap<String,Object> requirements() {
		return substitutionMappings.getRequirements();
	}

	private String _tplDescription() {
        return (String)tpl.get(DESCRIPTION);
        //if description:
        //	return description.rstrip()
	}

	@SuppressWarnings("unchecked")
	private LinkedHashMap<String,Object> _tplInputs() {
        if(tpl.get(INPUTS) != null) {
        	return (LinkedHashMap<String,Object>)tpl.get(INPUTS);
        }
        else {
        	return new LinkedHashMap<String,Object>();
        }
    }

    @SuppressWarnings("unchecked")
	private LinkedHashMap<String,Object> _tplNodeTemplates() {
        return (LinkedHashMap<String,Object>)tpl.get(NODE_TEMPLATES);
    }

    @SuppressWarnings("unchecked")
	private LinkedHashMap<String,Object> _tplRelationshipTemplates() {
        if(tpl.get(RELATIONSHIP_TEMPLATES) != null) {
        	return (LinkedHashMap<String,Object>)tpl.get(RELATIONSHIP_TEMPLATES);
        }
        else {
        	return new LinkedHashMap<String,Object>();
        }
    }

    @SuppressWarnings("unchecked")
 	private LinkedHashMap<String,Object> _tplOutputs() {
         if(tpl.get(OUTPUTS) != null) {
         	return (LinkedHashMap<String,Object>)tpl.get(OUTPUTS);
         }
         else {
         	return new LinkedHashMap<String,Object>();
         }
     }

    @SuppressWarnings("unchecked")
    private LinkedHashMap<String,Object> _tplSubstitutionMappings() {
        if(tpl.get(SUBSTITUTION_MAPPINGS) != null) {
        	return (LinkedHashMap<String,Object>)tpl.get(SUBSTITUTION_MAPPINGS);
        }
        else {
        	return new LinkedHashMap<String,Object>();
        }
    }

    @SuppressWarnings("unchecked")
    private LinkedHashMap<String,Object> _tplGroups() {
        if(tpl.get(GROUPS) != null) {
        	return (LinkedHashMap<String,Object>)tpl.get(GROUPS);
        }
        else {
        	return new LinkedHashMap<String,Object>();
        }
    }

    @SuppressWarnings("unchecked")
    private ArrayList<Object> _tplPolicies() {
        if(tpl.get(POLICIES) != null) {
        	return (ArrayList<Object>)tpl.get(POLICIES);
        }
        else {
        	return new ArrayList<Object>();
        }
    }

    private void _validateField() {
    	for(String name: tpl.keySet()) {
    		boolean bFound = false;
    		for(String section: SECTIONS) {
    			if(name.equals(section)) {
    				bFound = true;
    				break;
    			}
    		}
    		if(!bFound) {
                ExceptionCollector.appendException(String.format(
                		"UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name));
    		}
    	}
    }

    @SuppressWarnings("unchecked")
	private void _processIntrinsicFunctions() {
        // Process intrinsic functions

        // Current implementation processes functions within node template
        // properties, requirements, interfaces inputs and template outputs.
    	
    	if(nodeTemplates != null) {
    		for(NodeTemplate nt: nodeTemplates) {
    			for(Property prop: nt.getPropertiesObjects()) {
    				prop.setValue(Function.getFunction(this,nt,prop.getValue()));
    			}
    			for(InterfacesDef ifd: nt.getInterfaces()) {
    				LinkedHashMap<String,Object> ifin = ifd.getInputs();
    				if(ifin != null) {
    					for(Map.Entry<String,Object> me: ifin.entrySet()) {
    						String name = me.getKey();
    						Object value = Function.getFunction(this,nt,me.getValue());
    						ifd.setInput(name,value);
    					}
    				}
    			}
    			if(nt.getRequirements() != null &&
    					nt.getRequirements() instanceof ArrayList) {
    				for(Object oreq: nt.getRequirements()) {
    					LinkedHashMap<String,Object> req = (LinkedHashMap<String,Object>)oreq;
    					LinkedHashMap<String,Object> rel = req;
    					for(String reqName: req.keySet()) {
    						Object reqItem = req.get(reqName);
    						if(reqItem instanceof LinkedHashMap) {
    							Object t = ((LinkedHashMap<String,Object>)reqItem).get("relationship");
    							// it can be a string or a LHM...
    							if(t instanceof LinkedHashMap) {
    								rel = (LinkedHashMap<String,Object>)t;
    							}
    							else {
    								// we set it to null to fail the next test
    								// and avoid the get("proprties")
    								rel = null;
    							}
    							break;
    						}
    					}
    					if(rel != null && rel.get("properties") != null) {
    						LinkedHashMap<String,Object> relprops = 
    								(LinkedHashMap<String,Object>)rel.get("properties");
    						for(String key: relprops.keySet()) {
    							Object value = relprops.get(key);
    							Object func = Function.getFunction(this,req,value);
    							relprops.put(key,func);
    						}
    					}
    				}
    			}
    			if(nt.getCapabilitiesObjects() != null) {
    				for(Capability cap: nt.getCapabilitiesObjects()) {
    					if(cap.getPropertiesObjects() != null) {
    						for(Property prop: cap.getPropertiesObjects()) {
    							Object propvalue = Function.getFunction(this,nt,prop.getValue());
    							if(propvalue instanceof GetInput) {
    								propvalue = ((GetInput)propvalue).result();
    								for(String p: cap.getProperties().keySet()) {
    									//Object v = cap.getProperties().get(p);
    									if(p.equals(prop.getName())) {
    										cap.setProperty(p,propvalue);
    									}
    								}
    							}
    						}
    					}
    				}
    			}
    			for(RelationshipType rel: nt.getRelationships().keySet()) {
    				NodeTemplate node = nt.getRelationships().get(rel);
    				ArrayList<RelationshipTemplate> relTpls = node.getRelationshipTemplate();
    				if(relTpls != null) {
    					for(RelationshipTemplate relTpl: relTpls) {
    			    		// TT 5
    						for(InterfacesDef iface: relTpl.getInterfaces()) {
    							if(iface.getInputs() != null) {
    								for(String name: iface.getInputs().keySet()) {
    									Object value = iface.getInputs().get(name);
    									Object func = Function.getFunction(
    											this,
    											relTpl,
    											value);
    									iface.setInput(name,func);
    								}
    							}
    						}
    					}
    				}
    			}
    		}
    	}
    	for(Output output: outputs) {
    		Object func = Function.getFunction(this,outputs,output.getValue());
    		if(func instanceof GetAttribute) {
    			output.setAttr(Output.VALUE,func);
    		}
    	}
    }
    
    public static String getSubMappingNodeType(LinkedHashMap<String,Object> topologyTpl) {
    	if(topologyTpl != null && topologyTpl instanceof LinkedHashMap) { 
    		Object submapTpl = topologyTpl.get(SUBSTITUTION_MAPPINGS);
    		return SubstitutionMappings.stGetNodeType((LinkedHashMap<String,Object>)submapTpl);
    	}
    	return null;
    }
    
    // getters
    
	public LinkedHashMap<String,Object> getTpl() {
		return tpl;
	}
	
	public Metadata getMetadata() {
		return metaData;
	}
	
	public ArrayList<Input> getInputs() {
		return inputs;
	}
	
	public ArrayList<Output> getOutputs() {
		return outputs;
	}
	
	public ArrayList<Policy> getPolicies() {
		return policies;
	}
	
	public ArrayList<RelationshipTemplate> getRelationshipTemplates() {
		return relationshipTemplates;
	}

	public ArrayList<NodeTemplate> getNodeTemplates() {
		return nodeTemplates;
	}
	
	public ArrayList<Group> getGroups() {
		return groups;
	}
	
	public SubstitutionMappings getSubstitutionMappings() {
		return substitutionMappings;
	}

	public LinkedHashMap<String,Object> getParsedParams() {
		return parsedParams;
	}

	@Override
	public String toString() {
		return "TopologyTemplate{" +
				"tpl=" + tpl +
				", metaData=" + metaData +
				", inputs=" + inputs +
				", outputs=" + outputs +
				", relationshipTemplates=" + relationshipTemplates +
				", nodeTemplates=" + nodeTemplates +
				", customDefs=" + customDefs +
				", relTypes=" + relTypes +
				", subMappedNodeTemplate=" + subMappedNodeTemplate +
				", groups=" + groups +
				", policies=" + policies +
				", parsedParams=" + parsedParams +
				", description='" + description + '\'' +
				", graph=" + graph +
				", substitutionMappings=" + substitutionMappings +
				'}';
	}
}

/*python

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

from toscaparser.common import exception
from toscaparser.dataentity import DataEntity
from toscaparser import functions
from toscaparser.groups import Group
from toscaparser.nodetemplate import NodeTemplate
from toscaparser.parameters import Input
from toscaparser.parameters import Output
from toscaparser.policy import Policy
from toscaparser.relationship_template import RelationshipTemplate
from toscaparser.substitution_mappings import SubstitutionMappings
from toscaparser.tpl_relationship_graph import ToscaGraph
from toscaparser.utils.gettextutils import _


# Topology template key names
SECTIONS = (DESCRIPTION, INPUTS, NODE_TEMPLATES,
            RELATIONSHIP_TEMPLATES, OUTPUTS, GROUPS,
            SUBSTITUION_MAPPINGS, POLICIES) = \
           ('description', 'inputs', 'node_templates',
            'relationship_templates', 'outputs', 'groups',
            'substitution_mappings', 'policies')

log = logging.getLogger("tosca.model")


class TopologyTemplate(object):

    '''Load the template data.'''
    def __init__(self, template, custom_defs,
                 rel_types=None, parsed_params=None,
                 sub_mapped_node_template=None):
        self.tpl = template
        self.sub_mapped_node_template = sub_mapped_node_template
        if self.tpl:
            self.custom_defs = custom_defs
            self.rel_types = rel_types
            self.parsed_params = parsed_params
            self._validate_field()
            self.description = self._tpl_description()
            self.inputs = self._inputs()
            self.relationship_templates = self._relationship_templates()
            self.nodetemplates = self._nodetemplates()
            self.outputs = self._outputs()
            if hasattr(self, 'nodetemplates'):
                self.graph = ToscaGraph(self.nodetemplates)
            self.groups = self._groups()
            self.policies = self._policies()
            self._process_intrinsic_functions()
            self.substitution_mappings = self._substitution_mappings()

    def _inputs(self):
        inputs = []
        for name, attrs in self._tpl_inputs().items():
            input = Input(name, attrs)
            if self.parsed_params and name in self.parsed_params:
                input.validate(self.parsed_params[name])
            else:
                default = input.default
                if default:
                    input.validate(default)
            if (self.parsed_params and input.name not in self.parsed_params
                or self.parsed_params is None) and input.required \
                    and input.default is None:
                log.warning(_('The required parameter %s '
                              'is not provided') % input.name)

            inputs.append(input)
        return inputs

    def _nodetemplates(self):
        nodetemplates = []
        tpls = self._tpl_nodetemplates()
        if tpls:
            for name in tpls:
                tpl = NodeTemplate(name, tpls, self.custom_defs,
                                   self.relationship_templates,
                                   self.rel_types)
                if (tpl.type_definition and
                    (tpl.type in tpl.type_definition.TOSCA_DEF or
                     (tpl.type not in tpl.type_definition.TOSCA_DEF and
                      bool(tpl.custom_def)))):
                    tpl.validate(self)
                    nodetemplates.append(tpl)
        return nodetemplates

    def _relationship_templates(self):
        rel_templates = []
        tpls = self._tpl_relationship_templates()
        for name in tpls:
            tpl = RelationshipTemplate(tpls[name], name, self.custom_defs)
            rel_templates.append(tpl)
        return rel_templates

    def _outputs(self):
        outputs = []
        for name, attrs in self._tpl_outputs().items():
            output = Output(name, attrs)
            output.validate()
            outputs.append(output)
        return outputs

    def _substitution_mappings(self):
        tpl_substitution_mapping = self._tpl_substitution_mappings()
        # if tpl_substitution_mapping and self.sub_mapped_node_template:
        if tpl_substitution_mapping:
            return SubstitutionMappings(tpl_substitution_mapping,
                                        self.nodetemplates,
                                        self.inputs,
                                        self.outputs,
                                        self.sub_mapped_node_template,
                                        self.custom_defs)

    def _policies(self):
        policies = []
        for policy in self._tpl_policies():
            for policy_name, policy_tpl in policy.items():
                target_list = policy_tpl.get('targets')
                if target_list and len(target_list) >= 1:
                    target_objects = []
                    targets_type = "groups"
                    target_objects = self._get_policy_groups(target_list)
                    if not target_objects:
                        targets_type = "node_templates"
                        target_objects = self._get_group_members(target_list)
                    policyObj = Policy(policy_name, policy_tpl,
                                       target_objects, targets_type,
                                       self.custom_defs)
                    policies.append(policyObj)
        return policies

    def _groups(self):
        groups = []
        member_nodes = None
        for group_name, group_tpl in self._tpl_groups().items():
            member_names = group_tpl.get('members')
            if member_names is not None:
                DataEntity.validate_datatype('list', member_names)
                if len(member_names) < 1 or \
                        len(member_names) != len(set(member_names)):
                    exception.ExceptionCollector.appendException(
                        exception.InvalidGroupTargetException(
                            message=_('Member nodes "%s" should be >= 1 '
                                      'and not repeated') % member_names))
                else:
                    member_nodes = self._get_group_members(member_names)
            group = Group(group_name, group_tpl,
                          member_nodes,
                          self.custom_defs)
            groups.append(group)
        return groups

    def _get_group_members(self, member_names):
        member_nodes = []
        self._validate_group_members(member_names)
        for member in member_names:
            for node in self.nodetemplates:
                if node.name == member:
                    member_nodes.append(node)
        return member_nodes

    def _get_policy_groups(self, member_names):
        member_groups = []
        for member in member_names:
            for group in self.groups:
                if group.name == member:
                    member_groups.append(group)
        return member_groups

    def _validate_group_members(self, members):
        node_names = []
        for node in self.nodetemplates:
            node_names.append(node.name)
        for member in members:
            if member not in node_names:
                exception.ExceptionCollector.appendException(
                    exception.InvalidGroupTargetException(
                        message=_('Target member "%s" is not found in '
                                  'node_templates') % member))

    # topology template can act like node template
    # it is exposed by substitution_mappings.
    def nodetype(self):
        return self.substitution_mappings.node_type \
            if self.substitution_mappings else None

    def capabilities(self):
        return self.substitution_mappings.capabilities \
            if self.substitution_mappings else None

    def requirements(self):
        return self.substitution_mappings.requirements \
            if self.substitution_mappings else None

    def _tpl_description(self):
        description = self.tpl.get(DESCRIPTION)
        if description:
            return description.rstrip()

    def _tpl_inputs(self):
        return self.tpl.get(INPUTS) or {}

    def _tpl_nodetemplates(self):
        return self.tpl.get(NODE_TEMPLATES)

    def _tpl_relationship_templates(self):
        return self.tpl.get(RELATIONSHIP_TEMPLATES) or {}

    def _tpl_outputs(self):
        return self.tpl.get(OUTPUTS) or {}

    def _tpl_substitution_mappings(self):
        return self.tpl.get(SUBSTITUION_MAPPINGS) or {}

    def _tpl_groups(self):
        return self.tpl.get(GROUPS) or {}

    def _tpl_policies(self):
        return self.tpl.get(POLICIES) or {}

    def _validate_field(self):
        for name in self.tpl:
            if name not in SECTIONS:
                exception.ExceptionCollector.appendException(
                    exception.UnknownFieldError(what='Template', field=name))

    def _process_intrinsic_functions(self):
        """Process intrinsic functions

        Current implementation processes functions within node template
        properties, requirements, interfaces inputs and template outputs.
        """
        if hasattr(self, 'nodetemplates'):
            for node_template in self.nodetemplates:
                for prop in node_template.get_properties_objects():
                    prop.value = functions.get_function(self,
                                                        node_template,
                                                        prop.value)
                for interface in node_template.interfaces:
                    if interface.inputs:
                        for name, value in interface.inputs.items():
                            interface.inputs[name] = functions.get_function(
                                self,
                                node_template,
                                value)
                if node_template.requirements and \
                   isinstance(node_template.requirements, list):
                    for req in node_template.requirements:
                        rel = req
                        for req_name, req_item in req.items():
                            if isinstance(req_item, dict):
                                rel = req_item.get('relationship')
                                break
                        if rel and 'properties' in rel:
                            for key, value in rel['properties'].items():
                                rel['properties'][key] = \
                                    functions.get_function(self,
                                                           req,
                                                           value)
                if node_template.get_capabilities_objects():
                    for cap in node_template.get_capabilities_objects():
                        if cap.get_properties_objects():
                            for prop in cap.get_properties_objects():
                                propvalue = functions.get_function(
                                    self,
                                    node_template,
                                    prop.value)
                                if isinstance(propvalue, functions.GetInput):
                                    propvalue = propvalue.result()
                                    for p, v in cap._properties.items():
                                        if p == prop.name:
                                            cap._properties[p] = propvalue
                for rel, node in node_template.relationships.items():
                    rel_tpls = node.relationship_tpl
                    if rel_tpls:
                        for rel_tpl in rel_tpls:
                            for interface in rel_tpl.interfaces:
                                if interface.inputs:
                                    for name, value in \
                                            interface.inputs.items():
                                        interface.inputs[name] = \
                                            functions.get_function(self,
                                                                   rel_tpl,
                                                                   value)
        for output in self.outputs:
            func = functions.get_function(self, self.outputs, output.value)
            if isinstance(func, functions.GetAttribute):
                output.attrs[output.VALUE] = func

    @classmethod
    def get_sub_mapping_node_type(cls, topology_tpl):
        if topology_tpl and isinstance(topology_tpl, dict):
            submap_tpl = topology_tpl.get(SUBSTITUION_MAPPINGS)
            return SubstitutionMappings.get_node_type(submap_tpl)
*/