/*******************************************************************************
 * Copyright (c) 2005, 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.ws.tests.unittest;

import java.io.File;

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.EList;
import org.eclipse.wst.ws.internal.model.v10.registry.Name;
import org.eclipse.wst.ws.internal.model.v10.registry.Registry;
import org.eclipse.wst.ws.internal.model.v10.registry.RegistryFactory;
import org.eclipse.wst.ws.internal.model.v10.taxonomy.Category;
import org.eclipse.wst.ws.internal.model.v10.taxonomy.Taxonomy;
import org.eclipse.wst.ws.internal.model.v10.taxonomy.TaxonomyFactory;
import org.eclipse.wst.ws.internal.model.v10.uddiregistry.Taxonomies;
import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistry;
import org.eclipse.wst.ws.internal.model.v10.uddiregistry.UDDIRegistryFactory;
import org.eclipse.wst.ws.internal.registry.IRegistryManager;
import org.eclipse.wst.ws.internal.registry.RegistryService;
import org.eclipse.wst.ws.internal.registry.UDDIRegistryService;

public class RegistryTests extends TestCase
{
	public static Test suite ()
	{
		return new TestSuite(RegistryTests.class);
	}

	/**
	 * Creates a new Taxonomy model and passes it to
	 * <code>RegistryService.saveTaxonomy()</code>
	 * where the model is persisted to a platform
	 * specified temporary filesystem location.
	 */
	public void test_RegistryService_saveTaxonomy ()
	{
		System.out.println("STARTING test_RegistryService_saveTaxonomy");
		try
		{
			System.out.println("Creating RegistryService and Taxonomy");
			RegistryService registryService = RegistryService.instance();			
			Taxonomy taxonomy = registryService.newTaxonomy();

			System.out.println("Building a simple Taxonomy model");
			taxonomy.setId("my.taxonomy");
			taxonomy.setName("My Taxonomy");
			EList list = taxonomy.getCategory();
			Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
			category1.setName("My first category");
			category1.setCode("1");
			Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
			category2.setName("My second category");
			category2.setCode("2");
			Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
			category3.setName("My third category");
			category3.setCode("2.1");
			category2.getCategory().add(category3);
			list.add(category1);
			list.add(category2);

			File file = File.createTempFile("taxonomy.",".xml");
			System.out.println("Saving the Taxonomy model to "+file.getCanonicalPath());
			registryService.saveTaxonomy(file.toURL(),taxonomy);
		}
		catch (Exception exc)
		{
			exc.printStackTrace();
			fail("Unexpected Throwable ["+exc.getMessage()+"]");
		}
		finally
		{
			System.out.println("FINISHED test_RegistryService_saveTaxonomy\n");
		}
	}

	/**
	 * Creates a new UDDI Registry model and passes it to
	 * <code>RegistryService.saveRegistry()</code>
	 * where the model is persisted to a platform
	 * specified temporary filesystem location.
	 */
	public void test_RegistryService_saveRegistry ()
	{
		System.out.println("STARTING test_RegistryService_saveRegistry");
		try
		{
			System.out.println("Creating RegistryService, UDDIRegistryService and Registry");
			RegistryService registryService = RegistryService.instance();
			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();			
			UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();

			System.out.println("Building a simple Registry model");
			uddiRegistry.setId("my.registry");
			uddiRegistry.setVersion("2.0");
			uddiRegistry.setDiscoveryURL("http://some.discovery.url");
			uddiRegistry.setPublicationURL("http://some.publication.url");
			uddiRegistry.setDefaultLogin("hockeyfanatic");
			Name name = RegistryFactory.eINSTANCE.createName();
			name.setValue("My Registry");
			uddiRegistry.getName().add(name);
			Taxonomy taxonomyRef = registryService.newTaxonomy();
			taxonomyRef.setRef("my.taxonomy");
			Taxonomies t = uddiRegistry.getTaxonomies();
			if (t == null)
			{
				t = UDDIRegistryFactory.eINSTANCE.createTaxonomies();
				uddiRegistry.setTaxonomies(t);
			}
			EList e = t.getTaxonomy();
			e.add(taxonomyRef);

			File file = File.createTempFile("registry.",".xml");
			System.out.println("Saving the Registry model to "+file.getCanonicalPath());
			registryService.saveRegistry(file.toURL(),uddiRegistry);
		}
		catch (Exception exc)
		{
			exc.printStackTrace();
			fail("Unexpected Throwable ["+exc.getMessage()+"]");
		}
		finally
		{
			System.out.println("FINISHED test_RegistryService_saveRegistry\n");
		}
	}

	/**
	 * Creates a new UDDI Registry model and a new Taxonomy
	 * model, associates the latter with the former, and
	 * drives <code>IRegistryManager.saveRegistry()</code>
	 * to save the models and the index document to the
	 * preferred location of the default registry manager.
	 */
	public void test_RegistryManager_saveRegistry()
	{
		System.out.println("STARTING test_RegistryManager_saveRegistry");
		try {
			System.out.println("Creating RegistryService and Getting RegistryManager");	
			RegistryService registryService = RegistryService.instance();	
			IRegistryManager regManager = registryService.getDefaultRegistryManager();
			System.out.println("The location of the default index is " + regManager.getURL());

			//build the hockey taxonomy
			System.out.println("Building the hockey Taxonomy model");
			Taxonomy hockeyTaxonomy = registryService.newTaxonomy();
			hockeyTaxonomy.setId("hockey.taxonomy");
			hockeyTaxonomy.setName("hockey Taxonomy");
			EList list = hockeyTaxonomy.getCategory();
			Category category1 = TaxonomyFactory.eINSTANCE.createCategory();
			Category category4 = TaxonomyFactory.eINSTANCE.createCategory();
			category4.setName("Pro");
			category4.setCode("4");
			Category category5 = TaxonomyFactory.eINSTANCE.createCategory();
			category5.setName("AHL");
			category5.setCode("4.1");
			Category category6 = TaxonomyFactory.eINSTANCE.createCategory();
			category6.setName("NHL");
			category6.setCode("4.2");
			category1.setName("Junior");
			category1.setCode("1");
			Category category2 = TaxonomyFactory.eINSTANCE.createCategory();
			category2.setName("Midget");
			category2.setCode("2");
			Category category3 = TaxonomyFactory.eINSTANCE.createCategory();
			category3.setName("Bantam");
			category3.setCode("3");
			category4.getCategory().add(category5);
			category4.getCategory().add(category6);
			list.add(category1);
			list.add(category2);
			list.add(category3);
			list.add(category4);
			
			//save the hockey taxonomy
			Taxonomy hockeyTaxonomyRef = regManager.saveTaxonomy(hockeyTaxonomy);

			//make the hockey registry
			System.out.println("Building the hockey Registry model");
			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();			
			UDDIRegistry uddiRegistry = uddiRegistryService.newUDDIRegistry();
			uddiRegistry.setId("hockey.registry");
			uddiRegistry.setVersion("2.0");
			uddiRegistry.setDefaultLogin("hockeyfanatic");
			uddiRegistry.setDiscoveryURL("http://some.discovery.url");
			uddiRegistry.setPublicationURL("http://some.publication.url");
			Name name = RegistryFactory.eINSTANCE.createName();
			name.setValue("Hockey Registry");
			uddiRegistry.getName().add(name);

			// Add the reference to the taxonomy (saved above) to the registry.  
			uddiRegistryService.addTaxonomy(uddiRegistry,hockeyTaxonomyRef);

			/*
			UDDITaxonomyFinder UITFinder = new UDDITaxonomyFinder();
			regManager.addTaxonomyFinder(uddiRegistry.getClass().getName(),UITFinder);
			*/
			// Save the thing.
			System.out.println("Saving the hockey Registry model");
			regManager.saveRegistry(uddiRegistry);
		}
		catch (Exception exc)
		{
			exc.printStackTrace();
			fail("Unexpected Throwable ["+exc.getMessage()+"]");
		}
		finally
		{
			System.out.println("FINISHED test_RegistryManager_saveRegistry\n");
		}
	}

	/**
	 * Loads the registry and taxonomy in the index created in
	 * test_RegistryManager_saveRegistry, then asserts that the
	 * content of the model is what we expect.
	 */
	public void test_RegistryManager_loadRegistry()
	{
		System.out.println("STARTING test_RegistryManager_loadRegistry");
		try {
			// Setup
			System.out.println("Creating RegistryService and Getting RegistryManager");	
			RegistryService registryService = RegistryService.instance();	
			IRegistryManager regManager = registryService.getDefaultRegistryManager();
			
			// Get the one registry URI we expect, and load the registry.
			String[] registries = regManager.getRegistryURIs();
			assertEquals("Unexpected number of registries "+registries.length,registries.length,1);
			String uri = registries[0];
			System.out.println("Loading registry " + uri);
			Registry registry = regManager.loadRegistry(uri);
			System.out.println("Found registry " + registry.getId());
			assertEquals("Did not find hockey registry","hockey.registry",registry.getId());
			
			// It's supposed to be a UDDI registry. Verify it and check its values.
			assertTrue("Registry is not a UDDIRegistry",(registry instanceof UDDIRegistry));
			UDDIRegistry uddiRegistry = (UDDIRegistry)registry;
			assertEquals(uddiRegistry.getVersion(),"2.0");
			assertEquals(uddiRegistry.getDefaultLogin(),"hockeyfanatic");
			assertEquals(uddiRegistry.getDiscoveryURL(),"http://some.discovery.url");
			assertEquals(uddiRegistry.getPublicationURL(),"http://some.publication.url");
			
			// Load the taxonomies used the UDDI registry.
			UDDIRegistryService uddiRegistryService = UDDIRegistryService.instance();
			Taxonomy[] taxonomies = regManager.loadTaxonomies(uddiRegistryService.getTaxonomyURIs(uddiRegistry));
			assertEquals("Unexpected number of taxonomies "+taxonomies.length,taxonomies.length,1);
			Taxonomy taxonomy = taxonomies[0];
			System.out.println("Found taxonomy " + taxonomy.getId());
			Assert.assertEquals("Did not find hockey taxonomy","hockey.taxonomy",taxonomy.getId());
			
			// Dump out the values (no assertions here).
			EList cList = taxonomy.getCategory();
			for(int i = 0;i<cList.size();i++){
				Category category = (Category)cList.get(i);
				System.out.println("Found category " + category.getName());
				EList c2List = category.getCategory();
				for(int j = 0;j<c2List.size();j++){
					Category iCategory = (Category)c2List.get(j);
					System.out.println("Found subcategory " + iCategory.getName());
				}
			}					
		}
		catch(Exception t)
		{
			t.printStackTrace();
			fail("Unexpected Throwable ["+t.getMessage()+"]");
		}
		finally
		{
			System.out.println("FINISHED test_RegistryManager_loadRegistry\n");
		}
	}
}