/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache 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.apache.org/licenses/LICENSE-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.apache.jdo.tck.util;

import java.io.*;

public class ClassGenerator {
  private final String [] fieldTypes       = {"boolean", "byte", "short", "int", "long",
                                              "char", "float", "double",
                                              "Boolean", "Character", "Byte", "Short", "Integer",
                                              "Long", "Float", "Double", "String",
                                              "Locale", "Date", "BigDecimal", "BigInteger",
                                              "Object", "SimpleClass", "SimpleInterface"
                                              };
  //includes a place holder for default package access
  private final String [] accessSpecifiers = {"private ", "public ", "protected ", "" };

  private final String [] fieldModifiers   = {"", "static ", "transient ", "final ", "volatile ",
                                              "static transient ", "static final ", "static volatile ",
                                              "transient final ", "transient volatile ",
                                              "static transient final ", "static transient volatile " };

  private final String [] xmlPersistenceModifiers = {"", "persistence-modifier=\"none\"",
                                                      "persistence-modifier=\"persistent\"",
                                                      "persistence-modifier=\"transactional\""};

  private final String [] xmlEmbeddedModifiers    = {"", "embedded=\"true\"", "embedded=\"false\""};

  private final String [] collectionTypes    = {"Collection", "Map", "Set", "List",
                                               "HashSet", "ArrayList", "HashMap", "Hashtable",
                                               "LinkedList", "TreeMap", "TreeSet", "Vector", "Array"};

  //Note: Any updates to elementtypes should include an update to elementsWithPackageInfo
  private final String [] elementTypes    = {"Object", "SimpleClass", "SimpleInterface", "String",
                                            "Date", "Locale", "BigDecimal", "BigInteger",
                                            "Byte", "Double", "Float", "Integer", "Long",
                                            "Short"};

  private final String [] elementsWithPackageInfo = {"java.lang.Object",
                                                    "org.apache.jdo.tck.pc.fieldtypes.SimpleClass",
                                                    "org.apache.jdo.tck.pc.fieldtypes.SimpleInterface",
                                                    "java.lang.String", "java.util.Date",
                                                    "java.util.Locale", "java.math.BigDecimal",
                                                    "java.math.BigInteger", "java.lang.Byte",
                                                    "java.lang.Double", "java.lang.Float",
                                                    "java.lang.Integer","java.lang.Long",
                                                    "java.lang.Short"};

  private StringBuffer fieldSpecs = new StringBuffer(2000);
  private StringBuffer isPersistent = new StringBuffer(200);
  private StringBuffer isStatic   = new StringBuffer(200);
  private StringBuffer isFinalArray = new StringBuffer(2000);
      
  // can accomodate only 4000 fields, have to increase the capacity if the fields exceed 4000
  private static boolean [] isFinal = new boolean[4000];

