/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 * 	Balan Subramanian (bsubram@us.ibm.com)

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.tptp.wsdm.tooling.editor.capability.imports.wsdl;

import java.util.LinkedList;

import java.util.List;

import org.eclipse.tptp.wsdm.tooling.util.internal.XsdUtils;

import org.eclipse.xsd.XSDImport;

import org.eclipse.xsd.XSDInclude;

import org.eclipse.xsd.XSDSchema;

/**

 * This merges the given XSD Schema and returns the array of new schemas.<br>

 * Array contains the original XSD schema and all the Imported schemas.<br>

 * All the included schmeas merged into original schema. 

 *

 */

public class XSDSchemaMerger

{

	private XSDSchema _schema;

	private List _allResultedSchema;

	private List _allAddedSchemaURIs;

	public XSDSchemaMerger(XSDSchema schema)

	{

		_schema = schema;

		_allResultedSchema = new LinkedList();

		_allAddedSchemaURIs = new LinkedList();

		addSchema(_schema);

	}

	public XSDSchema[] merge()

	{

		XSDImport[] imports = XsdUtils.getAllXSDImports(_schema);

		for (int i = 0; i < imports.length; i++)

		{

			if (imports[i].getResolvedSchema() == null)

				continue;

			addSchema(imports[i].getResolvedSchema());

			XSDSchemaMerger merger = new XSDSchemaMerger(imports[i]

					.getResolvedSchema());

			XSDSchema[] schemas = merger.merge();

			for (int j = 0; j < schemas.length; j++)

				addSchema(schemas[j]);

		}

		XSDInclude[] includes = XsdUtils.getAllXSDIncludes(_schema);

		for (int i = 0; i < includes.length; i++)

		{

			if (includes[i].getResolvedSchema() == null)

				continue;

			addSchema(includes[i].getResolvedSchema());

			XSDSchemaMerger merger = new XSDSchemaMerger(includes[i]

					.getResolvedSchema());

			XSDSchema[] schemas = merger.merge();

			for (int j = 0; j < schemas.length; j++)

				addSchema(schemas[j]);

		}

		return (XSDSchema[]) _allResultedSchema

				.toArray(new XSDSchema[_allResultedSchema.size()]);

	}

	private void addSchema(XSDSchema givenSchema)

	{

		if(isAlreadyAdded(givenSchema))

			return;

		XSDSchema clonedSchema = (XSDSchema) givenSchema.cloneConcreteComponent(true, true);

		clonedSchema.setSchemaLocation(givenSchema.getSchemaLocation());

		XSDSchema schema = getSchema(clonedSchema.getTargetNamespace());

		if (schema != null)

			schema.getContents().addAll(clonedSchema.getContents());

		else

			_allResultedSchema.add(clonedSchema);

		String schemaLocation = clonedSchema.getSchemaLocation();

		_allAddedSchemaURIs.add(schemaLocation);

	}

	private boolean isAlreadyAdded(XSDSchema givenSchema)

	{

		String schemaLocation = givenSchema.getSchemaLocation();

		return _allAddedSchemaURIs.contains(schemaLocation);

	}

	private XSDSchema getSchema(String targetNamespace)

	{

		for (int i = 0; i < _allResultedSchema.size(); i++)

		{

			XSDSchema schema = (XSDSchema) _allResultedSchema.get(i);

			if (schema.getTargetNamespace().equals(targetNamespace))

				return schema;

		}

		return null;

	}

}

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Vector;

import javax.wsdl.Import;

import org.eclipse.emf.common.util.EList;

import org.eclipse.xsd.XSDImport;

import org.eclipse.xsd.XSDInclude;

	private XSDSchema[] _importedWsdlSchemas = new XSDSchema[0];

		_importedWsdlSchemas = loadSchemas();

			  XSDSchema importedPartSchema = getImportedWSDLSchema(importedPart.getElementName().getNamespaceURI());

			  importSchemaForElement(importedPartSchema); 

	private XSDSchema getImportedWSDLSchema(String namespace)

	{

		for(int i=0;i<_importedWsdlSchemas.length;i++)

			if(_importedWsdlSchemas[i].getTargetNamespace().equals(namespace))

				return _importedWsdlSchemas[i];

		for(int i=0;i<_importedWsdlSchemas.length;i++)

		{

			XSDImport theImports[] = XsdUtils.getAllXSDImports(_importedWsdlSchemas[i]);

			for(int j=0;j<theImports.length;j++)

				if(theImports[j].getNamespace().equals(namespace))

					return theImports[j].getResolvedSchema();

		}

		return null;

	}

	private void importSchemaForElement(XSDSchema elementSchema)

	{

		  XSDSchemaMerger merger =  new XSDSchemaMerger(elementSchema); 

		  XSDSchema[] mergedSchemas = merger.merge(); 

		  for(int i=0;i<mergedSchemas.length;i++) 

		  {

			  if(!isSchemaExistsInWsdl(mergedSchemas[i])) 

			  {

				  XSDSchema copySchema = createCopy(mergedSchemas[i]);

				  XSDSchema schema = _capabilityDefinition.createOrFindSchema(copySchema.getTargetNamespace());

				  schema.setElement(copySchema.getElement());

				  schema.updateElement(true); 

			 } 

		}		 

	}

	private boolean isSchemaExistsInWsdl(XSDSchema schema)

	{

		XSDSchema wsdlSchema = _capabilityDefinition.getSchema(schema

				.getTargetNamespace());

		if (wsdlSchema != null)

			return true;

		return false;

	}

	private XSDSchema createCopy(XSDSchema schema)

	{

		XSDSchema copySchema = (XSDSchema) schema.cloneConcreteComponent(true,

				false);

		List contents = copySchema.getContents();

		List includes = new LinkedList();

		List imports = new LinkedList();

		for (int i = 0; i < contents.size(); i++)

		{

			if (contents.get(i) instanceof XSDInclude)

				includes.add(contents.get(i));

			else if (contents.get(i) instanceof XSDImport)

			{

				XSDImport theImport = (XSDImport) contents.get(i);				

				theImport.setSchemaLocation(null);

				imports.add(theImport);

			}

		}

		contents.removeAll(includes);

		contents.removeAll(imports);

		contents.addAll(0, imports);		

		copySchema.updateElement(true);

		return copySchema;

	}