/*-
 * ============LICENSE_START=======================================================
 * org.openecomp.aai
 * ================================================================================
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * 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.
 * ============LICENSE_END=========================================================
 */

package org.openecomp.aai.ingestModel;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.dynamic.DynamicType;
import org.eclipse.persistence.internal.dynamic.DynamicTypeImpl;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.jaxb.JAXBContextProperties;
import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContextFactory;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.oxm.XMLField;
import org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping;

import org.openecomp.aai.domain.model.AAIResource;
import org.openecomp.aai.domain.model.AAIResourceKey;
import org.openecomp.aai.domain.model.AAIResourceKeys;
import org.openecomp.aai.domain.model.AAIResources;
import org.openecomp.aai.exceptions.AAIException;
import org.openecomp.aai.logging.ErrorLogHelper;
import org.openecomp.aai.util.AAIConfig;
import org.openecomp.aai.util.AAIConstants;
import org.openecomp.aai.util.FileWatcher;
import com.att.eelf.configuration.EELFLogger;
import com.att.eelf.configuration.EELFManager;
import com.google.common.base.CaseFormat;
import com.google.common.base.Splitter;
import com.google.common.collect.Multimap;

/**
 * The Class IngestModelMoxyOxm.
 */
public class IngestModelMoxyOxm
{

	private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(IngestModelMoxyOxm.class);

	public static HashMap<String, AAIResources> aaiResourceContainer;
	public static HashMap<String, DbMaps> dbMapsContainer;

	private static HashMap<String, Timer> timers = new HashMap<String,Timer>();

	/**
	 * The main method.
	 *
	 * @param args the arguments
	 * @throws Exception the exception
	 */
	public static void main(String[] args) throws Exception {

		String _apiVersion = AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP);

		if (args.length > 0) { 
			if (args[0] != null) {
				_apiVersion = args[0];
			}
		}
		ArrayList<String> apiVersions = new ArrayList<String>();
		apiVersions.add(_apiVersion);
		final IngestModelMoxyOxm m = new IngestModelMoxyOxm();
		m.init(apiVersions, false);

		ArrayList<String> endpoints = new ArrayList<String>();

		for (Map.Entry<String, AAIResources> ent: aaiResourceContainer.entrySet()) {

			AAIResources aaiResources = ent.getValue();
			DynamicJAXBContext jaxbContext = aaiResources.getJaxbContext();
			for (Map.Entry<String, AAIResource> aaiResEnt : aaiResources.getAaiResources().entrySet()) { 
				AAIResource aaiRes = aaiResEnt.getValue();

				String uri = aaiRes.getUri();
				if (uri != null) { 
					endpoints.add(uri);
					DynamicType dt = jaxbContext.getDynamicType(aaiRes.getResourceClassName());
					if (dt.containsProperty("relationshipList")) {
						endpoints.add(uri + "/relationship-list/relationship");
					}
				}
			}
			Collections.sort(endpoints);
			for (String endpoint : endpoints) {
				if (!endpoint.contains("/aai-internal/")) { 
					System.out.println(endpoint);
				}
			}
		}