  void generate() throws Exception
  {
    final String twoSpaces = "  ";
    final String space = " ";

    for (int i=0; i < fieldTypes.length; i++)
    {
      String classFile = (isPrimitive(fieldTypes[i]) ? "FieldsOfPrimitive" : "FieldsOf") + fieldTypes[i];

      FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n");
      PrintWriter xmlPw = new PrintWriter(xmlFout);
      FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a");
      PrintWriter xmlPw1 = new PrintWriter(xmlFout1);
      FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d");
      PrintWriter xmlPw2 = new PrintWriter(xmlFout2);
      startXmlMetaData(xmlPw);
      startXmlMetaData(xmlPw1);
      startXmlMetaData(xmlPw2);

      startXmlClass(xmlPw,  classFile, 0);
      startXmlClass(xmlPw1, classFile, 1);
      startXmlClass(xmlPw2, classFile, 2);

      FileOutputStream fout = new FileOutputStream(classFile + ".java");
      PrintWriter pw = new PrintWriter(fout);
      startClass(pw, classFile);
      int fieldCounter = 0;
      for(int j=0; j < accessSpecifiers.length; j++)
      {
        for (int k=0; k < fieldModifiers.length; k++)
        {
          for(int l = 0; l < xmlPersistenceModifiers.length; l++)
          {
             // do not generate persistence modifiers (persistent or transactional or none)
             // for fields that cannot be persisted


         if( (fieldModifiers[k].indexOf("static") >= 0 || fieldModifiers[k].indexOf("final") >= 0 ) &&
            !xmlPersistenceModifiers[l].equals(""))
                continue;                
             
/*        original code
         if(!isPersistenceCapable(fieldModifiers[k])
                  && !xmlPersistenceModifiers[l].equals(""))
                continue;
*/
             for(int m=0; m < xmlEmbeddedModifiers.length; m++) {
                 // generate persistence modifiers (persistent or transactional or none)
                 // only for fields that can be persisted
                 // generate embedded modifiers only for persistent fields
                 
                 boolean fieldIsPersistent = !( fieldModifiers[k].indexOf("static") >= 0 ||
                                                fieldModifiers[k].indexOf("final")  >= 0 ||
                                                xmlPersistenceModifiers[l].indexOf("none") >= 0 ||
                                                xmlPersistenceModifiers[l].indexOf("transactional") >= 0 ||
                                                (fieldModifiers[k].indexOf("transient") >= 0 && xmlPersistenceModifiers[l].indexOf("persistent") == -1)
                                              ); 
                                                
                 if(!xmlEmbeddedModifiers[m].equals("") && !fieldIsPersistent )
                  continue;

                 StringBuffer sb = new StringBuffer();
                 sb.append(twoSpaces);
                 sb.append(accessSpecifiers[j]);
                 sb.append(fieldModifiers[k]);
                 sb.append(fieldTypes[i]);
                 sb.append(space);
                 String fieldName = (fieldTypes[i] + fieldCounter++);
//temporary fix to get around the bug in the enhancer code
if(!(xmlEmbeddedModifiers[m].equals("") &&  xmlPersistenceModifiers[l].equals("")))
{
                 printXmlField(xmlPw, "name=\"" + fieldName + "\" "
                               + xmlPersistenceModifiers[l]+ " "
                               + xmlEmbeddedModifiers[m]);
                 printXmlField(xmlPw1, "name=\"" + fieldName + "\" "
                               + xmlPersistenceModifiers[l]+ " "
                               + xmlEmbeddedModifiers[m]);
                 printXmlField(xmlPw2, "name=\"" + fieldName + "\" "
                               + xmlPersistenceModifiers[l]+ " "
                               + xmlEmbeddedModifiers[m]);
}//end temporary fix
                 sb.append(fieldName);
                 buildisPersistentArray(fieldIsPersistent); // add to isPersistentArray
                 buildisStaticArray(isStatic(fieldModifiers[k])); // add to isStaticArray
                 buildFieldSpecs(xmlPersistenceModifiers[l].replace('"',' ') + " " +
                                 xmlEmbeddedModifiers[m].replace('"',' ') +
                                 sb.toString()); // add to the field specs array
                 isFinal[fieldCounter-1] = fieldModifiers[k].indexOf("final") >= 0;
                 if(isFinal[fieldCounter-1])
                   sb.append(getInitializerForFinalTypes(fieldTypes[i]));
                 buildisFinalArray(isFinal[fieldCounter-1]);
                 sb.append(";");
                 pw.println(sb.toString());
             }
           }
         }
       }
       writeisPersistentArray(pw);
       writeisStaticArray(pw);
       writeisFinalArray(pw);
       writeFieldSpecs(pw);
       writeMethodGetLength(pw);
       writeMethodGet(pw, fieldTypes[i], fieldCounter);
       writeMethodSet(pw, fieldTypes[i], fieldCounter);
       endClass(pw);
       pw.close();
       fout.close();

       endXmlClass(xmlPw);
       endXmlClass(xmlPw1);
       endXmlClass(xmlPw2);
       endXmlMetaDeta(xmlPw);
       endXmlMetaDeta(xmlPw1);
       endXmlMetaDeta(xmlPw2);
       xmlPw.close();
       xmlFout.close();
       xmlPw1.close();
       xmlFout1.close();
       xmlPw2.close();
       xmlFout2.close();
     }
 }


  private void startClass(PrintWriter pw, String className)
  {
    pw.println("package org.apache.jdo.tck.pc.fieldtypes;");
    pw.println("");
    pw.println(getImportStatements(className));
    pw.println("public class " + className + " { " );
    pw.println("  public int identifier;");
  }

