/* ===================================================================
    * 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.PrintWriter;
  import java.util.ArrayList;
  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.dbobj.RowSecuredDBObject;
  import com.jcorporate.expresso.core.security.SuperUser;
  import com.jcorporate.expresso.core.security.User;
  import com.jcorporate.expresso.services.dbobj.DBObjSecurity;
  import com.jcorporate.expresso.services.dbobj.RowGroupPerms;
  import com.jcorporate.expresso.services.dbobj.RowPermissions;
  import com.sri.emo.commandline.NodeTracker;
  import com.sri.emo.commandline.SqlRowGenerator;
  
  abstract public class AbstractExportSupport {
  
  	private final Logger log = Logger.getLogger(AbstractExportSupport.class);
  	
  	/***
  	 * The expected UID of the tester.
  	 */
  	protected static final int TESTER_UID = 4;
  	/***
  	 * Tracks the nodes.
  	 */
  	private final NodeTracker nodeTracker;
  	/***
  	 * Generates the insertion sql.
  	 */
  	private final SqlRowGenerator generator;
  
  	public AbstractExportSupport(final NodeTracker nodeTracker, final SqlRowGenerator generator) {
  		super();
  		this.nodeTracker = nodeTracker;
          this.generator = generator;		
  	}
  
  	/***
  	 * Exports a dbobject.  This function checks to see if a particular dbobject has been already
  	 * export before performing the export.
  	 *
  	 * @param writer   the output stream to write the SQL insert to.
  	 * @param dbobject the dbobject we're exporting.
  	 * @return number of INSERT statements written; 0 if the object has already been visited.
  	 * @throws DBException
  	 */
  	protected int writeDBObject(final PrintWriter writer, final DBObject dbobject) throws DBException {
  		if (dbobject == null) {
  			return 0;
  		}
  		
  	    List sqlStatements = getSQL(dbobject);
  	    writeSql(writer, sqlStatements);
  	    return sqlStatements.size();
  	}
  	
  	
  	/***
  	 * Writes a list of sql statements to the printwriter.
  	 * @param writer the printwriter to append the data to.
  	 * @param listOfSql list of strings.
  	 * @throws DBException if the data is not appropriately a sql string.
  	 */
  	protected void writeSql(final PrintWriter writer, final List listOfSql) throws DBException {
  	    for (Iterator iterator = listOfSql.iterator(); iterator.hasNext();) {
  	        Object obj = iterator.next();
  	
  	        if (!(obj instanceof String)) {
  	            String s = obj.toString();
  	            log.warn("Not a string: " + obj.getClass().getName() + " has toString: " + s);
  	            if (!s.startsWith("INSERT")) {
  	                throw new DBException("Cannot use object returned by getSQL for "
  	                		+"SQL insert; see previous error lines");
  	            }
  	        }
  	
  	        writer.println(obj.toString());
  	    }
  		
  	}
  	
  	/***
  	 * Writes a list of dbobjects to the output stream.
 	 * @param writer
 	 * @param severalDBObjects
 	 * @return
 	 * @throws DBException
 	 */
 	protected int writeDBObject(final PrintWriter writer, final List severalDBObjects) throws DBException {
 		int recordCount = 0;
 		
 		for (Iterator i = severalDBObjects.iterator(); i.hasNext();) {
 			DBObject eachObject = (DBObject)i.next();
 			recordCount += writeDBObject(writer,eachObject);
 		}
 		
 		return recordCount;
 	}
 	
 
 	protected List exportSecuredDBobjectEntries(final DBObject targetObject) throws DBException {
 		List result = new ArrayList();
 	
 		//Grab all security entries for the object.
 		DBObjSecurity dbobjSecurity = new DBObjSecurity(SuperUser.INSTANCE);
 		dbobjSecurity.set(DBObjSecurity.DBOBJECT_NAME, targetObject.getClass().getName());
 		List allSecurityEntries = dbobjSecurity.searchAndRetrieveList(DBObjSecurity.GROUP_NAME);
 		
 		//Grab all groups for tester.
 		User tester = User.getUserFromId(TESTER_UID);
 		List groups = tester.getGroupsList();
 		
 		//For each security entry that contains a group in groups.
 		//add security entiry to result.
 		for (Iterator i = groups.iterator(); i.hasNext();) {
 			String groupName = (String) i.next();
 			result.addAll(getEntriesForUserGroupName(groupName, allSecurityEntries));
 		}
 		
 		return result;
 	}
 
 	private List getEntriesForUserGroupName(final String groupName, final List allEntries) throws DBException {
 		List result = new ArrayList();
 		for (Iterator i = allEntries.iterator(); i.hasNext();) {
 			DBObjSecurity eachEntry = (DBObjSecurity)i.next();
 			
 			if (groupName.equals(eachEntry.getField(DBObjSecurity.GROUP_NAME))) {
 	    		if (nodeTracker.isObjectVisited(eachEntry)) {
 	    			continue;
 	    		}
 				nodeTracker.markObjectAsVisited(eachEntry);
 				result.add(generator.generateInsert(eachEntry));    
 			}
 	
 		}    	
 		return result;    	
 	}
 
 	/***
 	 * Creates default Row security  for each row secured object being export.
 	 *
 	 * @param object
 	 * @return the number of rows added to the export table.
 	 * @throws DBException
 	 */
 	protected List exportSecurityEntries(final RowSecuredDBObject object) throws DBException {
 	
 	    List list = new ArrayList();
 	    // save a copy of row permissions with ownder changed to ID 4.
 	    RowPermissions rowPermissions = object.getPermissions();
 	    rowPermissions.owner(AbstractExportSupport.TESTER_UID);
 	    if (log.isDebugEnabled()) {
 	    	log.debug("Generating row permission sql " + rowPermissions.getKey());
 	    }
 	
 	    list.addAll(getSQL(rowPermissions));
 	
 	    // iterate through groups
 	    List grps = object.getGroups();
 	    for (Iterator iterator = grps.iterator(); iterator.hasNext();) {
 	        RowGroupPerms grpperms = (RowGroupPerms) iterator.next();
 	
 	        // NB: all groups are already exported
 	        if (log.isDebugEnabled()) {
 	          log.debug("Exporting row group perms " + grpperms.getKey());
 	        }
 	        list.addAll(getSQL(grpperms));
 	    }
 	
 	    return list;
 	}
 
     /***
      * generate list of INSERT statements for given object (and any security objects
      * associated with the target object), IFF that object hasn't already been visited.
      *
      * @return list of strings: all the SQL insert statements for the given object
      */
     public List getSQL(DBObject dbobject) throws DBException {
         List list = new ArrayList();
         if (nodeTracker.isObjectVisited(dbobject)) {
             if (log.isInfoEnabled()) {
                 log.info("Skipping sql generation for object " + dbobject.toString() + " with key "
                         + dbobject.getKey() + " it already appears to have been exported");
             }
         } else {
 
             nodeTracker.markObjectAsVisited(dbobject);
 
             String toSave = generator.generateInsert(dbobject);
 
             if (log.isDebugEnabled()) {
                 log.debug("Created sql insert statement: \t " + toSave);
             }
 
             list.add(toSave);
 
             if (dbobject instanceof RowSecuredDBObject) {
                 if (log.isDebugEnabled()) {
                     log.debug("Exporting row security entries for dbobject." + dbobject);
                 }
 
                 list.addAll(exportSecurityEntries((RowSecuredDBObject) dbobject));
             }
 
             list.addAll(exportSecuredDBobjectEntries(dbobject));
         }
         return list;
     }
 
     /***
      * Retrieve the SQL generator.
      * @return generator or null
      */
 	protected SqlRowGenerator getGenerator() {
 		return generator;
 	}
 
 	/***
 	 * Retrieve the node tracker.
 	 * @return tracker or null
 	 */
 	protected NodeTracker getNodeTracker() {
 		return nodeTracker;
 	}
 
 
 }