		System.exit(0);
	}

	/**
	 * Inits the.
	 *
	 * @param apiVersions the api versions
	 * @throws Exception the exception
	 */
	public synchronized void init(ArrayList<String> apiVersions) throws AAIException {
		final IngestModelMoxyOxm m = new IngestModelMoxyOxm();
		m.init(apiVersions, true);
	}

	/**
	 * Inits the.
	 *
	 * @param apiVersions the api versions
	 * @param setTimer the set timer
	 * @throws AAIException If AAIConfig is missing necessary properties
	 * @throws Exception the exception
	 */
	public synchronized void init(ArrayList<String> apiVersions, Boolean setTimer) throws AAIException {

		aaiResourceContainer = new HashMap<String, AAIResources>();
		dbMapsContainer = new HashMap<String, DbMaps>();

		final IngestModelMoxyOxm m = new IngestModelMoxyOxm();

		for (String apiVersion : apiVersions) { 

			String relationshipUtils = "org.openecomp.aai.dbmap.RelationshipUtils";
			final String thisRelationshipUtils = relationshipUtils;

			final String thisApiVersion = apiVersion;
			final String schemaFile = AAIConstants.AAI_HOME_ETC_OXM + "aai_oxm_" + apiVersion + ".xml";

			m.loadSchema(apiVersion, schemaFile, relationshipUtils);

			if (!setTimer) continue;

			TimerTask task = null;
			task = new FileWatcher ( new File(schemaFile)) {
				protected void onChange( File file ) {
					m.loadSchema(thisApiVersion, schemaFile, thisRelationshipUtils);
				}
			};

			if (!timers.containsKey(apiVersion)) {
				Timer timer = new Timer();
				timer.schedule( task , new Date(), 10000 );
				timers.put(apiVersion,  timer);

			}
		}
		if (apiVersions.contains(AAIConfig.get(AAIConstants.AAI_DEFAULT_API_VERSION_PROP))) { 
			m.createPropertyAndNodeVersionInfoMapFromDbMaps();

			for (Map.Entry<String, AAIResources> ent: aaiResourceContainer.entrySet()) {
				String apiVersion = ent.getKey();
				AAIResources aaiResources = ent.getValue();

				DbMaps dbMap = dbMapsContainer.get(apiVersion);

				for (Map.Entry<String, AAIResource> aaiResEnt : aaiResources.getAaiResources().entrySet()) { 
					AAIResource aaiRes = aaiResEnt.getValue();
					aaiRes.setPropertyDataTypeMap(dbMap.PropertyDataTypeMap); 
					aaiRes.setNodeKeyProps(dbMap.NodeKeyProps);
					aaiRes.setNodeNameProps(dbMap.NodeNameProps);
					aaiRes.setNodeMapIndexedProps(dbMap.NodeMapIndexedProps);
				}
			}
		}
	}

	/**
	 * Load schema.
	 *
	 * @param apiVersion the api version
	 * @param schemaFile the schema file
	 * @param relationshipUtils the relationship utils
	 * @return the dynamic JAXB context
	 */
	private DynamicJAXBContext loadSchema(String apiVersion,
			String schemaFile, 
			String relationshipUtils)  {

		AAIResources aaiResources = new AAIResources();
		DbMaps dbMaps = new DbMaps();
		DynamicJAXBContext jaxbContext = null;

		try {

			InputStream iStream = new FileInputStream(new File(schemaFile));

			Map<String, Object> properties = new HashMap<String, Object>(); 
			properties.put(JAXBContextProperties.OXM_METADATA_SOURCE, iStream); 

			jaxbContext = 
					DynamicJAXBContextFactory.createContextFromOXM(IngestModelMoxyOxm.class.getClassLoader(), properties);

			aaiResources.setJaxbContext(jaxbContext);
			String rootClassName = "inventory.aai.openecomp.org." + apiVersion + ".Inventory";

			if ("v2".equals(apiVersion)) { 
				rootClassName = "inventory.aai.openecomp.org.Inventory";
			} 

			DynamicTypeImpl t = (DynamicTypeImpl)jaxbContext.getDynamicType(rootClassName);

			lookAtDynamicResource("Inventory",
					"inventory.aai.openecomp.org." + apiVersion, 
					jaxbContext, 
					t,
					1, "", "", apiVersion, "/" + apiVersion, false, aaiResources, dbMaps, relationshipUtils);

		} catch (Exception e) {
			ErrorLogHelper.logException(new AAIException("AAI_3000", e));
		}

		LOGGER.info("---> Loading " + apiVersion + " in aaiResourceContainer");
		aaiResourceContainer.put(apiVersion,  aaiResources);

		createDbMapsfromAAIResources(aaiResources, dbMaps);

		LOGGER.info("---> Loading " + apiVersion + " in dbMapsContainer");
		dbMapsContainer.put(apiVersion,  dbMaps);

		return jaxbContext;
	}

	/**
	 * Cleanup.
	 */
	public void cleanup() {
		aaiResourceContainer.clear();
		dbMapsContainer.clear();
	}

	/**
	 * Look at dynamic resource.
	 *
	 * @param resource the resource
	 * @param pojoBase the pojo base
	 * @param jaxbContext the jaxb context
	 * @param t the t
	 * @param depth the depth
	 * @param parent the parent
	 * @param namespace the namespace
	 * @param apiVersion the api version
	 * @param url the url
	 * @param container the container
	 * @param aaiResources the aai resources
	 * @param dbMaps the db maps
	 * @param relationshipUtils the relationship utils
	 * @throws ClassNotFoundException the class not found exception
	 * @throws NoSuchFieldException the no such field exception
	 * @throws SecurityException the security exception
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	private void lookAtDynamicResource(String resource, 
			String pojoBase, 
			DynamicJAXBContext jaxbContext, 
			DynamicTypeImpl t,
			int depth,
			String parent,
			String namespace,
			String apiVersion,
			String url, 
			boolean container, 
			AAIResources aaiResources,
			DbMaps dbMaps,
			String relationshipUtils
			) 
					throws ClassNotFoundException, NoSuchFieldException, SecurityException,  IOException {

		String className = pojoBase + "." + CaseFormat.UPPER_CAMEL.to(CaseFormat.UPPER_CAMEL, resource);

		AAIResource parentResource = aaiResources.getAaiResources().get(parent);

		AAIResources siblings = null;

		if (parentResource == null) { 
			String fullName = "/" +  resource;
			AAIResource aaiRes = new AAIResource();
			aaiRes.setFullName(fullName);
			aaiRes.setSimpleName(resource);
			aaiRes.setResourceType("container");
			aaiRes.setResourceClassName(className);
			aaiRes.setApiVersion(apiVersion);

			aaiResources.getAaiResources().put(fullName, aaiRes);
			parentResource = aaiRes;
		}

		if (depth >= 50) return;

		siblings = parentResource.getChildren();

		if (depth == 2) { 
			namespace = resource;
		}
		if (depth >= 50) {
			return;
		}

		/*		if ("Actions".equals(namespace) || "Search".equals(namespace)) {
			return;
		}*/

		ClassDescriptor cd = t.getDescriptor();

		createDbMapsfromOXM(cd.getProperties(), resource, dbMaps);

		

		Vector<DatabaseMapping> dm = cd.getMappings();		

		for (DatabaseMapping dmInst : dm) {
			String dmName = dmInst.getAttributeName();

			ClassDescriptor cd2 = dmInst.getReferenceDescriptor();
			if (cd2 != null) { 

				String newClassName = cd2.getJavaClassName();
				//				
				if (newClassName.contains("RelationshipList")) {
					continue;
				}

				DynamicTypeImpl newDt = (DynamicTypeImpl)jaxbContext.getDynamicType(newClassName);

				if (dmInst instanceof XMLCompositeCollectionMapping) { 
					String simpleName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, dmName);
					//					System.out.println(spaces + "+ List of A&AI Object named " + simpleName);

					String hypName = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, simpleName);

					String fullName = parent + "/" + simpleName;

					//Class<?> newClazz = Class.forName(newClassName);
					AAIResource aaiRes = new AAIResource();

					if ("cvlan-tag-entry".equals(hypName)) {
					}

					ClassDescriptor cd3 = newDt.getDescriptor();

					boolean allowDirectWrite = true;
					if (cd3.getProperties().containsKey("allowDirectWrite")) {
						if (cd3.getProperties().get("allowDirectWrite").equals("false")) {
							allowDirectWrite = false;
						}
					}
					

					boolean allowDirectRead = true;
					if (cd3.getProperties().containsKey("allowDirectRead")) {
						if (cd3.getProperties().get("allowDirectRead").equals("false")) {
							allowDirectRead = false;
						}
					}
					
					List<DatabaseField> dbfList = cd3.getPrimaryKeyFields();
					ArrayList<String> keyFields = new ArrayList<String>();

					if (dbfList != null) { 
						for (DatabaseField dbf : dbfList) {
							String name = dbf.getName();
							name = name.substring(0, name.indexOf('/'));
							keyFields.add(name);
						}
					}
					Vector<DatabaseMapping> dm2 = cd3.getMappings();
					for (DatabaseMapping dmInst2 : dm2) {
						String dmName2= CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmInst2.getAttributeName());
						DatabaseField xf2 = dmInst2.getField();
						if (dmInst2.getProperties().containsKey("autoGenerateUuid")) { 
							if (dmInst2.getProperties().get("autoGenerateUuid").equals("true")) { 
								aaiRes.getAutoGenUuidFields().add(dmName2);
							}
						}
						if (xf2 instanceof XMLField) { 
							XMLField x = (XMLField)xf2;
							if (x != null) { 
								if (x.isRequired()) {
									aaiRes.getRequiredFields().add(dmName2);
								}
							}
							
						}
						try {
							Class<?> xf2Clazz = xf2.getType();
							if (xf2Clazz.getSimpleName().equals("String")) {
								if (dmInst2 instanceof XMLCompositeDirectCollectionMapping) { 
									aaiRes.getStringListFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
								} else { 
									aaiRes.getStringFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
								}
							} else if (xf2Clazz.getSimpleName().toLowerCase().contains("long")) {
								aaiRes.getLongFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
							} else if (xf2Clazz.getSimpleName().toLowerCase().contains("int")) {
								aaiRes.getIntFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
							} else if (xf2Clazz.getSimpleName().toLowerCase().contains("short")) {
								aaiRes.getShortFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
							} else if (xf2Clazz.getSimpleName().toLowerCase().contains("boolean")) {
								aaiRes.getBooleanFields().add(CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmName2));
							}
						} catch (Exception e) {  // this xf2.getType() throws null pointer when I try to get the type and it doesn't have one
							;
						}
					}

					// get the key(s) from DbRules
					String uriKey = "";
					LinkedHashMap<String, ArrayList<String>> itemKeyList = new LinkedHashMap<String, ArrayList<String>>();

					aaiRes.setApiVersion(apiVersion);
					itemKeyList.put(hypName, new ArrayList<String>());
					for (String thisKey : keyFields) { 
						String pathParamName = hypName + "-" + thisKey;

						AAIResourceKey aaiResKey = new AAIResourceKey();
						aaiResKey.setKeyName(thisKey);
						aaiResKey.setDnCamKeyName(CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, pathParamName));
						aaiResKey.setPathParamName(pathParamName);

						for (DatabaseMapping dmInst2 : dm2) {
							String dmName2= CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN,dmInst2.getAttributeName());
							if (dmName2.equals(thisKey)){ 
								DatabaseField xf2 = dmInst2.getField();
								aaiResKey.setKeyType(xf2.getType().getSimpleName());
								break;
							}
						}

						aaiRes.getAaiResourceKeys().getAaiResourceKey().add(aaiResKey);

						if (siblings != null) {
							siblings.getAaiResources().put(fullName, aaiRes);
						}

						uriKey += "/{" + pathParamName + "}";
					}

					String newUri = url + "/" + hypName + uriKey;


					if ("v2".equals(apiVersion)) { 
						aaiRes.setResourceClassName("inventory.aai.openecomp.org." + simpleName);
					} else { 
						aaiRes.setResourceClassName("inventory.aai.openecomp.org." + apiVersion + "." + simpleName);
					}
					
					aaiRes.setAllowDirectWrite(allowDirectWrite);
					aaiRes.setAllowDirectRead(allowDirectRead);
					aaiRes.setNamespace(namespace);
					aaiRes.setSimpleName(simpleName);
					
					if (!aaiResources.getResourceLookup().containsKey(simpleName)) {
						aaiResources.getResourceLookup().put(simpleName, aaiRes);
					}
					
					aaiRes.setFullName(fullName);
					aaiRes.setUri(newUri);
					aaiRes.setResourceType("node");
					if ("v2".equals(apiVersion)) { 
						aaiRes.setRelationshipListClass("inventory.aai.openecomp.org.RelationshipList");
					} else { 
						aaiRes.setRelationshipListClass("inventory.aai.openecomp.org." + apiVersion + ".RelationshipList");
					}
					aaiRes.setRelationshipUtils(relationshipUtils);

					if (parentResource != null) { 
						aaiRes.setParent(parentResource);
					} else { 
						aaiRes.setParent(aaiRes);
					}

					aaiResources.getAaiResources().put(fullName, aaiRes);

					if (siblings != null) {
						siblings.getAaiResources().put(fullName, aaiRes);
					}