  private void endClass(PrintWriter pw)
  {
    pw.println("");
    pw.println("}");
  }

  private void startXmlMetaData(PrintWriter pw)
  {
    pw.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
    pw.println("<!DOCTYPE jdo SYSTEM \"jdo.dtd\">");
    pw.println("<jdo>");
    pw.println("<package name=\"org.apache.jdo.tck.pc.fieldtypes\">");
  }

  private void endXmlMetaDeta(PrintWriter pw)
  {
    pw.println("</package>");
    pw.println("</jdo>");
  }

  private void startXmlClass(PrintWriter pw, String className, int type)
  {
    switch(type)
    {
      case(0):
        pw.println("<class name=\"" + className + "\">");
        break;
      case(1):
        pw.println("<class name=\"" + className + "\" identity-type=\"application\">");
        break;
      case(2):
        pw.println("<class name=\"" + className + "\" identity-type=\"datastore\">");
        break;
      default:
        System.out.println("Unsupported Type");
    }
  }

  private void endXmlClass(PrintWriter pw)
  {
    pw.println("</class>");
  }

  // need to check if we should support extents
  // fieldName includes modifiers
  private void printXmlField(PrintWriter pw, String fieldName)
  {
    pw.println("<field " + fieldName  + ">");
    pw.println("</field>");
  }

  // fieldname does not include any modifiers.
  // element type includes package informaiton.
  private void printXmlCollectionFieldWithEmbeddedElement(PrintWriter pw, String fieldName,
                                                          String elementType, String embeddedValue)
  {
    pw.println("<field name=\"" + fieldName + "\" " + ">");
    pw.print("<collection element-type=" + "\"" + elementType + "\"");
    if(!embeddedValue.equals(""))
      pw.print(" embedded-element=" + "\"" + embeddedValue + "\"");
    pw.println(">");
    pw.println("</collection>");
    pw.println("</field>");
  }

  private void printXmlArrayFieldWithEmbeddedElement(PrintWriter pw, String fieldName,
                                                     String embeddedValue)
  {
    pw.println("<field name=\"" + fieldName + "\" " + ">");
    pw.println("<array embedded-element=" +  "\"" + embeddedValue + "\"" + ">");
    pw.println("</array>");
    pw.println("</field>");
  }

  private void printXmlMapField(PrintWriter pw, String fieldName, String keyType,
                                String embeddedKey, String valueType, String embeddedValue)
  {
    pw.println("<field name=\"" + fieldName + "\" " + ">");
    pw.print("<map ");
    if(!keyType.equals(""))
      pw.print(" key-type=" + "\"" + keyType + "\"");
    if(!embeddedKey.equals(""))
      pw.print(" embedded-key=" + "\"" + embeddedKey + "\"");
    if(!valueType.equals(""))
      pw.print(" value-type=" + "\"" + valueType + "\"");
    if(!embeddedValue.equals(""))
      pw.print(" embedded-value=" + "\"" + embeddedValue + "\"");
    pw.println(">");
    pw.println("</map>");
    pw.println("</field>");
  }

  private String getInitializerForFinalTypes(String fieldType) throws Exception
  {
    if (fieldType.equals("char"))
      return " = 'a'"; //primitive character, return 'a';
    else if (fieldType.equals("boolean"))
      return " = false"; //primitive boolean, return 'a';
    else if (Character.isLowerCase(fieldType.charAt(0)))
      return " = 5"; // return 0 for all other primitive types
    else if (fieldType.equals("Byte"))
      return " = Byte.valueOf((byte)5)";
    else if (fieldType.equals("Boolean"))
      return " = Boolean.FALSE";
    else if (fieldType.equals("Character"))
      return " = Character.valueOf('a')";
    else if (fieldType.equals("Short"))
      return " = Short.valueOf((short)5)";
    else if (fieldType.equals("Integer"))
      return " = Integer.valueOf((int)5)";
    else if (fieldType.equals("Long"))
      return " = Long.valueOf((long)5)";
    else if (fieldType.equals("Float"))
      return " = Float.valueOf((float)5)";
    else if (fieldType.equals("Double"))
      return " = Double.valueOf((double)5)";
    else if (fieldType.equals("String"))
      return " = new String(\"JDO TCK\")";
    else if (fieldType.equals("Locale"))
      return " = Locale.US";
    else if (fieldType.equals("BigDecimal"))
      return " = new BigDecimal(100.15)";
    else if (fieldType.equals("BigInteger"))
      return " = new BigInteger(\"100\")";
    else if (fieldType.equals("Collection"))
      return " = new HashSet()";
    else if (fieldType.equals("Set"))
      return " = new HashSet()";
    else if (fieldType.equals("HashSet"))
      return " = new HashSet()";
   else if (fieldType.equals("Object"))
      return " = new Object()";
    else if (fieldType.equals("SimpleClass"))
      return " = new SimpleClass()";
    else if (fieldType.equals("SimpleInterface"))
      return " = new SimpleClass()";
    else if (fieldType.equals("Date"))
      return " = new Date()";
    else
      throw new Exception("Unsupported FieldType " + fieldType);
  }

