//  Copyright (c) 2010 dark-matter-data committers

//  ---------------------------------------------------------------------------

//  This program 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 3 of the License, or (at your

//  option) any later version.

//  This program 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 program; if not, see <http://www.gnu.org/licenses/lgpl.html>.

//  ---------------------------------------------------------------------------

* The MetaGenerator class is used to bootstrap the entire Dark Matter Objects

* mechanism by generating the initial schema definition mechanism classes from

* a standard Data Model Schema (DMS) description.

*/

  // Offset to the source directory for the meta generator

  private final static String METADIR = "/src/org/dmd/dms/meta";

  // Offset to the source directory for the meta generator

  // private final static String GENDIR = "/src/org/dmd/dms/generated";

  // Offset to the source directory for dark matter wrappers

  private final static String DMWDIR = "/src/org/dmd/dms/generated/dmw";

  // Offset to the source directory for dark matter wrappers

  private final static String ENUMDIR = "/src/org/dmd/dms/generated/enums";

  // Offset to the Dark Matter Object generation directory

  private final static String DMODIR = "/src/org/dmd/dms/generated/dmo";

  // Offset to the generated types

  private final static String TYPEDIR = "/src/org/dmd/dms/generated/types";

  // Offset to the rule generation directory

  private final static String RULESDIR = "/src/org/dmd/dms/generated/rulesdmo";

  // Offset to the gdo source directory

  private final static String DMSDIR = "/src/org/dmd/dms";

  private final static int META_BASE_ID = 0;

  private final static int META_ID_RANGE = 200;

  private StringBuffer LGPL;

  // All definitions of the metaschema

  TreeMap<String, DmcUncheckedObject> allDefs;

  // Type definitions

  TreeMap<String, DmcUncheckedObject> typeDefs;

  // Enumeration definitions

  TreeMap<String, DmcUncheckedObject> enumDefs;

  // Attribute definitions

  TreeMap<String, DmcUncheckedObject> attributeDefs;

  // Class definitions

  TreeMap<String, DmcUncheckedObject> classDefs;

  // Complex type definitions

  TreeMap<String, DmcUncheckedObject> complexTypeDefs;

  // Attribute Validator Definitions

  TreeMap<String, DmcUncheckedObject> avDefs;

  // Object Validator Definitions

  TreeMap<String, DmcUncheckedObject> ovDefs;

  // Rule definitions

  TreeMap<String, DmcUncheckedObject> ruleDefs;

  // Rule category definitions

  TreeMap<String, DmcUncheckedObject> ruleCategoryDefs;

  // Rule instances

  ArrayList<DmcUncheckedObject> ruleInstances;

  // Some of the definitions have to be defined in a particular order, so

  // we maintain the order in which they appear in the Dmd file.

  ArrayList<String> origOrderClasses;

  ArrayList<String> origOrderAttrs;

  ArrayList<String> origOrderTypes;

  ArrayList<String> origOrderEnums;

  ArrayList<String> origOrderComplexTypes;

  ArrayList<String> origOrderAVDs;

  ArrayList<String> origOrderOVDs;

  ArrayList<String> origOrderRules;

  ArrayList<String> origOrderCategories;

  // Handle to the source directory name

  String sourceDir;

  DmcUncheckedOIFParser parser;

  public MetaGenerator() {

    allDefs = new TreeMap<String, DmcUncheckedObject>();

    typeDefs = new TreeMap<String, DmcUncheckedObject>();

    enumDefs = new TreeMap<String, DmcUncheckedObject>();

    attributeDefs = new TreeMap<String, DmcUncheckedObject>();

    classDefs = new TreeMap<String, DmcUncheckedObject>();

    complexTypeDefs = new TreeMap<String, DmcUncheckedObject>();

    avDefs = new TreeMap<String, DmcUncheckedObject>();

    ovDefs = new TreeMap<String, DmcUncheckedObject>();

    ruleDefs = new TreeMap<String, DmcUncheckedObject>();

    ruleCategoryDefs = new TreeMap<String, DmcUncheckedObject>();

    ruleInstances = new ArrayList<DmcUncheckedObject>();

    origOrderClasses = new ArrayList<String>();

    origOrderAttrs = new ArrayList<String>();

    origOrderTypes = new ArrayList<String>();

    origOrderEnums = new ArrayList<String>();

    origOrderComplexTypes = new ArrayList<String>();

    origOrderAVDs = new ArrayList<String>();

    origOrderOVDs = new ArrayList<String>();

    origOrderRules = new ArrayList<String>();

    origOrderCategories = new ArrayList<String>();

    parser = new DmcUncheckedOIFParser(this);

    parser.addPreserveNewlinesAttribute("description");

  }

  public void run(String[] args) throws DmcValueException, DmcRuleExceptionSet {

    try {

      FileUpdateManager.instance().generationStarting();

      FileUpdateManager.instance().reportProgress(System.out);

      FileUpdateManager.instance().reportErrors(System.err);

      FileUpdateManager.instance().deleteFiles(false);

      File curr = new File(".");

      sourceDir = curr.getCanonicalPath() + METADIR;

      // Read the license header

      LGPL = new StringBuffer();

      LineNumberReader in = new LineNumberReader(new FileReader(sourceDir

          + "/LGPL.txt"));

      String str;

      while ((str = in.readLine()) != null) {

        LGPL.append(str + "\n");

      }

      parser.parseFile(sourceDir + "/metaSchema.dms");

      createInternalTypesForComplexTypes();

      dumpTypeIterables(curr.getCanonicalPath() + DMWDIR);

      createInternalReferenceTypes();

      dumpDerivedTypes(curr.getCanonicalPath() + TYPEDIR);

      Iterator<DmcUncheckedObject> enums = enumDefs.values().iterator();

      while (enums.hasNext()) {

        dumpEnumClass(curr.getCanonicalPath() + ENUMDIR, enums.next());

      }

      dumpDmcTypes(curr.getCanonicalPath() + TYPEDIR);

      dumpComplexTypes(curr.getCanonicalPath() + TYPEDIR);

      dumpDMOClasses(curr.getCanonicalPath() + DMODIR);

      // DmoAttributeSchemaFormatter asf = new

      // DmoAttributeSchemaFormatter(System.out);

      // asf.dumpSchema("meta", "org.dmd.dms", attributeDefs, typeDefs,

      // curr.getCanonicalPath() + DMODIR);

      DmoCompactSchemaFormatter csf = new DmoCompactSchemaFormatter(

          System.out);

      csf.dumpSchema("meta", "org.dmd.dms", classDefs, attributeDefs,

          typeDefs, ruleInstances, curr.getCanonicalPath() + DMODIR,

          META_BASE_ID, META_ID_RANGE);

      // DmoValidatorCollectionFormatter vcf = new

      // DmoValidatorCollectionFormatter(System.out);

      // vcf.dumpSchema("meta", "org.dmd.dms", avDefs, ovDefs,

      // curr.getCanonicalPath() + DMODIR);

      RuleFormatter rf = new RuleFormatter(System.out);

      rf.dumpRuleCategoryInterfaces("meta", "org.dmd.dms", ruleCategoryDefs, curr.getCanonicalPath() + RULESDIR);

      dumpDMWClasses(curr.getCanonicalPath() + DMWDIR);

      dumpMetaSchemaNew(curr.getCanonicalPath() + DMSDIR);

      FileUpdateManager.instance().generationComplete();

    } catch (IOException e) {

      System.err.println(e);

    } catch (ResultException ex) {

      System.err.println(ex);

    }

  }

 

  ///////////////////////////////////////////////////////////////////////////

 

  void dumpMetaSchemaNew(String od) throws IOException, ResultException {

    BufferedWriter out = null;

    ImportManager    imports = new ImportManager();

   

    imports.addImport("org.dmd.dmc.DmcValueException", "To handle potential value exceptions.");

    imports.addImport("org.dmd.dms.generated.dmo.*", "Access to meta schema DMOs");

    // out = new BufferedWriter(new FileWriter(od + "/MetaSchemaAG.java"));

    out = FileUpdateManager.instance().getWriter(od, "MetaSchemaAG.java");

//    // problems

//    // when loading the meta schema

//    for (DmcUncheckedObject type : typeDefs.values()) {

//      type.rem("nameAttributeDef");

//      type.rem("filterAttributeDef");

//    }

    out.write(LGPL.toString());

    out.write("package org.dmd.dms;\n\n");

    out.write(imports.getFormattedImports() + "\n\n");

   

    out.write("/**\n");

    out.write("  * This class creates the basic definitions that allow for the definition of schemas.\n");

    out.write("  * Generated from: " + DebugInfo.getWhereWeAreNow() + "\n");

    out.write("  */\n");

    out.write("abstract public class MetaSchemaAG extends SchemaDefinition {\n");

    dumpStaticDefinitions(out);

   

    out.write("    public MetaSchemaAG() throws DmcValueException {\n\n");

    out.write("        super(\"meta\");\n\n");

   

    out.write("        // We only ever want to initialize the schema once, so check\n");

    out.write("        // to see if we've initialized the first class definition\n");

    out.write("        if (_metaSchema == null){\n");

    out.write("            _metaSchema = this;\n");

    out.write("            staticRefName = new String(\"MetaSchema._\");\n\n");

    out.write("            this.setDescription(\"The meta schema defines the elements used to define schemas.\");\n");

    // Set the prefix for the generated output directory and the generated

    // package prefixes

    out.write("            this.setSchemaPackage(\"org.dmd.dms\");\n");

    out.write("            this.setDmwPackage(\"org.dmd.dms\");\n");

    out.write("            this.setSchemaBaseID(" + META_BASE_ID + ");\n");

    out.write("            this.setSchemaIDRange(" + META_ID_RANGE + ");\n");

   

    out.write("            initClasses();\n");

    out.write("            initAttributes();\n");

    out.write("            initTypes();\n");

    out.write("            initEnums();\n");

    out.write("            initRuleCategories();\n");

    out.write("            initComplexTypes();\n");

   

    out.write("        }\n");

   

    out.write("    }\n");

   

    dumpInitClasses(out);

    dumpInitAttributes(out);

    dumpInitTypes(out);

    dumpInitEnums(out);

    dumpInitRuleCategories(out);

    dumpInitComplexTypes(out);

   

    out.write("}\n");

   

    out.close();

  }

 

  /**

   * This dumps the static definition of the various definitions.

   * @param out

   * @throws IOException 

   */

  void dumpStaticDefinitions(BufferedWriter out) throws IOException {

    out.write("    public static SchemaDefinition    _metaSchema;\n\n");

    out.write("    // Generated from: " + DebugInfo.getWhereWeAreNow()

        + "\n");

    for (int i = 0; i < origOrderClasses.size(); i++) {

      out.write("    public static ClassDefinition     _" + origOrderClasses.get(i) + ";\n");

    }

    out.write("\n");

    out.write("    // Generated from: " + DebugInfo.getWhereWeAreNow()

        + "\n");

    for (int i = 0; i < origOrderEnums.size(); i++)

      out.write("    public static EnumDefinition      _" + origOrderEnums.get(i) + ";\n");

    out.write("\n");

    out.write("    // Generated from: " + DebugInfo.getWhereWeAreNow()

        + "\n");