//					AAIResource ancestor = parentResource;
//
//					boolean recursiveEntity = false;
//					while (ancestor != null) { 
//
//						if (ancestor.getSimpleName().equals(aaiRes.getSimpleName())) {
//							recursiveEntity = true;
//							// attach it to the container that contains the resource above this one with the same name
//							if (ancestor.getParent() != null && ancestor.getParent().getResourceType().equals("container")) {
//								AAIResource recurseHere = ancestor.getParent();
//								aaiRes.setRecurseToResource(recurseHere);
//							}
//							break;
//						}
//						ancestor = ancestor.getParent();
//
//					}
//					if (recursiveEntity == false) { 
						lookAtDynamicResource(cd2.getJavaClass().getSimpleName(),
								pojoBase, 
								jaxbContext, 
								newDt,
								(depth + 1), fullName, namespace, apiVersion, newUri, false, aaiResources, dbMaps,
								relationshipUtils);
//					}
				} else { 
					String simpleName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, dmName);
					String fullName = parent + "/" +  simpleName;
					//					System.out.println(spaces + "+ Container of A&AI Object named " + simpleName);

					AAIResource aaiRes = new AAIResource();
					if (parentResource != null) { 
						aaiRes.setParent(parentResource);
					} else { 
						aaiRes.setParent(aaiRes);
					}
					aaiRes.setAllowDirectWrite(true);
					aaiRes.setAllowDirectRead(true);
					aaiRes.setFullName(fullName);
					aaiRes.setSimpleName(simpleName);
					if (!aaiResources.getResourceLookup().containsKey(simpleName)) {
						aaiResources.getResourceLookup().put(simpleName, aaiRes);
					}
					aaiRes.setResourceType("container");

					if ("v2".equals(apiVersion)) { 
						aaiRes.setResourceClassName("inventory.aai.openecomp.org." + simpleName);
						aaiRes.setRelationshipListClass("inventory.aai.openecomp.org.RelationshipList");
					} else {
						aaiRes.setResourceClassName("inventory.aai.openecomp.org." + apiVersion + "." + simpleName);
						aaiRes.setRelationshipListClass("inventory.aai.openecomp.org." + apiVersion  + ".RelationshipList");
					}
					aaiRes.setApiVersion(apiVersion);

					aaiResources.getAaiResources().put(fullName, aaiRes);
					aaiRes.setRelationshipUtils(relationshipUtils);

					String hypName = CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, simpleName);

					if (siblings != null) {
						siblings.getAaiResources().put(fullName, aaiRes);
					}

					lookAtDynamicResource(cd2.getJavaClass().getSimpleName(),
							pojoBase, 
							jaxbContext, 
							(DynamicTypeImpl)jaxbContext.getDynamicType(newClassName),
							(depth + 1), fullName, namespace, apiVersion, url + "/" + hypName, false, aaiResources, dbMaps,
							relationshipUtils);


				}
			}
		}
	}

	/**
	 * Creates the db mapsfrom OXM.
	 *
	 * @param propMap the prop map
	 * @param resource the resource
	 * @param dbMaps the db maps
	 */
	private void createDbMapsfromOXM(Map<?, ?> propMap, String resource, DbMaps dbMaps) {
		String nodeType = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, resource);
		if ("cvlan-tag-entry".equals(nodeType)) {
			nodeType = "cvlan-tag";
		}

		// if we have nodes dependent on multiple nodes we might revisit the node again - skip then
		if (propMap.size() > 1 && !dbMaps.NodeMapIndexedProps.containsKey(nodeType)) {

			if (propMap.containsKey("nameProps")) 
				dbMaps.NodeNameProps.putAll(nodeType, 
						(Iterable<String>) fromCommaSeparatedString(propMap.get("nameProps").toString()));

			if (propMap.containsKey("indexedProps")) 
				dbMaps.NodeMapIndexedProps.putAll(nodeType, 
						(Iterable<String>) fromCommaSeparatedString(propMap.get("indexedProps").toString()));

			if (propMap.containsKey("dependentOn")) 
				dbMaps.NodeDependencies.putAll(nodeType, 
						(Iterable<String>) fromCommaSeparatedString(propMap.get("dependentOn").toString()));

			if (propMap.containsKey("alternateKeys1")) 
				dbMaps.NodeAltKey1Props.putAll(nodeType, 
						(Iterable<String>) fromCommaSeparatedString(propMap.get("alternateKeys1").toString()));

			if (propMap.containsKey("uniqueProps")) 
				dbMaps.NodeMapUniqueProps.putAll(nodeType, 
						(Iterable<String>) fromCommaSeparatedString(propMap.get("uniqueProps").toString()));

			// build EdgeInfoMap
			if (propMap.containsKey("edgeInfo")) {
				int i = 0;
				Iterable<String> edgeInfoIterable = (Iterable<String>) fromCommaSeparatedString(propMap.get("edgeInfo").toString());
				Iterator<String> edgeInfoIterator = edgeInfoIterable.iterator();
				while(edgeInfoIterator.hasNext()) {
					String propName = edgeInfoIterator.next();
					dbMaps.EdgeInfoMap.put(i++, propName);
				}
			}
		}
	}

	/**
	 * Creates the db mapsfrom AAI resources.
	 *
	 * @param aaiResources the aai resources
	 * @param dbMaps the db maps
	 */
	private void createDbMapsfromAAIResources(AAIResources aaiResources, DbMaps dbMaps) {

		for (String  resource: aaiResources.getAaiResources().keySet()) {

			AAIResource aaiResource = aaiResources.getAaiResources().get(resource);
			String nodeType = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,aaiResource.getSimpleName());

			if (nodeType.equals("cvlan-tag-entry"))
				nodeType = "cvlan-tag";	

			// Build NodeNamespace
			if (aaiResource.getNamespace() != null && !aaiResource.getNamespace().equalsIgnoreCase("search")) 
				// oamNetworks is also defined under the search namespace - do not want that namespace 
				dbMaps.NodeNamespace.put(nodeType, CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, aaiResource.getNamespace()));

			// only process one nodetype once 
			if (dbMaps.NodeProps.containsKey(nodeType)) 
				continue;

			// Build NodePlural
			if (aaiResource.getPluralName() != null && !aaiResource.getPluralName().equals(aaiResource.getNamespace())) 
				// dont want resources which are namespaces themselves in map
				dbMaps.NodePlural.put(nodeType, CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_HYPHEN, aaiResource.getPluralName()));

			// Build NodeProps
			dbMaps.NodeProps.putAll(nodeType, aaiResource.getAllFields());

			// build ReservedNames
			if (nodeType.equalsIgnoreCase("reserved-prop-names")) {
				for (String propName: aaiResource.getAllFields()) {
					dbMaps.ReservedPropNames.put(propName, "");
				}
			}

			// Build NodekeyProps
			AAIResourceKeys aaiResKeys = aaiResource.getAaiResourceKeys();
			List<String> keyList = new ArrayList<String>();
			for (AAIResourceKey rk : aaiResKeys.getAaiResourceKey()) { 
				String keyProp = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN,rk.getKeyName());
				if (!keyList.contains(keyProp))
					keyList.add(keyProp);
			}				
			dbMaps.NodeKeyProps.putAll(nodeType, (Iterable<String>)keyList);

			// Build PropertyDataTypeMap
			for (String propName: aaiResource.getBooleanFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName))
					dbMaps.PropertyDataTypeMap.put(propName, "Boolean");
				else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("Boolean"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
			for (String propName: aaiResource.getShortFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName))
					dbMaps.PropertyDataTypeMap.put(propName, "Integer");
				else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("Integer"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
			for (String propName: aaiResource.getLongFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName)) {
					if (propName.contains("-ts"))
						dbMaps.PropertyDataTypeMap.put(propName, "Long");
					else
						dbMaps.PropertyDataTypeMap.put(propName, "Integer");
				} else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("Integer"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
			for (String propName: aaiResource.getIntFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName))
					dbMaps.PropertyDataTypeMap.put(propName, "Integer");
				else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("Integer"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
			for (String propName: aaiResource.getStringFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName))
					dbMaps.PropertyDataTypeMap.put(propName, "String");
				else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("String"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
			for (String propName: aaiResource.getStringListFields()) {
				if (nodeType.equalsIgnoreCase("edge-prop-names")) // these properties are in mixed format in DB
					propName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, propName);
				if (propName.equals("sVCINFRA")) propName = "SVC-INFRA";
				if (propName.equals("sVCINFRAREV")) propName = "SVC-INFRA-REV";
				if (!dbMaps.PropertyDataTypeMap.containsKey(propName))
					dbMaps.PropertyDataTypeMap.put(propName, "Set<String>");
				else if (!dbMaps.PropertyDataTypeMap.get(propName).equals("Set<String>"))
					System.out.println(propName + "defined with mis-matched types in oxm file");
			}
		}

	}


	/**
	 * Creates the property and node version info map from db maps.
	 */
	private void createPropertyAndNodeVersionInfoMapFromDbMaps() {
		DbMaps dbMaps = null;
		String previousApiVersion = null;
		List<Integer> apiIntegerKeySet = new ArrayList<Integer>();
		for ( String vers : dbMapsContainer.keySet()) {
			apiIntegerKeySet.add(Integer.valueOf(vers.substring(1)));
		}
		ArrayList<Integer> apiIntegerVersionsList = (ArrayList<Integer>) asSortedList(apiIntegerKeySet);
		String apiVersion;
		for ( Integer apiIntegerVersion : apiIntegerVersionsList) {
			apiVersion = "v" + apiIntegerVersion;
			System.out.println("apiVersion=" + apiVersion);
			dbMaps = dbMapsContainer.get(apiVersion);

			if (previousApiVersion != null) { // when running more than one version
				dbMaps.PropertyVersionInfoMap.putAll(dbMapsContainer.get(previousApiVersion).PropertyVersionInfoMap);
				dbMaps.NodeVersionInfoMap.putAll(dbMapsContainer.get(previousApiVersion).NodeVersionInfoMap);
			}
			
			Iterator<String> nodeTypeIterator = dbMaps.NodeProps.keySet().iterator();
			while( nodeTypeIterator.hasNext() ){
				String nType = nodeTypeIterator.next();
				if (!dbMaps.NodeVersionInfoMap.containsKey(nType)) {
					dbMaps.NodeVersionInfoMap.put(nType, apiVersion);
				}
				Collection <String> nodePropsForType =  dbMaps.NodeProps.get(nType);
				Iterator <String> propIter = nodePropsForType.iterator();
				while( propIter.hasNext() ){
					String propName = propIter.next();
					String infoKey = nType + "|" + propName;
					if( ! dbMaps.PropertyVersionInfoMap.containsKey(infoKey) ){
						// We haven't seen this one yet -- add it in.
						dbMaps.PropertyVersionInfoMap.put(infoKey, apiVersion);
					}
				}
			}
			dbMapsContainer.put(apiVersion, dbMaps);
			previousApiVersion = apiVersion;
		}
	}

	/**
	 * As sorted list.
	 *
	 * @param <T> the generic type
	 * @param c the c
	 * @return the list
	 */
	private <T extends Comparable<? super T>> List<T> asSortedList(Collection<T> c) {
		List<T> list = new ArrayList<T>(c);
		java.util.Collections.sort(list);
		return list;
	}

	/**
	 * From comma separated string.
	 *
	 * @param string the string
	 * @return the iterable
	 */
	public Iterable<String> fromCommaSeparatedString( String string ) {
		Iterable<String> split = Splitter.on( "," ).omitEmptyStrings().trimResults().split( string );
		return split;
	}

	/**
	 * Pretty print map.
	 *
	 * @param map the map
	 * @return the string
	 */
	public String prettyPrintMap(Multimap<String, String> map) {
		StringBuilder sb = new StringBuilder();
		sb.append('\n');
		for (String key:map.keySet()) {
			sb.append('\t');
			sb.append(key);
			sb.append('=').append('"');
			sb.append(map.get(key));
			sb.append('"');
			sb.append('\n');
		}
		return sb.toString();
	}

	/**
	 * Pretty print map.
	 *
	 * @param map the map
	 * @return the string
	 */
	public String prettyPrintMap(Map<?, String> map) {
		StringBuilder sb = new StringBuilder();
		sb.append('\n');
		for (Object key:map.keySet()) {
			sb.append('\t');
			sb.append(key);
			sb.append('=').append('"');
			sb.append(map.get(key));
			sb.append('"');
			sb.append('\n');
		}
		return sb.toString();
	}

}