  private String getImportStatements(String fieldType)
  {
    if (fieldType.equals("FieldsOfLocale"))
      return "import java.util.*;";
    if (fieldType.equals("FieldsOfDate"))
      return "import java.util.*;";
    else if (fieldType.equals("FieldsOfBigDecimal"))
      return "import java.math.*;";
    else if (fieldType.equals("FieldsOfBigInteger"))
      return "import java.math.*;";
    else if (fieldType.equals("FieldsOfCollection"))
      return "import java.util.*;";
    else if (fieldType.equals("FieldsOfSet"))
      return "import java.util.*;";
    else if (fieldType.equals("FieldsOfHashSet"))
      return "import java.util.*;";
    else if (fieldType.indexOf("Collections") >=0)
      return "import java.util.*;\r\nimport java.math.*;";
    else
      return "";
  }

  private boolean isPrimitive(String fieldType)
  {
     if (Character.isUpperCase(fieldType.charAt(0)))
      return false;
     else
      return true;
  }

  private boolean isPersistenceCapable(String fieldModifier)
  {
     if (fieldModifier.indexOf("static") >= 0
         || fieldModifier.indexOf("final") >= 0
         || fieldModifier.indexOf("transient") >= 0)
       return false;
     else
       return true;
  }

 private boolean isStatic(String fieldModifier)
  {
     if (fieldModifier.indexOf("static") >= 0)
       return true;
     else
       return false;
  }
  private boolean isFinal(String fieldModifier)
  {
      return fieldModifier.indexOf("final") >= 0;
  }
  private void buildisPersistentArray(boolean value)
  {
    if(isPersistent.length() != 0)
      isPersistent.append(",");
    if(value)
      isPersistent.append("true");
    else
      isPersistent.append("false");
  }

  private void buildisStaticArray(boolean value)
  {
    if(isStatic.length() != 0)
      isStatic.append(",");
    if(value)
      isStatic.append("true");
    else
      isStatic.append("false");
  }

  private void buildisFinalArray(boolean value)
  {
    if(isFinalArray.length() != 0)
      isFinalArray.append(",");
    if(value)
      isFinalArray.append("true");
    else
      isFinalArray.append("false");
  }


  private void writeisPersistentArray(PrintWriter pw)
  {
     // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only
     // 1024 characters
     char [] charArray = new char[isPersistent.length()];
     isPersistent.getChars(0,isPersistent.length(),charArray,0);
     pw.println("");
     pw.println("public static final boolean [] isPersistent = { ");

     int fieldCounter=0;
     for(int i = 0; i < charArray.length; i++)
     {
        pw.print(charArray[i]);
        if(charArray[i] == ',')
        {
          fieldCounter++;
          if(fieldCounter == 10)
          {
            pw.println("");
            pw.flush();
            fieldCounter = 0;
          }
        }
     }
     pw.println("");
     pw.println(" };");
     isPersistent = new StringBuffer(2000);
   }


