/*
    wsmo4j - a WSMO API and Reference Implementation
   
    Copyright (c) 2004-2007, Ontotext Lab. / SIRMA
   
    This library is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 2.1 of the License, or (at your option)
    any later version.
   This library is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   details.
   You should have received a copy of the GNU Lesser General Public License along
   with this library; if not, write to the Free Software Foundation, Inc.,
   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  
  package org.wsmo.grounding.sawsdl.examples;
  
  
  import java.io.*;
  import java.net.URI;
  import java.util.List;
  
  import javax.xml.namespace.QName;
  
  import org.wsmo.factory.WsmoFactory;
  import org.wsmo.grounding.sawsdl.*;
  import org.wsmo.grounding.sawsdl.io.*;
  
  /*
   * An example program demonstrating the usage of the SAWSDL grounding API.
   * The scenario is quite simple:
   *    - opening a WSDL file (SAWSDLexample.wsdl) which is based on the latest SAWSDL specification
   *    - constructing a grounding object (one for the whole file)
   *    - listing the detected SAWSDL annotations
   *    - adding various types of annotation to the grounding object
   *    - listing the new state of the annotation
   *    - printing the result in a new separate file (SAWSDLexampleNew.wsdl)
   */
  
  public class SawsdlExample {
  
      private static final String INPUT_FILE = "WSDL-input.wsdl";
      private static final String OUTPUT_FILE = "SAWSDL-output.wsdl";
  
      public static void main(String[] args) throws Exception {
  
          // Reading the SAWSDL annotation
          Grounding grounding = readGrounding(INPUT_FILE);
          
          // Printing the current state of the annotation
          System.out.println("* * * * * * * *  INITIAL GROUNDING STATE * * * * * * ");
          dumpGrounding(grounding);
          
          // Constructing and adding new annotation objects:
          WsmoFactory factory = org.wsmo.factory.Factory.createWsmoFactory(null);
          String targetNamespace = "http://www.w3.org/2002/ws/sawsdl/spec/wsdl/order#";
          
          grounding.createElementModelRef(
                  new QName(targetNamespace, "OrderRequest"), 
                  factory.createIRI("http://www.example-one.org#elementRef"));
  
          grounding.createAttributeModelRef(
                  new QName(targetNamespace, "quantity"), 
                  factory.createIRI("http://www.example-one.org#attrRef"));
  
          grounding.createComplexTypeModelRef(
                  new QName(targetNamespace, "item"), 
                  factory.createIRI("http://www.example-one.org#complexTypeRef"));
  
          grounding.createSimpleTypeModelRef(
                  new QName(targetNamespace, "confirmation"), 
                  factory.createIRI("http://www.example-one.org#simpleTypeRef"));
  
          grounding.createOperationModelRef(
                  new QName(targetNamespace, "order"), 
                  factory.createIRI("http://www.example-one.org#operationRef"));
  
          grounding.createFaultModelRef(
                  new QName(targetNamespace, "orderFault"), 
                  factory.createIRI("http://www.example-one.org#faultRef"));
  
          grounding.createInterfaceCategory(
                  new QName(targetNamespace, "Order"), 
                  factory.createIRI("http://www.example-one.org#orderRef"));
  
          grounding.createLiftingSchemaMapping(
                  new QName(targetNamespace, "OrderRequest"), 
                  new URI("http://www.example-one.org/Request2RDFOnt.xml"));
  
          // printing the new state of the annotation
          System.out.println("\n* * * * * * * *  FINAL GROUNDING STATE * * * * * * ");
          dumpGrounding(grounding);
  
          // Saving the result to a new file
          System.out.print("Saving to " + OUTPUT_FILE + " ...");
          writeGrounding(OUTPUT_FILE, grounding);
         System.out.println("Done");
     }
     
     private static Grounding readGrounding(String inputWSDL) throws Exception {
 
         Reader in = new InputStreamReader(
                 ClassLoader.getSystemResourceAsStream(inputWSDL));
         
         // Instanciate the default implementation of the Grounding parser
         GroundingParser parser = Factory.createParser(null);
         return parser.parse(in);
     }
     
     private static void writeGrounding(String outputWSDL, Grounding grounding) throws Exception {
 
         Writer out = new OutputStreamWriter(
                 new FileOutputStream(outputWSDL));
         
         // Instanciate the default implementation of the Grounding serializer
         GroundingSerializer serializer = Factory.createSerializer(null);
         
         serializer.serialize(grounding, out);
     }
 
     private static void dumpGrounding(Grounding grounding) throws Exception {
         List<ModelRef> refs = grounding.listModelRefs();
         System.out.println(refs.size() + " model reference(s) detected:");
         for(ModelRef ref : refs) {
             String type;
             if (ref instanceof AttributeModelRef) {
                 type = "Attribute";
             }
             else if (ref instanceof ElementModelRef) {
                 type = "Element";
             } 
             else if (ref instanceof ComplexTypeModelRef) {
                 type = "ComplexType";
             } 
             else if (ref instanceof SimpleTypeModelRef) {
                 type = "SimpleType";
             } 
             else if (ref instanceof InterfaceCategory) {
                 type = "Interface";
             } 
             else if (ref instanceof OperationModelRef) {
                 type = "Operation";
             } 
             else if (ref instanceof FaultModelRef) {
                 type = "Fault";
             }
             else {
                 type = "unknown";
             }
             System.out.println("  " + type + " [" + ref.getSource().getLocalPart() + "  ->  " + ref.getTarget() + "]");
         }
         List<SchemaMapping> mappings = grounding.listSchemaMappings();
         
         System.out.println(mappings.size() + " schema mappings detected:");
         for(SchemaMapping ref : mappings) {
             String type;
             if (ref instanceof LiftingSchemaMapping) {
                 type = "  Lifting";
             }
             else {
                 type = "  Lowering";
             } 
             System.out.println(type + " schema mapping [" + ref.getSource() + "  ->  " + ref.getSchema() + "]");
         }
 
     }
 
 }