#-----------------------------------------------------------------
# MOBY::RDF::Ontologies::Services
# Author: Edward Kawas <edward.kawas@gmail.com>,
# For copyright and disclaimer see below.
#
# $Id: Services.pm,v 1.11 2009/02/03 18:05:03 kawas Exp $
#-----------------------------------------------------------------

package MOBY::RDF::Ontologies::Services;

use RDF::Core;
use RDF::Core::Storage::Memory;
use RDF::Core::Model;
use RDF::Core::Literal;
use RDF::Core::Statement;
use RDF::Core::Model::Serializer;
use RDF::Core::NodeFactory;

use Digest::MD5 qw /md5_hex/;

use XML::LibXML;

use LS::ID;

use MOBY::Client::Central;
use MOBY::Config;

use MOBY::RDF::Predicates::DC_PROTEGE;
use MOBY::RDF::Predicates::FETA;
use MOBY::RDF::Predicates::MOBY_PREDICATES;
use MOBY::RDF::Predicates::OMG_LSID;
use MOBY::RDF::Predicates::RDF;
use MOBY::RDF::Predicates::RDFS;
use MOBY::RDF::Utils;

use Data::Dumper;
use strict;

use vars qw /$VERSION/;
$VERSION = sprintf "%d.%02d", q$Revision: 1.11 $ =~ /: (\d+)\.(\d+)/;

#-----------------------------------------------------------------
# load all modules needed for my attributes
#-----------------------------------------------------------------

=head1 NAME

MOBY::RDF::Ontologies::Services - Create RDF/OWL for Moby

=head1 SYNOPSIS

	use MOBY::RDF::Ontologies::Services;

	my $x = MOBY::RDF::Ontologies::Services->new;

	# get pretty printed RDF/XML for one service
	print $x->findService({ 
		serviceName => 'MOBYSHoundGiFromGOIDListAndECode',
		authURI => 'bioinfo.icapture.ubc.ca' 
	});

	# get unformatted RDF/XML for a bunch of services from a single provider
	print $x->findService({ 
		prettyPrint => 'no',
		authURI => 'bioinfo.icapture.ubc.ca' 
	});

	# get unformatted RDF/XML for a bunch of services from a single provider without isAlive info
	print $x->findService({ 
		prettyPrint => 'no',
		authURI => 'bioinfo.icapture.ubc.ca',
		isAlive => 'no' 
	});

	# get unformatted RDF/XML for all services
	print $x->findService({ 
		prettyPrint => 'no' 
	});

=head1 DESCRIPTION

	This module aids in the creation of RDF/XML for service instances in the BioMOBY world.

=cut

=head1 AUTHORS

 Edward Kawas (edward.kawas [at] gmail [dot] com)

=cut

#-----------------------------------------------------------------

=head1 SUBROUTINES

=cut

#-----------------------------------------------------------------
# new
#-----------------------------------------------------------------

=head2 new

Instantiate a Services object.

Parameters: 
	* A Hash with keys:
		-> endpoint		=> the BioMOBY registry endpoint to use <optional>
		-> namespace	=> the BioMOBY registry namespace to use <optional>

=cut

