/*
    * UML2MMBase module.
    *
    * The contents of this file are subject to the Mozilla Public License
    * Version 1.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.mozilla.org/MPL/
    *
    * Software distributed under the License is distributed on an "AS IS"
   * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
   * License for the specific language governing rights and limitations
   * under the License.
   */
  
  package com.finalist.mmbase.modules;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.util.*;
  import java.net.URL;
  import org.andromda.core.mdr.MDRepositoryFacade;
  import com.finalist.mmbase.uml.MMBasePackageHelper;
  
  /***
   * The MMBasePackage handler is used in the postprocessing part of UML2MMBase.
   * It will check which UMLPackages in the model haven been marked with the MMBasePackage stereotype.
   * For these packages the package name will be used to do some package specific post processing.
   *
   * @author Rudie Ekkelenkamp
   * @version $Revision: 1.5 $, $Date: 2005/07/12 10:31:59 $
   */
  public class MMBasePackageHandler {
  
      private static Properties properties;
      /*
        Static code to load property file
      */
      static {
  
         try {
            properties = new Properties();
            File file = new File("conf" + File.separator + "/uml2mmbase-package-generator.properties");
            System.out.println("Trying to read file: " + file.getAbsolutePath());
            properties.load(new FileInputStream(file));
            System.out.println("The uml2mmbase-package-generator.properties was read.");
         }
         catch (Exception e) {
            System.out.println("Error while reading : /conf/uml2mmbase-package-generator.properties");
            e.printStackTrace();
         }
      }
  
  
     /***
      * Creates a new package handler.
      */
     private MMBasePackageHandler() {
     }
  
  
     /***
      * This method will be called from the ant task after all code generation has been done.
      *
      * @param args the commandline arguments;
      *               The first argument should be the name of the model. For example: model.xmi
      *               The second argument should be the generated dir where all code generation has been done.
      *                       For example: generated
      *               The third argument should be the mmbaseVersion number. For example: 1.8
      *
      * @throws Exception an exception.
      */
     public static void main(String[] args) throws Exception {
        if (args.length != 3) {
           System.out.println("Three parameters expected for the MMbase Package Handler!");
           return;
        }
  
        String modelName = args[0];
        String generatedDir = args[1];
        String mmbaseVersion = args[2];
        MMBasePackageHelper mmbasePackageHelper = null;
        MDRepositoryFacade mdr = new MDRepositoryFacade();
  
        String [] modules = {"modules","profiles"};
        loadModel(mdr, modelName, modules);
        mmbasePackageHelper = new MMBasePackageHelper(mdr.getModel());
     
        Collection mmbasePackages = mmbasePackageHelper.getMMBasePackages();
         for (Iterator iterator = mmbasePackages.iterator(); iterator.hasNext();) {
             String packageName =  (String) iterator.next();
  
             // Set the configuration with the passed arguments.
             MMBasePackageConfiguration config = new MMBasePackageConfiguration();
             config.setGeneratedDir(generatedDir);
             config.setMmbaseVersion(mmbaseVersion);
             config.setModelName(modelName);
             config.setPackageName(packageName);
  
             // Not check if a mapping to a java class was speficied for this package.
            String className = null;
            if (properties != null) {
              className = (String) properties.getProperty(packageName);
            }
            if (className == null) {
                // If no mapping was specified, we use the default generator.
                className = MMBasePackageGenerator.DEFAULT_MMBASE_PACKAGE_GENERATOR;
            }
            try {
                // Now use the classloader to get the implementation for this package.
                MMBasePackageGenerator generator = (MMBasePackageGenerator) Class.forName(className).newInstance();
                 // Now do the actual generation: init, process, destroy.
                generator.init(config);
                generator.process(config);
                generator.destroy(config);
            } catch (ClassNotFoundException e) {
                System.out.println("Couldn't find the custom classname " + className + " for package: " + packageName);
                System.out.println("Skipping the MMBasePackage generation for this package.");
            }
        }
       closeModel(mdr);
    }
 
     /***
      *
      * Load the model into the MDR.
      * @param modelName The reference to the model on which the tests will be applied.
      */
     private static void loadModel(MDRepositoryFacade mdr, String modelName, String[] modules) {
        System.out.println("Reading a new XMI file: " + modelName + ".");
        mdr.open();
 
        try {
           // Read the model file.
           URL xmiURL = (new File(modelName)).toURL();
           mdr.readModel(xmiURL, modules);
        }
        catch (Exception e) {
           e.printStackTrace();
        }
     }
 
     /***
      * Close the MDR.
      * @param mdr Meta Data Repository
      */
     private static void closeModel(MDRepositoryFacade mdr) {
        System.out.println("Closing de MDR.");
        try {
        if (mdr != null) {
            mdr.close();
        }
        }
        catch (Exception e) {
           e.printStackTrace();
        }
     }
 }