/*

  * Copyright 2011 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.util;

 import java.io.File;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.PrintStream;

 import java.util.Collections;

 import java.util.Date;

 import java.util.Enumeration;

 import java.util.List;

 import java.util.Stack;

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

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

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

 import org.kuali.student.contract.writer.XmlWriter;

 /**

  *

  * @author nwright

  */

 public class XmlKradBaseDictionaryCreator {

     private ServiceContractModel model;

     private ModelFinder finder;

     private String directory;

     private String className;

     private XmlType xmlType;

     private XmlWriter gwriter;

     private XmlWriter bwriter;

     private List<MessageStructure> messageStructures;

     public XmlKradBaseDictionaryCreator(String directory,

             ServiceContractModel model, String className) {

         this.directory = directory;

         this.model = model;

         this.finder = new ModelFinder(this.model);

         this.className = className;

         this.xmlType = this.finder.findXmlType(className);

         if (xmlType == null) {

             throw new IllegalArgumentException(className);

         }

         this.messageStructures = this.finder.findMessageStructures(className);

         if (this.messageStructures.isEmpty()) {

             throw new IllegalStateException(className);

         }

     }

     public void write() {

         this.initXmlWriters();

         this.writeSpringHeaderOpen(gwriter);

         this.writeWarning(gwriter);

         this.writeGeneratedImports(gwriter);

         this.writeGeneratedObjectStructure(gwriter);

         this.writeSpringHeaderClose(gwriter);

         this.writeSpringHeaderOpen(bwriter);

         this.writeNote (bwriter);

         this.writeBaseImports(bwriter);

         this.writeBaseObjectStructure(bwriter);

         this.writeSpringHeaderClose(bwriter);

     }

     private void initXmlWriters() {

         String generatedFileName = "/ks-" + initUpper(className) + "-dictionary-generated.xml";

         String baseFileName = "/ks-" + initUpper(className) + "-dictionary.xml";

         File dir = new File(this.directory);

         //System.out.indentPrintln ("Writing java class: " + fileName + " to " + dir.getAbsolutePath ());

         if (!dir.exists()) {

             if (!dir.mkdirs()) {

                 throw new IllegalStateException("Could not create directory "

                         + this.directory);

             }

         }

         try {

             PrintStream out = new PrintStream(new FileOutputStream(this.directory + "/" + generatedFileName, false));

             this.gwriter = new XmlWriter(out, 0);

         } catch (FileNotFoundException ex) {

             throw new IllegalStateException(ex);

         }

         try {

             PrintStream out = new PrintStream(new FileOutputStream(this.directory + "/" + baseFileName, false));

             this.bwriter = new XmlWriter(out, 0);

         } catch (FileNotFoundException ex) {

             throw new IllegalStateException(ex);

         }

     }

     private static String initLower(String str) {

         if (str == null) {

             return null;

         }

         if (str.length() == 0) {

             return str;

         }

         if (str.length() == 1) {

             return str.toLowerCase();

         }

         return str.substring(0, 1).toLowerCase() + str.substring(1);

     }

     private static String initUpper(String str) {

         if (str == null) {

             return null;

         }

         if (str.length() == 0) {

             return str;

         }

         if (str.length() == 1) {

             return str.toUpperCase();

         }

         return str.substring(0, 1).toUpperCase() + str.substring(1);

     }

     private void writeSpringHeaderClose(XmlWriter out) {

         out.decrementIndent();

         out.indentPrintln("</beans>");

     }

     private void writeSpringHeaderOpen(XmlWriter out) {

         out.indentPrintln("<!--");

         out.indentPrintln(" Copyright 2011 The Kuali Foundation");

         out.println("");

         out.indentPrintln(" Licensed under the Educational Community License, Version 2.0 (the \"License\");");

         out.indentPrintln(" you may not use this file except in compliance with the License.");

         out.indentPrintln(" You may obtain a copy of the License at");

         out.indentPrintln("");

         out.indentPrintln(" http://www.opensource.org/licenses/ecl2.php");

         out.println("");

         out.indentPrintln(" Unless required by applicable law or agreed to in writing, software");

         out.indentPrintln(" distributed under the License is distributed on an \"AS IS\" BASIS,");

         out.indentPrintln(" WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.");

         out.indentPrintln(" See the License for the specific language governing permissions and");

         out.indentPrintln(" limitations under the License.");

         out.indentPrintln("-->");

         out.indentPrintln("<beans xmlns=\"http://www.springframework.org/schema/beans\"");

         out.indentPrintln("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");

         out.indentPrintln("xsi:schemaLocation=\""

                 + "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd" + "\">");

         out.println("");

         out.incrementIndent();

     }

     private void writeWarning(XmlWriter out) {

         out.println("");

         out.indentPrintln("<!-- ********************************************************");

         out.indentPrintln("                           WARNING ");

         out.indentPrintln("                 DO NOT UPDATE THIS FILE MANUALLY");

         out.indentPrintln("    This dictionary file was automatically generated on " + new Date());

         out.indentPrintln("    The DictionaryGeneratorMojo reads the service contract ");

         out.indentPrintln("    and creates these ks-XXXX-dictionary-generated.xml files.");

         out.indentPrintln("    ");

         out.indentPrintln("    If this file is out of sync with the contract re-run the mojo.");

         out.indentPrintln("    ");

         out.indentPrintln("    To add in additional constraints or change these default values (perhaps");

         out.indentPrintln("    because the generator is not perfect) please update the corresponding ");

         out.indentPrintln("    ks-XXXX-dictionary.xml instead of this one.");

         out.indentPrintln("************************************************************* -->");

     }

     private void writeNote(XmlWriter out) {

         out.println("");

         out.indentPrintln("<!-- ********************************************************");

         out.indentPrintln("                           NOTE");

         out.indentPrintln("              THIS FILE WAS INTENDED TO BE MODIFIED");

         out.println ("");        

         out.indentPrintln("    While this file was originally generated on " + new Date());

         out.indentPrintln("    it was intended to be subsequently modified by hand.");

         out.indentPrintln("    It imports a corresponding ks-XXXX-dictionary-generated.xml file");

         out.indentPrintln("    that was also automatically generated by the DictionaryCreatorMojo.");

         out.indentPrintln("    This file gives you the ability to layer in addiditional definitions");

         out.indentPrintln("    that are not/cannot be generated simply by reading the service contract");

         out.println ("");

         out.indentPrintln("    The goal is to be able to easily re-generate the ks-XXXX-dictionary-generated.xml file");        

         out.indentPrintln("    without affecting the manually entered additions that are coded here.");              

         out.indentPrintln("************************************************************* -->");

     }

     private void writeGeneratedImports(XmlWriter out) {

         out.indentPrintln("<import resource=\"classpath:ks-base-dictionary.xml\"/>");

         // TODO: only write out the ones that are used in this structure

 //        out.indentPrintln("<import resource=\"classpath:ks-RichTextInfo-dictionary.xml\"/>");

 //        out.indentPrintln("<import resource=\"classpath:ks-MetaInfo-dictionary.xml\"/>");

     }

     private void writeBaseImports(XmlWriter out) {

         out.indentPrintln("<import resource=\"classpath:ks-" + initUpper(className) + "-dictionary-generated.xml\"/>");

     }

     private String stripListOffEnd(String name) {

         if (name.endsWith("List")) {

             return name.substring(0, name.length() - "List".length());

         }

         return name;

     }

     private void writeSubStructures(XmlType type, Stack<String> stack) {

         boolean first = true;

         for (MessageStructure ms : finder.findMessageStructures(type.getName())) {

             XmlType st = finder.findXmlType(this.stripListOffEnd(ms.getType()));

             if (st == null) {

                 throw new NullPointerException(ms.getType() + " does not exist in list of types with parents " + calcParents(stack));

             }

             if (!st.getPrimitive().equalsIgnoreCase(XmlType.COMPLEX)) {

                 continue;

             }

             if (first) {

                 first = false;

                 gwriter.indentPrintln("<ul>");

             }

             if (!stack.contains(st.getName())) {

                 stack.push(st.getName());

                 this.writeSubStructures(st, stack);

                 stack.pop();

             }

         }

         if (!first) {

             gwriter.indentPrintln("</ul>");

         }

     }

     private String calcParents(Stack<String> stack) {

         StringBuilder sb = new StringBuilder();

         String dot = "";

         Enumeration<String> en = stack.elements();

         while (en.hasMoreElements()) {

             sb.append(dot);

             dot = ".";

             sb.append(en.nextElement());

         }

         return sb.toString();

     }

     private void writeGeneratedObjectStructure(XmlWriter out) {

         //Step 1, create the abstract structure

         out.println("");

         out.indentPrintln("<!-- " + className + "-->");

         out.indentPrintln("<bean id=\"" + initUpper(className) + "-generated\" abstract=\"true\" parent=\"DataObjectEntry\">");

         out.incrementIndent();

         writeProperty("name", initLower(className));

         writeProperty("objectClass", xmlType.getJavaPackage() + "." + initUpper(className));

         writeProperty("objectLabel", calcObjectLabel());

         writeProperty("objectDescription", xmlType.getDesc());

         String titleAttribute = calcTitleAttribute();

         if (titleAttribute != null) {

             writeProperty("titleAttribute", titleAttribute);

         }

         out.indentPrintln("<property name=\"primaryKeys\">");

         List<String> pks = calcPrimaryKeys();

         if (pks != null && !pks.isEmpty()) {

             out.incrementIndent();

             out.indentPrintln("<list>");

             out.incrementIndent();

             for (String pk : pks) {

                 addValue(pk);

             }

             out.decrementIndent();

             out.indentPrintln("</list>");

             out.decrementIndent();

         }

         out.indentPrintln("</property>");

         out.indentPrintln("<property name=\"attributes\">");

         out.incrementIndent();

         out.indentPrintln("<list>");

         out.incrementIndent();

         this.writeGeneratedAttributeRefBeans(className, null, new Stack<String>(), this.messageStructures, out);

         out.decrementIndent();

         out.indentPrintln("</list>");

         out.decrementIndent();

         out.indentPrintln("</property>");

         out.decrementIndent();

         out.indentPrintln("</bean>");

         //Step 2, loop through attributes

         this.writeGeneratedAttributeDefinitions(className, null, new Stack<String>(), this.messageStructures, out);

     }

     private void addValue(String value) {

         gwriter.indentPrintln("<value>" + value + "</value>");

     }

     private String calcObjectLabel() {

         String label = this.className;

         if (label.endsWith("Info")) {

             label = label.substring(0, label.length() - "Info".length());

         }

         label = initUpper(label);

         return splitCamelCase(label);

     }

     // got this from http://stackoverflow.com/questions/2559759/how-do-i-convert-camelcase-into-human-readable-names-in-java

     private static String splitCamelCase(String s) {

         return s.replaceAll(

                 String.format("%s|%s|%s",

                 "(?<=[A-Z])(?=[A-Z][a-z])",

                 "(?<=[^A-Z])(?=[A-Z])",

                 "(?<=[A-Za-z])(?=[^A-Za-z])"),

                 " ");

     }

     private void writeGeneratedAttributeRefBeans(String className, String parentFieldName,

             Stack<String> parents, List<MessageStructure> fields, XmlWriter out) {

         if (parents.contains(className)) {

             return;

         }

         for (MessageStructure ms : fields) {

             String fieldName = calcFieldName(className, parentFieldName, ms);

             out.indentPrintln("<ref bean=\"" + fieldName + "\"/>");

             // Add complex sub-types fields

             String childTypeName = this.stripListOffEnd(ms.getType());

             XmlType childType = this.finder.findXmlType(childTypeName);

             if (childType == null) {

                 throw new IllegalStateException(childTypeName);

             }

             if (childType.getPrimitive().equalsIgnoreCase(XmlType.COMPLEX)) {

                 parents.push(className);

                 List<MessageStructure> childFields = this.finder.findMessageStructures(childTypeName);

                 if (childFields.isEmpty()) {

                     throw new IllegalStateException(childTypeName);

                 }

                 writeGeneratedAttributeRefBeans(childTypeName, fieldName, parents, childFields, out);

                 parents.pop();

             }

         }

     }

     private void writeGeneratedAttributeDefinitions(String className, String parentFieldName,

             Stack<String> parents, List<MessageStructure> fields, XmlWriter out) {

         if (parents.contains(className)) {

             return;

         }

         for (MessageStructure ms : fields) {

             String fieldName = calcFieldName(className, parentFieldName, ms);

             String childTypeName = this.stripListOffEnd(ms.getType());

             XmlType childType = this.finder.findXmlType(childTypeName);

             if (childType == null) {

                 throw new IllegalStateException(childTypeName);

             }

             writeGeneratedAttributeDefinition(className, parentFieldName, ms, out);

             // Add complex sub-types fields

             if (childType.getPrimitive().equalsIgnoreCase(XmlType.COMPLEX)) {

                 parents.push(className);

                 List<MessageStructure> childFields = this.finder.findMessageStructures(childTypeName);

                 if (childFields.isEmpty()) {

                     throw new IllegalStateException(childTypeName);

                 }

                 writeGeneratedAttributeDefinitions(childTypeName, fieldName, parents, childFields, out);

                 parents.pop();

             }

         }

     }

     private void writeGeneratedAttributeDefinition(String className, String parentFieldName, MessageStructure ms, XmlWriter out) {

         //Create the abstract field

         String fieldName = this.calcFieldName(className, parentFieldName, ms);

         String baseKualiType = this.calcBaseKualiType(ms);

         out.println("");

         out.indentPrintln("<bean id=\"" + fieldName + "-generated\" abstract=\"true\" parent=\"" + baseKualiType + "\">");

         out.incrementIndent();

         writeProperty("name", initLower(ms.getShortName()));

         if (ms.isOverriden()) {

             writeProperty("shortLabel", ms.getName());

         }

         out.decrementIndent();

         // TODO: implement maxoccurs

 //        if (isList(pd)) {

 //            addProperty("maxOccurs", "" + DictionaryConstants.UNBOUNDED, s);

 //        }

         out.indentPrintln("</bean>");

     }

     private void writeBaseObjectStructure(XmlWriter out) {

         //Step 1, create the parent bean

         out.println("");

         out.indentPrintln("<!-- " + className + "-->");

         out.indentPrintln("<bean id=\"" + initUpper(className) + "-parent\" abstract=\"true\" parent=\"" + initUpper(className) + "-generated\">");

         out.writeComment("insert any overrides to the generated object definitions here");

         out.indentPrintln("</bean>");

         //Create the actual instance of the bean

         out.indentPrintln("<bean id=\"" + initUpper(className) + "\" parent=\"" + initUpper(className) + "-parent\"/>");

         out.println("");

         //Step 2, loop through attributes

         this.writeBaseAttributeDefinitions(className, null, new Stack<String>(), this.messageStructures, out);

     }

     private void writeBaseAttributeDefinitions(String className, String parentFieldName,

             Stack<String> parents, List<MessageStructure> fields, XmlWriter out) {

         if (parents.contains(className)) {

             return;

         }

         for (MessageStructure ms : fields) {

             String fieldName = calcFieldName(className, parentFieldName, ms);

             String childTypeName = this.stripListOffEnd(ms.getType());

             XmlType childType = this.finder.findXmlType(childTypeName);

             if (childType == null) {

                 throw new IllegalStateException(childTypeName);

             }

             writeBaseAttributeDefinition(className, parentFieldName, ms, out);

             // Add complex sub-types fields

             if (childType.getPrimitive().equalsIgnoreCase(XmlType.COMPLEX)) {

                 parents.push(className);

                 List<MessageStructure> childFields = this.finder.findMessageStructures(childTypeName);

                 if (childFields.isEmpty()) {

                     throw new IllegalStateException(childTypeName);

                 }

                 writeBaseAttributeDefinitions(childTypeName, fieldName, parents, childFields, out);

                 parents.pop();

             }

         }

     }

     private void writeBaseAttributeDefinition(String className, String parentFieldName, MessageStructure ms, XmlWriter out) {

         //Create the abstract field

         String fieldName = this.calcFieldName(className, parentFieldName, ms);

 //        String baseKualiType = this.calcBaseKualiType(ms);

         out.println("");

         out.indentPrintln("<bean id=\"" + fieldName + "-parent\" abstract=\"true\" parent=\"" + fieldName + "-generated\">");

         out.writeComment("insert any overrides to the generated attribute definitions here");

         out.indentPrintln("</bean>");

         //Create the actual bean instance

         out.indentPrintln("<bean id=\"" + fieldName + "\" parent=\"" + fieldName + "-parent\"/>");

     }

     private String calcBaseKualiType(MessageStructure ms) {

         String name = ms.getShortName();

         if (name.equals("id")) {

             return "BaseKuali.id";

         }

         if (name.equals("key")) {

             return "BaseKuali.key";

         }

         if (name.equals("descr")) {

             return "BaseKuali.descr";

         }

         if (name.equals("name")) {

             return "BaseKuali.name";

         }

         if (name.equals("typeKey")) {

             return "BaseKuali.typeKey";

         }

         if (name.equals("stateKey")) {

             return "BaseKuali.stateKey";

         }

         // to handle r1 services

         if (name.equals("type")) {

             return "BaseKuali.typeKey";

         }

         if (name.equals("state")) {

             return "BaseKuali.stateKey";

         }

         if (name.equals("effectiveDate")) {

             return "BaseKuali.effectiveDate";

         }

         if (name.equals("expirationDate")) {

             return "BaseKuali.expirationDate";

         }

         if (name.endsWith("orgId")) {

             return "BaseKuali.orgId";

         }

         if (name.endsWith("personId")) {

             return "BaseKuali.personId";

         }

         if (name.endsWith("principalId")) {

             return "BaseKuali.principalId";

         }

         if (name.endsWith("cluId")) {

             return "BaseKuali.cluId";

         }

         if (name.endsWith("luiId")) {

             return "BaseKuali.luiId";

         }

         if (name.endsWith("Code")) {

             return "BaseKuali.code";

         }

         // now key off the type

         String type = this.stripListOffEnd(ms.getType());

         if (type.equalsIgnoreCase("String")) {

             return "BaseKuali.string";

         }

         if (type.equalsIgnoreCase("DateTime")) {

             return "BaseKuali.dateTime";

         }

         if (type.equalsIgnoreCase("Date")) {

             return "BaseKuali.date";

         }

         if (type.equalsIgnoreCase("Boolean")) {

             return "BaseKuali.boolean";

         }

         if (type.equalsIgnoreCase("Integer")) {

             return "BaseKuali.integer";

         }

 //        if (type.equalsIgnoreCase("Float")) {

 //            return "BaseKuali.Currency";

 //        }

         if (type.equalsIgnoreCase(XmlType.COMPLEX)) {

             return "BaseKuali.complex";

         }

         // all else fails call it a string

         return "BaseKuali.string";

     }

     private String calcFieldName(String className, String parentFieldName, MessageStructure ms) {

         if (parentFieldName == null) {

             return initUpper(className) + "." + initLower(ms.getShortName());

         }

         return parentFieldName + "." + initLower(ms.getShortName());

     }

     private String calcTitleAttribute() {

         MessageStructure ms = null;

         ms = this.findMessageStructure("name");

         if (ms != null) {

             return initLower(ms.getShortName());

         }

         ms = this.findMessageStructure("title");

         if (ms != null) {

             return initLower(ms.getShortName());

         }

         ms = this.findMessageStructureEndsWith("name");

         if (ms != null) {

             return initLower(ms.getShortName());

         }

         ms = this.findMessageStructureEndsWith("title");

         if (ms != null) {

             return initLower(ms.getShortName());

         }

         ms = this.findMessageStructure("key");

         if (ms != null) {

             return initLower(ms.getShortName());

         }

         // TODO: consider checking for ID and just returning null

         System.out.println("XmlKradBaseDictionaryCreator: could not find a title attribute for " + this.className);

 //        ms = this.findMessageStructure("id");

 //        if (ms != null) {

 //            return initLower(ms.getShortName());

 //        }

         return null;

     }

     private MessageStructure findMessageStructureEndsWith(String shortNameEndsWith) {

         shortNameEndsWith = shortNameEndsWith.toLowerCase();

         for (MessageStructure ms : this.messageStructures) {

             if (ms.getShortName().toLowerCase().endsWith(shortNameEndsWith)) {

                 return ms;

             }

         }

         return null;

     }

     private MessageStructure findMessageStructure(String shortName) {

         for (MessageStructure ms : this.messageStructures) {

             if (ms.getShortName().equalsIgnoreCase(shortName)) {

                 return ms;

             }

         }

         return null;

     }

     private MessageStructure getMessageStructure(String shortName) {

         MessageStructure ms = this.findMessageStructure(shortName);

         if (ms == null) {

             throw new IllegalArgumentException(shortName);

         }

         return ms;

     }

     private List<String> calcPrimaryKeys() {

         MessageStructure ms = null;

         ms = this.findMessageStructure("id");

         if (ms != null) {

             return Collections.singletonList(initLower(ms.getShortName()));

         }

         ms = this.findMessageStructure("key");

         if (ms != null) {

             return Collections.singletonList(initLower(ms.getShortName()));

         }

         return Collections.EMPTY_LIST;

     }

     private void writeProperty(String propertyName, String propertyValue) {

         gwriter.indentPrintln("<property name=\"" + propertyName + "\" value=\"" + propertyValue + "\"/>");

     }

 }