/*

  * Copyright 2010 The Kuali Foundation

  *

  * Licensed under the Educational Community 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.osedu.org/licenses/ECL-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.

  */

 package org.kuali.student.contract.model.impl;

 import com.sun.xml.xsom.XSAnnotation;

 import com.sun.xml.xsom.XSComplexType;

 import com.sun.xml.xsom.XSContentType;

 import com.sun.xml.xsom.XSElementDecl;

 import com.sun.xml.xsom.XSFacet;

 import com.sun.xml.xsom.XSModelGroup;

 import com.sun.xml.xsom.XSParticle;

 import com.sun.xml.xsom.XSSchema;

 import com.sun.xml.xsom.XSSchemaSet;

 import com.sun.xml.xsom.XSSimpleType;

 import com.sun.xml.xsom.XSTerm;

 import com.sun.xml.xsom.XSType;

 import com.sun.xml.xsom.parser.AnnotationContext;

 import com.sun.xml.xsom.parser.AnnotationParser;

 import com.sun.xml.xsom.parser.AnnotationParserFactory;

 import com.sun.xml.xsom.parser.SchemaDocument;

 import com.sun.xml.xsom.parser.XSOMParser;

 import com.sun.xml.xsom.util.DomAnnotationParserFactory;

 import java.io.File;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.kuali.student.contract.model.MessageStructure;

 import org.kuali.student.contract.model.Service;

 import org.kuali.student.contract.model.ServiceContractModel;

 import org.kuali.student.contract.model.ServiceMethod;

 import org.kuali.student.contract.model.ServiceMethodReturnValue;

 import org.kuali.student.contract.model.XmlType;

 import org.xml.sax.Attributes;

 import org.xml.sax.ContentHandler;

 import org.xml.sax.EntityResolver;

 import org.xml.sax.ErrorHandler;

 import org.xml.sax.Locator;

 import org.xml.sax.SAXException;

 /**

  *

  * @author nwright

  */

 public class ServiceContractModelPescXsdLoader implements

         ServiceContractModel {

     private List<String> xsdFileNames;

     private List<Service> services = null;

     private List<ServiceMethod> serviceMethods = null;

     private Map<String, XmlType> xmlTypeMap = null;

     private List<MessageStructure> messageStructures;

     public ServiceContractModelPescXsdLoader(List<String> xsdFileNames) {

         this.xsdFileNames = xsdFileNames;

     }

     @Override

     public List<ServiceMethod> getServiceMethods() {

         if (this.serviceMethods == null) {

             this.parse();

         }

         return this.serviceMethods;

     }

     @Override

     public List<String> getSourceNames() {

         List<String> list = new ArrayList();

         list.addAll(this.xsdFileNames);

         return list;

     }

     @Override

     public List<Service> getServices() {

         if (services == null) {

             this.parse();

         }

         return services;

     }

     @Override

     public List<XmlType> getXmlTypes() {

         if (xmlTypeMap == null) {

             this.parse();

         }

         return new ArrayList(xmlTypeMap.values());

     }

     @Override

     public List<MessageStructure> getMessageStructures() {

         if (messageStructures == null) {

             this.parse();

         }

         return this.messageStructures;

     }

     private void parse() {

         System.out.println("ServiceContractModelQDoxLoader: Starting parse");

         services = new ArrayList();

         Service service = new Service();

         services.add(service);

         service.setKey("Pesc");

         service.setName("PescService");

         service.setComments("Derived from pesc CoreMain");

         serviceMethods = new ArrayList();

         ServiceMethod method = new ServiceMethod();

         serviceMethods.add(method);

         method.setName("dummy");

         method.setDescription("Dummy method so validation won't fail");

         method.setService("Pesc");

         method.setParameters(new ArrayList());

         ServiceMethodReturnValue rv = new ServiceMethodReturnValue();

         rv.setType("void");

         rv.setDescription("returns nothing");

         method.setReturnValue(rv);

         xmlTypeMap = new LinkedHashMap();

         messageStructures = new ArrayList();

         XSOMParser parser = new XSOMParser(); 

         parser.setAnnotationParser(new DomAnnotationParserFactory());

 //        parser.setAnnotationParser(new XsdAnnotationParserFactory());        

         try {

             for (String xsdFileName : this.xsdFileNames) {

 //                System.out.println("Parsing " + xsdFileName);

                 parser.parse(new File(xsdFileName));

             }

         } catch (SAXException ex) {

             throw new IllegalArgumentException(ex);

         } catch (IOException ex) {

             throw new IllegalArgumentException(ex);

         }

         XSSchemaSet schemas;

         try {

             schemas = parser.getResult();

         } catch (SAXException ex) {

             throw new IllegalArgumentException(ex);

         }

 //        for (XSSchema schema : schemas.getSchemas()) {

 //            this.processSchema(schema);

 //        }

         Set<SchemaDocument> schemaDocuments = parser.getDocuments();

         for (SchemaDocument doc : schemaDocuments) {

             XSSchema schema = doc.getSchema();

             this.processSchema(schema);

         }

     }

     private void processSchema(XSSchema schema) {

         for (XSElementDecl element : schema.getElementDecls().values()) {

             this.addElementDecl(element);

         }

         for (XSSimpleType st : schema.getSimpleTypes().values()) {

 //            System.out.println("SimpleType =" + st.getName() + " namespace=" + st.getTargetNamespace());

             addSimpleType(st);

         }

         for (XSComplexType ct : schema.getComplexTypes().values()) {

             if (!shouldInclude(ct)) {

 //                System.out.println("Skipping ComplexType =" + ct.getName() + " namespace=" + ct.getTargetNamespace());

                 continue;

             }

 //            System.out.println("ComplexType =" + ct.getName() + " namespace=" + ct.getTargetNamespace());

             addComplexType(ct);

         }

     }

     private boolean shouldInclude(XSComplexType ct) {

 //        if (ct.getTargetNamespace().equals("urn:org:pesc:core:CoreMain:v1.8.0")) {

         return true;

 //        }

 //        return false;

     }

     private void addSimpleType(XSSimpleType simpleType) {

         XmlType xmlType = xmlTypeMap.get(simpleType.getName());

         if (xmlType != null) {

 //            System.out.println("Already processed simple Type="

 //                    + simpleType.getName());

             return;

         }

         xmlType = new XmlType();

         xmlTypeMap.put(simpleType.getName(), xmlType);

         xmlType.setName(simpleType.getName());

         xmlType.setDesc(calcMissing(calcDesc(simpleType.getAnnotation())));

         xmlType.setComments("???");

         xmlType.setExamples("???");

         xmlType.setService("Pesc");

         xmlType.setPrimitive("Primitive");

     }

     private void addComplexType(XSComplexType complexType) {

         addComplexType(complexType, complexType.getName());

     }

     private void addElementDecl(XSElementDecl element) {

         String name = element.getName();

         XmlType xmlType = xmlTypeMap.get(name);

         if (xmlType != null) {

 //            System.out.println("Already processed element name=" + name);

             return;

         }

 //        System.out.println("processing element=" + name);

         xmlType = new XmlType();

         xmlTypeMap.put(name, xmlType);

         xmlType.setName(name);

         xmlType.setDesc(calcMissing(calcDesc(element.getAnnotation())));

         xmlType.setComments("???");

         xmlType.setExamples("???");

         xmlType.setService("Pesc");

         xmlType.setPrimitive(XmlType.COMPLEX);

         addMessageStructure(xmlType.getName(), element);

     }

     private void addComplexType(XSComplexType complexType, String name) {

         XmlType xmlType = xmlTypeMap.get(name);

         if (xmlType != null) {

 //            System.out.println("Already processed complex Type=" + name);

             return;

         }

 //        System.out.println("processing complex type=" + name);

         xmlType = new XmlType();

         xmlTypeMap.put(name, xmlType);

         xmlType.setName(name);

         xmlType.setDesc(calcMissing(calcDesc(complexType.getAnnotation())));

         xmlType.setComments("???");

         xmlType.setExamples("???");

         xmlType.setService("Pesc");

         xmlType.setPrimitive(XmlType.COMPLEX);

         boolean found = false;

         XSContentType contentType = complexType.getContentType();

         XSParticle particle = contentType.asParticle();

         if (particle != null) {

             XSTerm term = particle.getTerm();

             if (term.isModelGroup()) {

                 XSModelGroup xsModelGroup = term.asModelGroup();

                 XSParticle[] particles = xsModelGroup.getChildren();

                 for (XSParticle p : particles) {

                     XSTerm pterm = p.getTerm();

                     if (pterm.isElementDecl()) { //xs:element inside complex type

                         XSElementDecl element = pterm.asElementDecl();

                         addMessageStructure(xmlType.getName(), element);

                         found = true;

                     }

                 }

             }

         }

 //        if (!found) {

 //            System.out.println("*** WARNING *** Complex Type, " + xmlType.getName() + ", has no message structure fields");

 //        }

     }

     private String calcMissing(String str) {

         if (str == null) {

             return "???";

         }

         if (str.trim().isEmpty()) {

             return "???";

         }

         return str;

     }

     private String calcDesc(XSAnnotation annotation) {

         if (annotation == null) {

             return null;

         }

         if (annotation.getAnnotation() == null) {

             return null;

         }

         return annotation.getAnnotation().toString();

     }

     private void addMessageStructure(String xmlObject, XSElementDecl element) {

         MessageStructure ms = new MessageStructure();

         this.messageStructures.add(ms);

         ms.setXmlObject(xmlObject);

         ms.setShortName(element.getName());

         ms.setName("???");

         ms.setId(xmlObject + "." + ms.getShortName());

         ms.setType(calcType(element, xmlObject + "" + ms.getShortName()));

         ms.setDescription(calcMissing(calcDesc(element.getAnnotation())));

 //        System.out.println("Element " + ms.getId() + " " + ms.getType());

         ms.setRequired(calcRequired(element));

         ms.setCardinality(calcCardinality(element));

     }

     private String calcType(XSElementDecl element, String inLinePrefix) {

         String type = calcType(element.getType(), inLinePrefix);

         if (type != null) {

             return type;

         }

         return type;

     }

     private String calcType(XSType xsType, String inLinePrefix) {

         if (xsType.isSimpleType()) {

             XSSimpleType st = xsType.asSimpleType();

             return st.getBaseType().getName();

 //   if (st.isRestriction ())

 //   {

 //    XSRestrictionSimpleType res = st.asRestriction ();

 //    return res.getBaseType ().getName ();

 //   }

         }

         String type = xsType.getName();

         if (type != null) {

             return type;

         }

         if ((xsType.isComplexType())) {

             XSComplexType ct = xsType.asComplexType();

             String baseType = ct.getBaseType().getName();

             if (baseType.equals("anyType")) {

                 baseType = "";

             }

             String inlineTypeName = inLinePrefix + baseType;

             addComplexType(ct, inlineTypeName);

             return inlineTypeName;

         }

         throw new IllegalArgumentException("cannot calculate the type of the field " + inLinePrefix);

     }

     private String calcRequired(XSElementDecl element) {

         // TODO: isNillable seems to ALWAYS be true so... figure out another way        

 //        if (element.isNillable()) {

 //            return null;

 //        }

 //        return "Required";

         // TODO: facets only hold min/maxLength not min/maxOccurs find out where min/maxOccurs is parsed into        

 //        String minOccurs = this.getFacetValue(element, "minOccurs");

 //        if (minOccurs == null) {

 //            return "No";

 //        }

 //        if (minOccurs.equals("0")) {

 //            return "No";

 //        }

 //        System.out.println(element.getName() + " has a minOccurs that is " + minOccurs);

 //        return "Required";

         return "???";

     }

     private String calcCardinality(XSElementDecl element) {

 //        if (element.getName().equals ("NoteMessage")) {

 //            System.out.println ("start debugging because NoteMessage has maxOccurs=unbounded");

 //        }

         if (this.getIsRepeated(element)) {

             return "Many";

         }

         // TODO: facets only hold min/maxLength not min/maxOccurs find out where min/maxOccurs is parsed into

 //        String maxOccurs = this.getFacetValue(element, "maxOccurs");

 //        if (maxOccurs == null) {

 //            return "One";

 //        }

 //        if (maxOccurs.equals("unbounded")) {

 //            return "Many";

 //        }

 //        System.out.println(element.getName() + " has a maxOccurs that is " + maxOccurs);

 //        return "Many";

         return null;

     }

     private boolean getIsRepeated (XSElementDecl element) {

         XSType type = element.getType();

         if (type == null) {

             return false;

         }

         if (type.isComplexType()) {

             XSContentType contentType = type.asComplexType().getContentType();

             if (contentType == null) {

                 return false;

             }

             XSParticle particle = contentType.asParticle();

             if (particle == null) {

                 return false;

             }

             particle.isRepeated();

         }

 //        if (type.isSimpleType())

         return false;

     }

     private String getFacetValue(XSElementDecl element, String name) {

         XSType type = element.getType();

         if (type == null) {

             return null;

         }

         if (type.isSimpleType()) {

             XSFacet facet = type.asSimpleType().getFacet(name);

             if (facet == null) {

                 return null;

             }

             return facet.getValue().toString();

         }

         if (type.isComplexType()) {

             XSContentType contentType = type.asComplexType().getContentType();

             if (contentType == null) {

                 return null;

             }

             XSSimpleType simpleType = contentType.asSimpleType();

             if (simpleType == null) {

                 return null;

             }

             XSFacet facet = simpleType.getFacet(name);

             if (facet == null) {

                 return null;

             }

             return facet.getValue().toString();

         }

         return null;

     }

     /**

      * helper class

      */

     private static class XsdAnnotationParserFactory implements AnnotationParserFactory {

         @Override

         public AnnotationParser create() {

             return new XsdAnnotationParser();

         }

     }

     /** 

      * helper class

      */

     private static class XsdAnnotationParser extends AnnotationParser {

         private StringBuilder documentation = new StringBuilder();

         @Override

         public ContentHandler getContentHandler(AnnotationContext context,

                 String parentElementName,

                 ErrorHandler handler,

                 EntityResolver resolver) {

             return new XsdContentHandler(documentation);

         }

         @Override

         public Object getResult(Object existing) {

             return documentation.toString().trim();

         }

     }

     /**

      * helper class

      */

     private static class XsdContentHandler implements ContentHandler {

         private StringBuilder documentation;

         public XsdContentHandler(StringBuilder documentation) {

             this.documentation = documentation;

         }

         private boolean parsingDocumentation = false;

         @Override

         public void characters(char[] ch, int start, int length)

                 throws SAXException {

             if (parsingDocumentation) {

                 documentation.append(ch, start, length);

             }

         }

         @Override

         public void endElement(String uri, String localName, String name)

                 throws SAXException {

             if (localName.equals("documentation")) {

                 parsingDocumentation = false;

             }

         }

         @Override

         public void startElement(String uri, String localName, String name,

                 Attributes atts) throws SAXException {

             if (localName.equals("documentation")) {

                 parsingDocumentation = true;

             }

         }

         @Override

         public void endDocument() throws SAXException {

             // do nothing

         }

         @Override

         public void endPrefixMapping(String prefix) throws SAXException {

             // do nothing

         }

         @Override

         public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {

             // do nothing

         }

         @Override

         public void processingInstruction(String target, String data) throws SAXException {

             // do nothing

         }

         @Override

         public void setDocumentLocator(Locator locator) {

             // do nothing

         }

         @Override

         public void skippedEntity(String name) throws SAXException {

             // do nothing

         }

         @Override

         public void startDocument() throws SAXException {

             // do nothing

         }

         @Override

         public void startPrefixMapping(String prefix, String uri) throws SAXException {

             // do nothing

         }

     }

 }