  private void writeisStaticArray(PrintWriter pw)
  {
     // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only
     // 1024 characters
     char [] charArray = new char[isStatic.length()];
     isStatic.getChars(0,isStatic.length(),charArray,0);
     pw.println("");
     pw.println("public static final boolean [] isStatic = { ");

     int fieldCounter=0;
     for(int i = 0; i < charArray.length; i++)
     {
        pw.print(charArray[i]);
        if(charArray[i] == ',')
        {
          fieldCounter++;
          if(fieldCounter == 10)
          {
            pw.println("");
            pw.flush();
            fieldCounter = 0;
          }
        }
     }
     pw.println("");
     pw.println(" };");
     isStatic = new StringBuffer(2000);
   }
  private void writeisFinalArray(PrintWriter pw)
  {
     // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only
     // 1024 characters
     char [] charArray = new char[isFinalArray.length()];
     isFinalArray.getChars(0,isFinalArray.length(),charArray,0);
     pw.println("");
     pw.println("public static final boolean [] isFinal = { ");

     int fieldCounter=0;
     for(int i = 0; i < charArray.length; i++)
     {
        pw.print(charArray[i]);
        if(charArray[i] == ',')
        {
          fieldCounter++;
          if(fieldCounter == 10)
          {
            pw.println("");
            pw.flush();
            fieldCounter = 0;
          }
        }
     }
     pw.println("");
     pw.println(" };");
     isFinalArray = new StringBuffer(2000);
   }

  private void buildFieldSpecs(String field)
  {
    if(fieldSpecs.length() != 0)
      fieldSpecs.append(",");

    fieldSpecs.append("\"");
    fieldSpecs.append(field.trim());
    fieldSpecs.append("\"");
  }


  private void writeFieldSpecs(PrintWriter pw)
  {
    // have to go through this hoopla because pw.println(fieldSpecs.toString()); outputs only
    // 1024 characters
    char [] charArray = new char[fieldSpecs.length()];
    fieldSpecs.getChars(0,fieldSpecs.length(),charArray,0);
    pw.println("");
    pw.println("  public static final String [] fieldSpecs = { ");

    pw.print("  ");
    for(int i = 0; i < charArray.length; i++)
    {
       pw.print(charArray[i]);
       if(charArray[i] == ',')
       {
         pw.println("");
         pw.print("  ");
         pw.flush();
       }
    }
    pw.println("");
    pw.println("  };");
    fieldSpecs = new StringBuffer(2000);
  }

  private void writeMethodGetLength(PrintWriter pw)
  {
     pw.println("  public int getLength()");
     pw.println("  {");
     pw.println("    return fieldSpecs.length;");
     pw.println("  }");
  }

  private void writeMethodGet(PrintWriter pw, String fieldType, int numberOfFields)
  {
     pw.println("  public " +fieldType+ " get(int index)");
     pw.println("  {");

     pw.println("    switch (index)");
     pw.println("    {");
     for(int i = 0; i < numberOfFields; i++)
     {
       pw.println("      case(" + i + "):");
       pw.println("        return " + fieldType + i +";");
     }
     pw.println("      default:");
     pw.println("        throw new IndexOutOfBoundsException();");
     pw.println("    }");
     pw.println("  }");
  }

  private void writeMethodGet(PrintWriter pw, String fieldType, String[] fieldNames, int numFields)
  {
     pw.println("  public " +fieldType+ " get(int index)");
     pw.println("  {");

     pw.println("    switch (index)");
     pw.println("    {");
     for(int i = 0; i < numFields; i++)
     {
       pw.println("      case(" + i + "):");
       pw.println("        return " + fieldNames[i] +";");
     }
     pw.println("      default:");
     pw.println("        throw new IndexOutOfBoundsException();");
     pw.println("    }");
     pw.println("  }");
  }
  private void writeMethodSet(PrintWriter pw, String fieldType, int numberOfFields)
  {
     pw.println("  public boolean set(int index," + fieldType + " value"+ ")");
     pw.println("  {");
     pw.println("    if(fieldSpecs[index].indexOf(\"final\") != -1)");
     pw.println("      return false;");

     pw.println("    switch (index)");
     pw.println("    {");
     for(int i = 0; i < numberOfFields; i++)
     {
       if(!isFinal[i])
       {
         pw.println("      case(" + i + "):");
         pw.println("        " + fieldType + i + "= value" + ";");
         pw.println("         break;" );
       }
     }
     pw.println("      default:");
     pw.println("        throw new IndexOutOfBoundsException();");
     pw.println("    }");
     pw.println("    return true;");
     pw.println("  }");
  }