sub new {
	my ( $class, %args ) = @_;

	# create an object
	my $self = bless {}, ref($class) || $class;

	# save some information retrieved from mobycentral.config
	my $CONF = MOBY::Config->new;

	# set the uris unless an endpoint was specified
	do {
		$self->{instance_uri}  = $CONF->{mobycentral}->{resourceURL}   || '';
		$self->{service_uri}   = $CONF->{mobyservice}->{resourceURL}   || '';
		$self->{datatype_uri}  = $CONF->{mobyobject}->{resourceURL}    || '';
		$self->{namespace_uri} = $CONF->{mobynamespace}->{resourceURL} || '';
	} unless $args{endpoint};

	# save the endpoint/namespace/uri if passed in
	$self->{endpoint}  = $args{endpoint} if $args{endpoint};
	$self->{namespace} = $args{endpoint} if $args{namespace};

	unless ( $self->{instance_uri} ) {
		my $moby =
		  MOBY::Client::Central->new(
					 Registries => {
						 mobycentral => {
							 URL => $self->{endpoint},
							 URI => 'http://mobycentral.cbr.nrc.ca/MOBY/Central'
						 }
					 }
		  ) if $self->{endpoint};

		# otherwise use default one
		$moby = MOBY::Client::Central->new() unless $self->{endpoint};

		# moby is a hash ref now
		$moby = $moby->retrieveResourceURLs();

		# add all uris
		$self->{instance_uri} = $moby->{ServiceInstance}->[0]
		  if $moby->{ServiceInstance}->[0];
		$self->{service_uri} = $moby->{Services}->[0] if $moby->{Services}->[0];
		$self->{namespace_uri} = $moby->{Namespaces}->[0]
		  if $moby->{Namespaces}->[0];
		$self->{datatype_uri} = $moby->{Objects}->[0] if $moby->{Objects}->[0];

		#revert to a default value if nothing is retrieved
		$self->{instance_uri} =
		  'http://biomoby.org/RESOURCES/MOBY-S/ServiceInstances/'
		  unless $moby->{ServiceInstance}->[0];
		$self->{service_uri} = 'http://biomoby.org/RESOURCES/MOBY-S/Services/'
		  unless $moby->{Services}->[0];
		$self->{namespace_uri} =
		  'http://biomoby.org/RESOURCES/MOBY-S/Namespaces/'
		  unless $moby->{Namespaces}->[0];
		$self->{datatype_uri} = 'http://biomoby.org/RESOURCES/MOBY-S/Objects/'
		  unless $moby->{Objects}->[0];
	}

	# add a / at the end of the uri if it isnt there already
	$self->{instance_uri} = $self->{instance_uri} . "/"
	  unless $self->{instance_uri} =~ m/^.*(\/{1})$/;
	$self->{service_uri} = $self->{service_uri} . "/"
	  unless $self->{service_uri} =~ m/^.*(\/{1})$/;
	$self->{namespace_uri} = $self->{namespace_uri} . "/"
	  unless $self->{namespace_uri} =~ m/^.*(\/{1})$/;
	$self->{datatype_uri} = $self->{datatype_uri} . "/"
	  unless $self->{datatype_uri} =~ m/^.*(\/{1})$/;

	#set the isAlive path
	$self->{is_alive_path} = $CONF->{mobycentral}->{service_tester_path}
	  if $ENV{MOBY_SERVER}
		  and $self->{endpoint}
		  and $ENV{MOBY_SERVER} eq $self->{endpoint};

	# done
	return $self;
}

#-----------------------------------------------------------------
# findService
#-----------------------------------------------------------------

=head2 findService

Return a string of RDF in XML service instances in the service ontology.
 This routine consumes a hash as input with keys:
	authURI: the service provider URI <optional>
	serviceName: the name of a particular service <optional>
	isAlive    : whether (yes) or not (no) to add isAlive information. Defaults to 'yes'.
	prettyPrint: whether (yes) or not (no) to output 'pretty print' formatted XML. Defaults to 'yes'.

#TODO should i add all parameters from findService here?

=cut

sub findService {
	my ( $self, $hash ) = @_;

	my $authURI = $hash->{authURI}     || '';
	my $name    = $hash->{serviceName} || '';
	my $prettyPrint = $hash->{prettyPrint} ? $hash->{prettyPrint} : 'yes';
	my $addIsAlive  = $hash->{isAlive}     ? $hash->{isAlive}     : 'yes';
	my $services    = [];
	my $RegObject;

	# use the passed in endpoint if applicable
	my $moby =
	  MOBY::Client::Central->new(
					 Registries => {
						 mobycentral => {
							 URL => $self->{endpoint},
							 URI => 'http://mobycentral.cbr.nrc.ca/MOBY/Central'
						 }
					 }
	  ) if $self->{endpoint};

	# otherwise use default one
	$moby = MOBY::Client::Central->new() unless $self->{endpoint};

	if ( $name ne '' or $authURI ne '' ) {
		( $services, $RegObject ) =
		  $moby->findService( authURI => $authURI, serviceName => $name );

	}
	else {
		my (@URIS) = $moby->retrieveServiceProviders();
		foreach my $provider (@URIS) {
			my ( $instances, $RegObject ) =
			  $moby->findService( authURI => $provider );
			push @$services, @$instances;
		}

	}
	my $xml = $self->_createRDFModel( \@$services, $addIsAlive );
	return new MOBY::RDF::Utils->prettyPrintXML( { xml => $xml } )
	  unless $prettyPrint =~ /no/i;
	return $xml;
}

#-----------------------------------------------------------------
# _createRDFModel
#-----------------------------------------------------------------

=head2 _createRDFModel

this routine takes an array of MOBY::Client::ServiceInstance objects and
creates and RDF model for them all.

=cut

