/* ===================================================================
    * Copyright 2002-06 SRI International.
    * Released under the MOZILLA PUBLIC LICENSE Version 1.1
    * which can be obtained at http://www.mozilla.org/MPL/MPL-1.1.html
    * This software 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.sri.emo.commandline.defaults;
  
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.log4j.Logger;
  
  import com.jcorporate.expresso.core.db.DBException;
  import com.jcorporate.expresso.core.dbobj.DBObject;
  import com.jcorporate.expresso.core.security.User;
  import com.jcorporate.expresso.core.security.UserInfo;
  import com.jcorporate.expresso.services.dbobj.DefaultUserInfo;
  import com.jcorporate.expresso.services.dbobj.GroupMembers;
  import com.jcorporate.expresso.services.dbobj.Setup;
  import com.jcorporate.expresso.services.dbobj.UserGroup;
  import com.sri.emo.commandline.NodeTracker;
  import com.sri.emo.commandline.SqlRowGenerator;
  import com.sri.emo.commandline.TreeExporter;
  import com.sri.emo.dbobj.Node;
  import com.sri.emo.dbobj.selectiontree.TreeSelectionFactory;
  
  /***
   * @author Michael Rimov
   */
  public class DefaultTreeExporter extends AbstractNodeExportSupport implements TreeExporter {
  
      /***
       * Log4j logger.
       */
      public final Logger log = Logger.getLogger(TreeExporter.class);
  
  
      public DefaultTreeExporter(final NodeTracker nodeTracker, final SqlRowGenerator generator) {
          super(nodeTracker, generator);
      }
  
  
      public int exportNodeTree(final PrintWriter writer, final Node baseNode) throws DBException, IOException {
          int totalCount = 0;
  
          totalCount += exportAllUserGroups(writer);
          totalCount += exportAllSetupValues(writer);
  
          //Grabbed from TagSelectionFactory.
          HashMap map = new HashMap();
          baseNode.setAttribute(Node.INDENT, new Integer(1));
          TreeSelectionFactory.getNodesInStronglyRelatedTreeRecursive(baseNode, map);
          if (log.isDebugEnabled()) {
              log.debug("Found a total of " + map.size()
                      + " nodes to export for tree with base node " + baseNode.getNodeId());
          }
  
          for (Iterator i = map.values().iterator(); i.hasNext();) {
              Node oneNode = (Node) i.next();
              totalCount += exportNode(writer, oneNode);
          }
  
          return totalCount;
      }
  
      private int exportAllSetupValues(PrintWriter writer) throws DBException {
          int result = 0;
          Setup setup = new Setup();
          List list = setup.searchAndRetrieveList();
          for (Iterator iterator = list.iterator(); iterator.hasNext();) {
              Setup aSetup = (Setup) iterator.next();
  
              // skip some
              if ( "MAILFrom".equals(aSetup.getField(Setup.SETUP_CODE))
                      || "HTTPServ".equals(aSetup.getField(Setup.SETUP_CODE))
                      || "BugsEmail".equals(aSetup.getField(Setup.SETUP_CODE))
                      || "AdminEmail".equals(aSetup.getField(Setup.SETUP_CODE))
                      || "EmailValidateURL".equals(aSetup.getField(Setup.SETUP_CODE))) {
                  continue;
              }
              result += writeDBObject(writer, aSetup);
          }
  
          return result;
      }
  
      /***
       * @param writer
       * @return
       * @throws DBException
       */
     private int exportAllUserGroups(final PrintWriter writer) throws DBException {
         int result = 0;
 
         UserGroup grp = new UserGroup();
         List list = grp.searchAndRetrieveList();
         for (Iterator iterator = list.iterator(); iterator.hasNext();) {
             UserGroup group = (UserGroup) iterator.next();
             result += writeDBObject(writer, group);
 
             // make sure our user is member of all groups EXCEPT unknown,
             if (!UserGroup.NOT_REG_USERS_GROUP.equals(group.getGroupName())
                     && !UserGroup.UNKNOWN_USERS_GROUP.equals(group.getGroupName())) {
                 GroupMembers member = new GroupMembers();
                 member.setGroupName(group.getGroupName());
                 member.setUID(TESTER_UID);
                 result += writeDBObject(writer, member);
             }
         }
 
         // also export the test user
         User user = new User();
         UserInfo testerInfo = user.getUserInfo();
         testerInfo.setUid(TESTER_UID);
         testerInfo.setLoginName("tester");
         testerInfo.setEmail("testerForEmo@codeguild.com");
         testerInfo.setAccountStatus("A");
         testerInfo.setPassword("tester");
         testerInfo.setEmailValCode((String) null);
         testerInfo.setUserName("tester");
         testerInfo.setRegComplete(true);
         testerInfo.setRegistrationDomain("default");
 
         DBObject info = (DBObject) testerInfo;
         Date now = new Date();
         info.setField(DefaultUserInfo.CREATED_DATE, now);
         info.setField(DefaultUserInfo.UPDATED_DATE, now);
 
         result += writeDBObject(writer, info);
 
         // add a read-only user
         testerInfo.setUid(TESTER_UID + 1);
         testerInfo.setLoginName("reader");
         testerInfo.setUserName("reader");
         testerInfo.setEmail("readerPadiExport@codeguild.com");
         testerInfo.setAccountStatus("A");
         testerInfo.setPassword("reader");
 
         result += writeDBObject(writer, info);
 
         // make member of readers group
         GroupMembers member = new GroupMembers();
         member.setGroupName("padi_read"); // read group constant is in PADI-specific classes; use literal to prevent dependency
         member.setUID(TESTER_UID + 1);
 
         result += writeDBObject(writer, member);
 
         return result;
     }
 
     /***
      * Exports a node and all of its related attributes, security settings, and relations.
      *
      * @param writer
      * @param node
      * @return
      * @throws DBException
      * @throws IOException
      */
     public int exportNode(final PrintWriter writer, final Node node) throws DBException, IOException {
 
         int totalCount = 0;
 
         //Export the node type.
         totalCount += exportNodeType(writer, node.getNodeType());
 
         //Export the node
         totalCount += writeDBObject(writer, node);
 
         if (totalCount == 0) {
             if (log.isDebugEnabled()) {
                 log.debug("Found out that node " + node.getNodeId() + " already exists.  Skipping");
             }
             //if we haven't written anything by now, it means
             //we've visited this node.  Don't try anything else.
             return totalCount;
         }
 
 //        if (log.isDebugEnabled()) {
 //            log.debug("Exporting node " + node.getNodeId());
 //        }
 
         //Export all node attributes.
         totalCount += exportAttributes(writer, node);
 
         //Export relations.
         totalCount += exportRelations(writer, node);
 
         totalCount += exportNodeTags(writer, node);
 
         return totalCount;
     }
 
 
 
 }