  private void writeMethodSet(PrintWriter pw, String fieldType, String [] fieldNames, int numFields)
  {
     pw.println("  public boolean set(int index," + fieldType + " value"+ ")");
     pw.println("  {");
     pw.println("    if(fieldSpecs[index].indexOf(\"final\") != -1)");
     pw.println("      return false;");

     pw.println("    switch (index)");
     pw.println("    {");
     for(int i = 0; i < numFields; i++)
     {
//       if(!isFinal[i]) {
         pw.println("      case(" + i + "):");
         pw.println("        " + fieldNames[i] + "= value" + ";");
         pw.println("         break;" );
//       }
     }
     pw.println("      default:");
     pw.println("        throw new IndexOutOfBoundsException();");
     pw.println("    }");
     pw.println("    return true;");
     pw.println("  }");
  }


  private void writeMethodSetForArray(PrintWriter pw, String fieldType, String [] fieldNames, int numFields)
  {
     pw.println("  public boolean set(int index," + fieldType + " value"+ ")");
     pw.println("  {");
     pw.println("    if(fieldSpecs[index].indexOf(\"final\") != -1)");
     pw.println("      return false;");

     pw.println("    switch (index)");
     pw.println("    {");
     for(int i = 0; i < numFields; i++)
     {
//       if(!isFinal[i]) {
         String fieldName = fieldNames[i];
         String valueType;
         pw.println("      case(" + i + "):");
         int indexOfValueType = fieldName.indexOf("Of") + 2;
         String valueTypeWithNumber = fieldName.substring(indexOfValueType);
         int lastIndexOfValueType = 0;
         for (int j=valueTypeWithNumber.length() -1; j>=0; j--)
         {
           if (Character.isDigit(valueTypeWithNumber.charAt(j)))
           {
             continue;
           }else {
            lastIndexOfValueType = j;
            break;
           }
         }
         valueType =  valueTypeWithNumber.substring(0, lastIndexOfValueType+1);
         pw.println("        " + fieldNames[i] + "= (" +valueType + " []) value ;");
         pw.println("         break;" );
//       }
     }
     pw.println("      default:");
     pw.println("        throw new IndexOutOfBoundsException();");
     pw.println("    }");
     pw.println("    return true;");
     pw.println("  }");
  }