sub _createRDFModel {
	my ( $self, $services, $addIsAlive ) = @_;

	# set up an RDF model
	my $storage      = new RDF::Core::Storage::Memory;
	my $model        = new RDF::Core::Model( Storage => $storage );
	my $node_factory = new RDF::Core::NodeFactory();

	foreach my $SI (@$services) {

		# used for computing checksums
		my $service_name      = $SI->name;
		my $service_authority = $SI->authority;

		my $resource = new RDF::Core::Resource( $self->{instance_uri},
											 $SI->authority . "," . $SI->name );
		$model->addStmt(
						 new RDF::Core::Statement(
							 $resource,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
								 MOBY::RDF::Predicates::FETA->serviceDescription
							 )
						 )
		);
		$model->addStmt(
				new RDF::Core::Statement(
					$resource,
					$resource->new( MOBY::RDF::Predicates::DC_PROTEGE->format ),
					new RDF::Core::Literal( $SI->category )
				)
		);
		$model->addStmt(
			new RDF::Core::Statement(
				$resource,
				$resource->new( MOBY::RDF::Predicates::DC_PROTEGE->identifier ),
				new RDF::Core::Literal( $SI->LSID )
			)
		);
		$model->addStmt(
				 new RDF::Core::Statement(
					 $resource,
					 $resource->new( MOBY::RDF::Predicates::FETA->locationURI ),
					 new RDF::Core::Literal( $SI->URL )
				 )
		);
		$model->addStmt(
				  new RDF::Core::Statement(
					  $resource,
					  $resource->new(
						  MOBY::RDF::Predicates::FETA->hasServiceDescriptionText
					  ),
					  new RDF::Core::Literal( $SI->description )
				  )
		);
		$model->addStmt(
			  new RDF::Core::Statement(
				  $resource,
				  $resource->new(
					  MOBY::RDF::Predicates::FETA->hasServiceDescriptionLocation
				  ),
				  new RDF::Core::Literal( $SI->signatureURL )
			  )
		);
		$model->addStmt(
						 new RDF::Core::Statement(
							 $resource,
							 $resource->new(
								 MOBY::RDF::Predicates::FETA->hasServiceNameText
							 ),
							 new RDF::Core::Literal( $SI->name )
						 )
		);
		eval {
			do {

				# add is alive information if necessary
				if (     $self->{is_alive_path}
					 and -e $self->{is_alive_path}
					 and -r $self->{is_alive_path} . "/isAliveStats.xml" )
				{
					my $parser = XML::LibXML->new();
					my $doc =
					  $parser->parse_file(
								 $self->{is_alive_path} . '/isAliveStats.xml' );
					my $value    = "true";
					my $id       = $SI->authority . "," . $SI->name;
					my @nodelist = $doc->getElementsByTagName("service");
					for my $node (@nodelist) {
						next unless ( $node->getAttribute('id') eq $id );
						$value = $node->textContent;
						last;
					}
					$model->addStmt(
									new RDF::Core::Statement(
										$resource,
										$resource->new(
											MOBY::RDF::Predicates::FETA->isAlive
										),
										new RDF::Core::Literal($value)
									)
					);
				}
				else {

					# by default, state the service is alive ...
					$model->addStmt(
									new RDF::Core::Statement(
										$resource,
										$resource->new(
											MOBY::RDF::Predicates::FETA->isAlive
										),
										new RDF::Core::Literal('true')
									)
					);
				}
			} unless $addIsAlive =~ /no/i;
		};

		# add the authoring statements
		my $bnode =
		  new RDF::Core::Resource(
								   $self->{instance_uri},
								   md5_hex(
											"$service_authority/$service_name/"
											  . MOBY::RDF::Predicates::FETA
											  ->providedBy
								   )
		  );    #$node_factory->newResource;
		$model->addStmt(
				  new RDF::Core::Statement(
					  $resource,
					  $resource->new( MOBY::RDF::Predicates::FETA->providedBy ),
					  $bnode
				  )
		);
		$model->addStmt(
			   new RDF::Core::Statement(
				   $bnode,
				   $resource->new( MOBY::RDF::Predicates::FETA->authoritative ),
				   new RDF::Core::Literal(
									  $SI->authoritative == 0 ? "false" : "true"
				   )
			   )
		);
		$model->addStmt(
			   new RDF::Core::Statement(
				   $bnode,
				   $resource->new( MOBY::RDF::Predicates::DC_PROTEGE->creator ),
				   new RDF::Core::Literal( $SI->contactEmail )
			   )
		);
		$model->addStmt(
			 new RDF::Core::Statement(
				 $bnode,
				 $resource->new( MOBY::RDF::Predicates::DC_PROTEGE->publisher ),
				 new RDF::Core::Literal( $SI->authority )
			 )
		);
		$model->addStmt(
						 new RDF::Core::Statement(
							 $bnode,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
									   MOBY::RDF::Predicates::FETA->organisation
							 )
						 )
		);

		# add parameter statements
		my $operation =
		  new RDF::Core::Resource(
								   $self->{instance_uri},
								   md5_hex(
											"$service_authority/$service_name/"
											  . MOBY::RDF::Predicates::FETA
											  ->hasOperation
								   )
		  );    # $node_factory->newResource;
		$model->addStmt(
				new RDF::Core::Statement(
					$resource,
					$resource->new( MOBY::RDF::Predicates::FETA->hasOperation ),
					$operation
				)
		);
		$model->addStmt(
					   new RDF::Core::Statement(
						   $operation,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasOperationNameText
						   ),
						   new RDF::Core::Literal( $SI->name )
					   )
		);
		$model->addStmt(
						 new RDF::Core::Statement(
							 $operation,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										MOBY::RDF::Predicates::FETA->operation )
						 )
		);
		$bnode = new RDF::Core::Resource(
							   $self->{instance_uri},
							   md5_hex(
								   "$service_authority/$service_name/"
									 . MOBY::RDF::Predicates::FETA->performsTask
							   )
		);    # $node_factory->newResource;
		$model->addStmt(
				new RDF::Core::Statement(
					$operation,
					$resource->new( MOBY::RDF::Predicates::FETA->performsTask ),
					$bnode
				)
		);
		$model->addStmt(
						 new RDF::Core::Statement(
							 $bnode,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
									  MOBY::RDF::Predicates::FETA->operationTask
							 )
						 )
		);
		# add the service type		
		$model->addStmt(
				 new RDF::Core::Statement(
					 $bnode,
					 $resource->new( MOBY::RDF::Predicates::RDF->type ),
					 new RDF::Core::Resource($self->{service_uri} . $SI->type )
				 )
		);

		# add unit test data here ...
		if ( $SI->unitTests ) {
			my $unitTests = $SI->unitTests;
			my $utils = new MOBY::RDF::Utils;
			foreach my $unit_test (@$unitTests) {
				$bnode =
				  new RDF::Core::Resource(
						  $self->{instance_uri},
						  md5_hex(
							  "$service_authority/$service_name/"
								. (
									  $unit_test->example_input
									? $utils->trim($unit_test->example_input)
									: ""
								)
								. (
									  $unit_test->expected_output
									? $utils->trim($unit_test->expected_output)
									: ""
								)
								. ( $unit_test->regex ? $utils->trim($unit_test->regex) : "" )
								. ( $unit_test->xpath ? $utils->trim($unit_test->xpath) : "" )
								."/"
								. MOBY::RDF::Predicates::FETA->unitTest
						  )
				  );

				# add the type
				$model->addStmt(
						 new RDF::Core::Statement(
							 $bnode,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										   MOBY::RDF::Predicates::FETA->unitTest
							 )
						 )
				);

				# add the example input if defined
				$model->addStmt(
						 new RDF::Core::Statement(
							 $bnode,
							 $resource->new(
									   MOBY::RDF::Predicates::FETA->exampleInput
							 ),
							 new RDF::Core::Literal( $unit_test->example_input )
						 )
				  )
				  if $unit_test->example_input
					  and $unit_test->example_input ne '';

				# add the valid output xml if defined
				$model->addStmt(
					   new RDF::Core::Statement(
						   $bnode,
						   $resource->new(
									 MOBY::RDF::Predicates::FETA->validOutputXML
						   ),
						   new RDF::Core::Literal( $unit_test->expected_output )
					   )
				  )
				  if $unit_test->expected_output
					  and $unit_test->expected_output ne '';

				# add the valid regex if defined
				$model->addStmt(
								 new RDF::Core::Statement(
									 $bnode,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->validREGEX
									 ),
									 new RDF::Core::Literal( $unit_test->regex )
								 )
				  )
				  if $unit_test->regex
					  and $unit_test->regex ne '';

				# add the valid xpath expression if defined
				$model->addStmt(
								 new RDF::Core::Statement(
									 $bnode,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->validXPath
									 ),
									 new RDF::Core::Literal( $unit_test->xpath )
								 )
				  )
				  if $unit_test->xpath
					  and $unit_test->xpath ne '';

				$model->addStmt(
								new RDF::Core::Statement(
									$operation,
									$resource->new(
										MOBY::RDF::Predicates::FETA->hasUnitTest
									),
									$bnode
								)
				);
			}
		}

		my $inputs = $SI->input;
		foreach (@$inputs) {
			my $inputParameter =
			  new RDF::Core::Resource(
							$self->{instance_uri},
							md5_hex(
								"$service_authority/$service_name/"
								  . (
									$_->isSimple ? "isSimple/" : "isCollection/"
								  )
								  . MOBY::RDF::Predicates::FETA->inputParameter
								  . "/"
								  . $_->articleName
							)
			  );    # $node_factory->newResource;
			$model->addStmt(
							 new RDF::Core::Statement(
								 $operation,
								 $resource->new(
									 MOBY::RDF::Predicates::FETA->inputParameter
								 ),
								 $inputParameter
							 )
			);
			if ( $_->isSimple ) {
				$model->addStmt(
					   new RDF::Core::Statement(
						   $inputParameter,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasParameterNameText
						   ),
						   new RDF::Core::Literal( $_->articleName )
					   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $inputParameter,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										  MOBY::RDF::Predicates::FETA->parameter
							 )
						 )
				);
							
				my $oType =
				  new RDF::Core::Resource(
					   $self->{instance_uri},
					   md5_hex(
						       "$service_authority/$service_name/"
							 . ( $_->isSimple ? "isSimple/" : "isCollection/" )
							 . MOBY::RDF::Predicates::FETA->inputParameter . "/"
							 . $_->articleName . "/"
							 . $_->objectType
					   )
				  );    # $node_factory->newResource;
				$model->addStmt(
								 new RDF::Core::Statement(
									 $inputParameter,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->objectType
									 ),
									 $oType
								 )
				);
								
				$model->addStmt(
					new RDF::Core::Statement(
						$oType,
						$resource->new( MOBY::RDF::Predicates::RDF->type ),
						new RDF::Core::Resource(
							# check for lsids
							LS::ID->new($_->objectType) ? 
								$_->objectType : $self->{datatype_uri} . $_->objectType
						)
					)
				);

				my $pType =
				  new RDF::Core::Resource(
					 $self->{instance_uri},
					 md5_hex(
						     "$service_authority/$service_name/"
						   . ( $_->isSimple ? "isSimple/" : "isCollection/" )
						   . MOBY::RDF::Predicates::FETA->hasParameterType . "/"
						   . $_->articleName
					 )
				  );           # $node_factory->newResource;
				$model->addStmt(
						   new RDF::Core::Statement(
							   $inputParameter,
							   $resource->new(
								   MOBY::RDF::Predicates::FETA->hasParameterType
							   ),
							   $pType
						   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $pType,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
									MOBY::RDF::Predicates::FETA->simpleParameter
							 )
						 )
				);
				my $namespaces = $_->namespaces;
				foreach my $n (@$namespaces) {
					my $inNamespaces =
					  new RDF::Core::Resource(
						$self->{instance_uri},
						md5_hex(
							    "$service_authority/$service_name/"
							  . ( $_->isSimple ? "isSimple/" : "isCollection/" )
							  . MOBY::RDF::Predicates::FETA->inputParameter
							  . "/"
							  . $_->articleName . "/"
							  . $n
						)
					  );    # $node_factory->newResource;
					$model->addStmt(
							   new RDF::Core::Statement(
								   $inputParameter,
								   $resource->new(
									   MOBY::RDF::Predicates::FETA->inNamespaces
								   ),
								   $inNamespaces
							   )
					);
					$model->addStmt(
						 new RDF::Core::Statement(
							 $inNamespaces,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
								 MOBY::RDF::Predicates::FETA->parameterNamespace
							 )
						 )
					);
					$model->addStmt(
						new RDF::Core::Statement(
							$inNamespaces,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								LS::ID->new($n) ? 
									$n : $self->{namespace_uri} . $n
							  )  # check for lsids
						)
					);
				}
			}
			elsif ( $_->isCollection ) {

				$model->addStmt(
					   new RDF::Core::Statement(
						   $inputParameter,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasParameterNameText
						   ),
						   new RDF::Core::Literal( $_->articleName )
					   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $inputParameter,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										  MOBY::RDF::Predicates::FETA->parameter
							 )
						 )
				);

				my $pType =
				  new RDF::Core::Resource(
					 $self->{instance_uri},
					 md5_hex(
						     "$service_authority/$service_name/"
						   . ( $_->isSimple ? "isSimple/" : "isCollection/" )
						   . MOBY::RDF::Predicates::FETA->hasParameterType . "/"
						   . $_->articleName
					 )
				  );    # $node_factory->newResource;
				$model->addStmt(
						   new RDF::Core::Statement(
							   $inputParameter,
							   $resource->new(
								   MOBY::RDF::Predicates::FETA->hasParameterType
							   ),
							   $pType
						   )
				);
				$model->addStmt(
						new RDF::Core::Statement(
							$pType,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								MOBY::RDF::Predicates::FETA->collectionParameter
							)
						)
				);

				my $simples = $_->Simples;
				foreach my $simp (@$simples) {
					my $oType =
					  new RDF::Core::Resource(
						$self->{instance_uri},
						md5_hex(
							    "$service_authority/$service_name/"
							  . ( $_->isSimple ? "isSimple/" : "isCollection/" )
							  . MOBY::RDF::Predicates::FETA->inputParameter
							  . "/"
							  . $_->articleName . "/"
							  . $simp->objectType
						)
					  );    # $node_factory->newResource;
					$model->addStmt(
								 new RDF::Core::Statement(
									 $inputParameter,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->objectType
									 ),
									 $oType
								 )
					);
					$model->addStmt(
						new RDF::Core::Statement(
							$oType,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								LS::ID->new($simp->objectType) ? 
									$simp->objectType : $self->{datatype_uri} . $simp->objectType	   
							  )# check for lsids
						)
					);
					my $namespaces = $simp->namespaces;
					foreach my $n (@$namespaces) {
						my $inNamespaces =
						  new RDF::Core::Resource(
							$self->{instance_uri},
							md5_hex(
								"$service_authority/$service_name/"
								  . (
									$_->isSimple ? "isSimple/" : "isCollection/"
								  )
								  . MOBY::RDF::Predicates::FETA->inputParameter
								  . "/"
								  . $_->articleName . "/"
								  . $n
							)
						  );    # $node_factory->newResource;
						$model->addStmt(
							   new RDF::Core::Statement(
								   $inputParameter,
								   $resource->new(
									   MOBY::RDF::Predicates::FETA->inNamespaces
								   ),
								   $inNamespaces
							   )
						);
						$model->addStmt(
										new RDF::Core::Statement(
											$inNamespaces,
											$resource->new(
												MOBY::RDF::Predicates::RDF->type
											),
											new RDF::Core::Resource(
													 MOBY::RDF::Predicates::FETA
													   ->parameterNamespace
											)
										)
						);
						$model->addStmt(
							new RDF::Core::Statement(
								$inNamespaces,
								$resource->new(
												MOBY::RDF::Predicates::RDF->type
								),
								new RDF::Core::Resource(
									LS::ID->new($n) ? 
										$n : $self->{namespace_uri} . $n
								  )# check for lsids
							)
						);
					}
				}
			}
		}

		my $secondaries = $SI->secondary;

		foreach (@$secondaries) {
			next unless $_->isSecondary;
			my $inputParameter =
			  new RDF::Core::Resource(
							 $self->{instance_uri},
							 md5_hex(
								     "$service_authority/$service_name/"
								   . "isSecondaryInputParameter/"
								   . MOBY::RDF::Predicates::FETA->inputParameter
								   . "/"
								   . $_->articleName
							 )
			  );    #$node_factory->newResource;
			$model->addStmt(
							 new RDF::Core::Statement(
								 $operation,
								 $resource->new(
									 MOBY::RDF::Predicates::FETA->inputParameter
								 ),
								 $inputParameter
							 )
			);
			$model->addStmt(
						 new RDF::Core::Statement(
							 $inputParameter,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										  MOBY::RDF::Predicates::FETA->parameter
							 )
						 )
			);

			my $pType =
			  new RDF::Core::Resource(
						   $self->{instance_uri},
						   md5_hex(
							       "$service_authority/$service_name/"
								 . "isSecondary/"
								 . MOBY::RDF::Predicates::FETA->hasParameterType
								 . "/"
								 . $_->articleName
						   )
			  );    # $node_factory->newResource;
			$model->addStmt(
						   new RDF::Core::Statement(
							   $inputParameter,
							   $resource->new(
								   MOBY::RDF::Predicates::FETA->hasParameterType
							   ),
							   $pType
						   )
			);
			$model->addStmt(
						 new RDF::Core::Statement(
							 $pType,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
								 MOBY::RDF::Predicates::FETA->secondaryParameter
							 )
						 )
			);

			$model->addStmt(
					   new RDF::Core::Statement(
						   $inputParameter,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasParameterNameText
						   ),
						   new RDF::Core::Literal( $_->articleName )
					   )
			);

			$model->addStmt(
						 new RDF::Core::Statement(
							 $inputParameter,
							 $resource->new( MOBY::RDF::Predicates::FETA->min ),
							 new RDF::Core::Literal( $_->min )
						 )
			) if defined( $_->min );

			$model->addStmt(
						 new RDF::Core::Statement(
							 $inputParameter,
							 $resource->new( MOBY::RDF::Predicates::FETA->max ),
							 new RDF::Core::Literal( $_->max )
						 )
			) if defined( $_->max );

			$model->addStmt(
				new RDF::Core::Statement(
					$inputParameter,
					$resource->new(
						MOBY::RDF::Predicates::FETA->hasParameterDescriptionText
					),
					new RDF::Core::Literal( $_->description )
				)
			);

			$model->addStmt(
							new RDF::Core::Statement(
								$inputParameter,
								$resource->new(
									MOBY::RDF::Predicates::FETA->hasDefaultValue
								),
								new RDF::Core::Literal( $_->default )
							)
			) if defined( $_->default );

			$model->addStmt(
					new RDF::Core::Statement(
						$inputParameter,
						$resource->new( MOBY::RDF::Predicates::FETA->datatype ),
						new RDF::Core::Literal( $_->datatype )
					)
			);
			foreach my $e ( @{ $_->enum } ) {
				$model->addStmt(
						new RDF::Core::Statement(
							$inputParameter,
							$resource->new( MOBY::RDF::Predicates::FETA->enum ),
							new RDF::Core::Literal($e)
						)
				);
			}
		}

		my $outputs = $SI->output;
		foreach (@$outputs) {
			my $outputParameter =
			  new RDF::Core::Resource(
						  $self->{instance_uri},
						  md5_hex(
							  "$service_authority/$service_name/"
								. (
								  $_->isSimple ? "isSimple/" : "isCollection/" )
								. MOBY::RDF::Predicates::FETA->outputParameter
								. "/"
								. $_->articleName
						  )
			  );    # $node_factory->newResource;
			$model->addStmt(
							new RDF::Core::Statement(
								$operation,
								$resource->new(
									MOBY::RDF::Predicates::FETA->outputParameter
								),
								$outputParameter
							)
			);
			if ( $_->isSimple ) {
				$model->addStmt(
					   new RDF::Core::Statement(
						   $outputParameter,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasParameterNameText
						   ),
						   new RDF::Core::Literal( $_->articleName )
					   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $outputParameter,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										  MOBY::RDF::Predicates::FETA->parameter
							 )
						 )
				);

				my $oType =
				  new RDF::Core::Resource(
					  $self->{instance_uri},
					  md5_hex(
						      "$service_authority/$service_name/"
							. ( $_->isSimple ? "isSimple/" : "isCollection/" )
							. MOBY::RDF::Predicates::FETA->outputParameter . "/"
							. $_->articleName . "/"
							. $_->objectType
					  )
				  );    # $node_factory->newResource;
				$model->addStmt(
								 new RDF::Core::Statement(
									 $outputParameter,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->objectType
									 ),
									 $oType
								 )
				);
				$model->addStmt(
					new RDF::Core::Statement(
						$oType,
						$resource->new( MOBY::RDF::Predicates::RDF->type ),
						new RDF::Core::Resource(
							LS::ID->new($_->objectType) ? 
								$_->objectType : $self->{datatype_uri} . $_->objectType
						  )# check for lsids
					)
				);

				my $pType =
				  new RDF::Core::Resource(
					 $self->{instance_uri},
					 md5_hex(
						     "$service_authority/$service_name/"
						   . ( $_->isSimple ? "isSimple/" : "isCollection/" )
						   . MOBY::RDF::Predicates::FETA->hasParameterType . "/"
						   . $_->articleName
					 )
				  );           # $node_factory->newResource;
				$model->addStmt(
						   new RDF::Core::Statement(
							   $outputParameter,
							   $resource->new(
								   MOBY::RDF::Predicates::FETA->hasParameterType
							   ),
							   $pType
						   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $pType,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
									MOBY::RDF::Predicates::FETA->simpleParameter
							 )
						 )
				);
				my $namespaces = $_->namespaces;
				foreach my $n (@$namespaces) {
					my $inNamespaces =
					  new RDF::Core::Resource(
						$self->{instance_uri},
						md5_hex(
							    "$service_authority/$service_name/"
							  . ( $_->isSimple ? "isSimple/" : "isCollection/" )
							  . MOBY::RDF::Predicates::FETA->outputParameter
							  . "/"
							  . $_->articleName . "/"
							  . $n
						)
					  );    # $node_factory->newResource;
					$model->addStmt(
							   new RDF::Core::Statement(
								   $outputParameter,
								   $resource->new(
									   MOBY::RDF::Predicates::FETA->inNamespaces
								   ),
								   $inNamespaces
							   )
					);
					$model->addStmt(
						 new RDF::Core::Statement(
							 $inNamespaces,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
								 MOBY::RDF::Predicates::FETA->parameterNamespace
							 )
						 )
					);
					$model->addStmt(
						new RDF::Core::Statement(
							$inNamespaces,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								LS::ID->new($n) ? 
									$n : $self->{namespace_uri} . $n
							  )# check for lsids
						)
					);
				}
			}
			elsif ( $_->isCollection ) {

				$model->addStmt(
					   new RDF::Core::Statement(
						   $outputParameter,
						   $resource->new(
							   MOBY::RDF::Predicates::FETA->hasParameterNameText
						   ),
						   new RDF::Core::Literal( $_->articleName )
					   )
				);
				$model->addStmt(
						 new RDF::Core::Statement(
							 $outputParameter,
							 $resource->new( MOBY::RDF::Predicates::RDF->type ),
							 new RDF::Core::Resource(
										  MOBY::RDF::Predicates::FETA->parameter
							 )
						 )
				);

				my $pType =
				  new RDF::Core::Resource(
					 $self->{instance_uri},
					 md5_hex(
						     "$service_authority/$service_name/"
						   . ( $_->isSimple ? "isSimple/" : "isCollection/" )
						   . MOBY::RDF::Predicates::FETA->hasParameterType . "/"
						   . $_->articleName
					 )
				  );    # $node_factory->newResource;
				$model->addStmt(
						   new RDF::Core::Statement(
							   $outputParameter,
							   $resource->new(
								   MOBY::RDF::Predicates::FETA->hasParameterType
							   ),
							   $pType
						   )
				);
				$model->addStmt(
						new RDF::Core::Statement(
							$pType,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								MOBY::RDF::Predicates::FETA->collectionParameter
							)
						)
				);

				my $simples = $_->Simples;
				foreach my $simp (@$simples) {
					my $oType =
					  new RDF::Core::Resource(
						$self->{instance_uri},
						md5_hex(
							    "$service_authority/$service_name/"
							  . ( $_->isSimple ? "isSimple/" : "isCollection/" )
							  . MOBY::RDF::Predicates::FETA->outputParameter
							  . "/"
							  . $_->articleName . "/"
							  . $simp->objectType
						)
					  );    # $node_factory->newResource;
					$model->addStmt(
								 new RDF::Core::Statement(
									 $outputParameter,
									 $resource->new(
										 MOBY::RDF::Predicates::FETA->objectType
									 ),
									 $oType
								 )
					);
					$model->addStmt(
						new RDF::Core::Statement(
							$oType,
							$resource->new( MOBY::RDF::Predicates::RDF->type ),
							new RDF::Core::Resource(
								LS::ID->new($simp->objectType) ? 
									$simp->objectType : $self->{datatype_uri} . $simp->objectType
							  )# check for lsids
						)
					);
					my $namespaces = $simp->namespaces;
					foreach my $n (@$namespaces) {
						my $inNamespaces =
						  new RDF::Core::Resource(
							$self->{instance_uri},
							md5_hex(
								"$service_authority/$service_name/"
								  . (
									$_->isSimple ? "isSimple/" : "isCollection/"
								  )
								  . MOBY::RDF::Predicates::FETA->outputParameter
								  . "/"
								  . $_->articleName . "/"
								  . $n
							)
						  );    # $node_factory->newResource;
						$model->addStmt(
							   new RDF::Core::Statement(
								   $outputParameter,
								   $resource->new(
									   MOBY::RDF::Predicates::FETA->inNamespaces
								   ),
								   $inNamespaces
							   )
						);
						$model->addStmt(
										new RDF::Core::Statement(
											$inNamespaces,
											$resource->new(
												MOBY::RDF::Predicates::RDF->type
											),
											new RDF::Core::Resource(
													 MOBY::RDF::Predicates::FETA
													   ->parameterNamespace
											)
										)
						);
						$model->addStmt(
							new RDF::Core::Statement(
								$inNamespaces,
								$resource->new(
												MOBY::RDF::Predicates::RDF->type
								),
								new RDF::Core::Resource(
								LS::ID->new($n) ? 
									$n : $self->{namespace_uri} . $n
								  )
							)
						);
					}
				}
			}
		}
	}
	my $xml = '';
	my $serializer =
	  new RDF::Core::Model::Serializer(
										Model   => $model,
										Output  => \$xml,
										BaseURI => 'URI://BASE/',
	  );
	$serializer->serialize;
	return $xml;
}

1;
__END__