  // generates Collection files for the different collectionTypes
  // also, updates the corresponding xml files
  // called by generate, after it is done dealing with the generic field types
  void generateCollections() throws Exception
  {
    final String [] embeddedElements = {"", "true", "false"};
    final String [] embeddedElementsForFieldSpec = {"", "embedded-element=true", "embedded-element=false"};
    for(int i=0; i < collectionTypes.length; i++)
    {
          // Map has a lot of combinations, generate it separately
      if(collectionTypes[i].indexOf("Map") >= 0 || collectionTypes[i].equals("Hashtable"))
      {
        generateMapCollection(collectionTypes[i]);
      }
      else // Array and the other collections
      {
        String classFile = collectionTypes[i] + "Collections";
        FileOutputStream fout = new FileOutputStream(classFile + ".java");
        PrintWriter pw = new PrintWriter(fout);
        FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n");
        PrintWriter xmlPw = new PrintWriter(xmlFout);
        FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a");
        PrintWriter xmlPw1 = new PrintWriter(xmlFout1);
        FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d");
        PrintWriter xmlPw2 = new PrintWriter(xmlFout2);

        startClass(pw, classFile);
        startXmlMetaData(xmlPw);
        startXmlMetaData(xmlPw1);
        startXmlMetaData(xmlPw2);

        startXmlClass(xmlPw,  classFile, 0);
        startXmlClass(xmlPw1, classFile, 1);
        startXmlClass(xmlPw2, classFile, 2);

        int fieldCounter=0;
        String fieldNames [] = new String [elementTypes.length * embeddedElements.length];
        for(int j=0; j < elementTypes.length; j++)
        {
            if( elementTypes[j].equals("Locale") && collectionTypes[i].equals("TreeSet") )
                continue;
          for(int k=0; k < embeddedElements.length; k++)
          {
            if(collectionTypes[i].equals("Array"))
            {
              if(!embeddedElements[k].equals(""))
              {
                fieldNames[fieldCounter] = collectionTypes[i] + "Of" + elementTypes[j] + fieldCounter;
//                pw.println("  public " + "Object [] "+ fieldNames[fieldCounter] +";");
                pw.println("  public " + elementTypes[j] +" [] " + fieldNames[fieldCounter] +";");
                printXmlArrayFieldWithEmbeddedElement(xmlPw,  fieldNames[fieldCounter], embeddedElements[k]);
                printXmlArrayFieldWithEmbeddedElement(xmlPw1, fieldNames[fieldCounter], embeddedElements[k]);
                printXmlArrayFieldWithEmbeddedElement(xmlPw2, fieldNames[fieldCounter], embeddedElements[k]);
                buildFieldSpecs(embeddedElementsForFieldSpec[k] + " " +
                                "public " + elementTypes[j] +" [] " + fieldNames[fieldCounter]); // add to the field specs array*/

                fieldCounter++;
              }
            }
            else // Collection
            {
              fieldNames[fieldCounter] = collectionTypes[i] + "Of" + elementTypes[j] + fieldCounter;
              pw.println("  public " + collectionTypes[i] +" "+ fieldNames[fieldCounter] +";");
              printXmlCollectionFieldWithEmbeddedElement(xmlPw, fieldNames[fieldCounter], elementsWithPackageInfo[j],
                                                         embeddedElements[k]);
              printXmlCollectionFieldWithEmbeddedElement(xmlPw1, fieldNames[fieldCounter], elementsWithPackageInfo[j],
                                                         embeddedElements[k]);
              printXmlCollectionFieldWithEmbeddedElement(xmlPw2, fieldNames[fieldCounter], elementsWithPackageInfo[j],
                                                         embeddedElements[k]);
              buildFieldSpecs(embeddedElementsForFieldSpec[k] + " " +
                              "public " + collectionTypes[i] +" "+ fieldNames[fieldCounter]); // add to the field specs array*/
              fieldCounter++;

            }
          }
        }
        writeFieldSpecs(pw);
        writeMethodGetLength(pw);
        writeMethodGet(pw, collectionTypes[i].equals("Array")? "Object [] " : collectionTypes[i], fieldNames, fieldCounter);
        if(collectionTypes[i].equals("Array"))
          writeMethodSetForArray(pw, "Object [] ", fieldNames, fieldCounter);
        else
         writeMethodSet(pw, collectionTypes[i], fieldNames, fieldCounter);

        endClass(pw);
        pw.close();
        fout.close();
        endXmlClass(xmlPw);
        endXmlClass(xmlPw1);
        endXmlClass(xmlPw2);
        endXmlMetaDeta(xmlPw);
        endXmlMetaDeta(xmlPw1);
        endXmlMetaDeta(xmlPw2);
        xmlPw.close();
        xmlFout.close();
        xmlPw1.close();
        xmlFout1.close();
        xmlPw2.close();
        xmlFout2.close();
      }
    }
  }

  private void generateMapCollection(String mapName) throws Exception
  {
    final String [] keyTypes1 = {"String"};
    final String [] valueTypes1 = {"Object", "SimpleClass", "SimpleInterface", "String",
                                "Date", "Locale", "BigDecimal", "BigInteger",
                                "Byte", "Double", "Float", "Integer", "Long",
                                "Short"};
    final String [] keyTypes2 = {"Object", "SimpleClass", "SimpleInterface", "String",
                                "Date", "BigDecimal", "BigInteger",
                                "Byte", "Double", "Float", "Integer", "Long",
                                "Short"};
    final String [] valueTypes2 = {"String"};

    final String [][] keyTypes = {keyTypes1, keyTypes2};
    final String [][] valueTypes = {valueTypes1, valueTypes2};

    String [] classNameArray =   {mapName + "StringKey" + "Collections",
                                  mapName + "StringValue" + "Collections"};

    for(int i=0; i < classNameArray.length; i++)
    {
      String classFile = classNameArray[i];
      FileOutputStream fout = new FileOutputStream(classFile + ".java");
      PrintWriter pw = new PrintWriter(fout);
      FileOutputStream xmlFout = new FileOutputStream(classFile + ".jdo.n");
      PrintWriter xmlPw = new PrintWriter(xmlFout);
      FileOutputStream xmlFout1 = new FileOutputStream(classFile + ".jdo.a");
      PrintWriter xmlPw1 = new PrintWriter(xmlFout1);
      FileOutputStream xmlFout2 = new FileOutputStream(classFile + ".jdo.d");
      PrintWriter xmlPw2 = new PrintWriter(xmlFout2);

      startClass(pw, classFile);
      startXmlMetaData(xmlPw);
      startXmlMetaData(xmlPw1);
      startXmlMetaData(xmlPw2);

      startXmlClass(xmlPw,  classFile, 0);
      startXmlClass(xmlPw1, classFile, 1);
      startXmlClass(xmlPw2, classFile, 2);

      fillMapCollection(keyTypes[i], valueTypes[i],mapName, pw, xmlPw, xmlPw1, xmlPw2);

      endClass(pw);
      pw.close();
      fout.close();
      endXmlClass(xmlPw);
      endXmlClass(xmlPw1);
      endXmlClass(xmlPw2);
      endXmlMetaDeta(xmlPw);
      endXmlMetaDeta(xmlPw1);
      endXmlMetaDeta(xmlPw2);
      xmlPw.close();
      xmlFout.close();
      xmlPw1.close();
      xmlFout1.close();
      xmlPw2.close();
      xmlFout2.close();
    }
  }

  private void fillMapCollection(String [] keyTypes, String [] valueTypes,
                                 String mapName, PrintWriter pw, PrintWriter xmlPw,
                                 PrintWriter xmlPw1, PrintWriter xmlPw2)
  {
    final String [] embeddedKeys = {"", "true", "false"};
    final String [] embeddedValues = embeddedKeys;
    final String [] embeddedKeyForFieldSpec = {"", "embedded-key=true", "embedded-key=false"};
    final String [] embeddedValueForFieldSpec = {"", "embedded-value=true", "embedded-value=false"};

    int fieldCounter=0;
    String fieldNames [] = new String [keyTypes.length * embeddedKeys.length
                                       * valueTypes.length * embeddedValues.length];
    for(int i = 0; i < keyTypes.length; i++)
    {
      for(int j = 0; j < embeddedKeys.length; j++)
      {
        for(int k = 0; k < valueTypes.length; k++)
        {
          for(int l = 0; l < embeddedValues.length; l++)
          {
            if( keyTypes[i].equals("") && embeddedKeys[j].equals("")
              && valueTypes[k].equals("") && embeddedValues[l].equals(""))
              continue;
            fieldNames[fieldCounter] = mapName+ "Of" + keyTypes[i] +"_"+valueTypes[k] + fieldCounter;
            pw.println("  public " + mapName +" " + fieldNames[fieldCounter] +";");
            printXmlMapField(xmlPw, fieldNames[fieldCounter], keyTypes[i], embeddedKeys[j],
                             valueTypes[k], embeddedValues[l]);
            printXmlMapField(xmlPw1, fieldNames[fieldCounter], keyTypes[i], embeddedKeys[j],
                             valueTypes[k], embeddedValues[l]);
            printXmlMapField(xmlPw2, fieldNames[fieldCounter], keyTypes[i], embeddedKeys[j],
                             valueTypes[k], embeddedValues[l]);
            buildFieldSpecs(embeddedKeyForFieldSpec[j] + " " +
                            embeddedValueForFieldSpec[l] + " " +
                            "public " + mapName +" "+ fieldNames[fieldCounter]); // add to the field specs array*/
            fieldCounter++;

           }
        }
      }
    }
    writeFieldSpecs(pw);
    writeMethodGetLength(pw);
    writeMethodGet(pw, mapName, fieldNames, fieldCounter);
    writeMethodSet(pw, mapName, fieldNames, fieldCounter);
  }

  public static void main(String[] args)
  {
    ClassGenerator classGenerator = new ClassGenerator();
    try
    {
        classGenerator.generate();
        classGenerator.generateCollections();
    }
    catch (Exception e)
    {
      System.out.println(e);
      e.printStackTrace();
    }
  }
}
