package com.randomnoun.common.spring;
   
   /* (c) 2013 randomnoun. All Rights Reserved. This work is licensed under a
    * BSD Simplified License. (http://www.randomnoun.com/bsd-simplified.html)
    */
   
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.util.*;
  
  import org.springframework.dao.DataAccessException;
  import org.springframework.jdbc.core.*;
  import org.apache.log4j.Logger;
  
  import com.randomnoun.common.Struct;
  
  /** A bit like a StructuredListResultSetExtractor, but executes a callback on each object, rather than returning List of them.
   *
   * @see StructuredListResultSetExtractor
   *
   * 
   * @author knoxg
   */
  public class StructuredMapCallbackHandlerResultSetExtractor 
      implements ResultSetExtractor<Object> {
      
      
      
      /** Logger instance for this class */
      private static Logger logger = Logger.getLogger(StructuredMapCallbackHandlerResultSetExtractor.class);  
      
      /** Contains mappings from source column names to (structured) target column names */
      Map<String, String> columnMapping;
  
      /** List to save results in */
      private final List<Map<String, Object>> results;
      private List<String> levels;
  
      /** Row mapper */
      private final RowMapper<Map<String, Object>> rowMapper;
      private Map<String, Object> lastResultRow = null;
      
      private StructuredMapCallbackHandler smch;
  
      public static interface StructuredMapCallbackHandler {
      	public void processMap(Map<String, Object> row);
      }
      
      /** The counter used to count rows */
      private int rowNum = 0;
  
      /**
       * Create a new RowMapperResultReader.
       * 
       * @param jt jdbcTemplate for some reason
       */
      public StructuredMapCallbackHandlerResultSetExtractor(JdbcTemplate jt, String mappings, StructuredMapCallbackHandler smch) {
          this(new ColumnMapRowMapper(), mappings, smch);
      }
      
  
      /**
       * Create a new RowMapperResultReader.
       * 
       * @param rowMapper the RowMapper which creates an object for each row
       */
      private StructuredMapCallbackHandlerResultSetExtractor(RowMapper<Map<String, Object>> rowMapper, String mappings, StructuredMapCallbackHandler smch) {
          this.smch = smch;
          if (mappings == null) { throw new NullPointerException("mappings cannot be null"); }
  
          // Use the more efficient collection if we know how many rows to expect:
          // ArrayList in case of a known row count, LinkedList if unknown
          this.results = new ArrayList<Map<String, Object>>();
          this.rowMapper = rowMapper;
          this.columnMapping = new HashMap<String, String>();
          this.levels = new ArrayList<String>(3); // we're not going to go higher than this too often
  
          StringTokenizer st = new StringTokenizer(mappings, ",");
          StringTokenizer st2;
          StringTokenizer st3;
          String column = null;
          String columnTarget = null;
          String token;
          String mapping;
  
          while (st.hasMoreTokens()) {
              mapping = st.nextToken().trim();
  
              if (mapping.indexOf(' ') == -1) {
                  column = mapping;
                  columnTarget = mapping;
              } else {
                  // parse state (note that this uses a StringTokenizer, 
                  // rather than a character-based parser)
                  // 
                  // 0 = start of parse
                  // 1 = consumed column name
                  // 2 = consumed 'as'
                  // 3 = consumed mapping
                 int state = 0; // 0=initial, 1=got column name, 2=got 'as', 3=got mapping
                 st2 = new StringTokenizer(mapping, " ");
                 while (st2.hasMoreTokens()) {
                     token = st2.nextToken().trim();
                     if (token.equals("")) { continue; }
 
                     if (state == 0) {
                         column = token;
                         state = 1;
                     } else if (state == 1) {
                         if (!token.equalsIgnoreCase("as")) {
                             throw new IllegalArgumentException("Invalid mapping '" + mapping + "'; expected AS");
                         }
                         state = 2;
                     } else if (state == 2) {
                         columnTarget = token;
                         state = 3;
                     } else if (state == 3) {
                         throw new IllegalArgumentException("Invalid mapping '" + mapping + "'; too many tokens");
                     }
                 }
             }
 
             // check target for levels
             int levelIdx = 0;
             st3 = new StringTokenizer(columnTarget, ".");
             if (st3.hasMoreTokens()) {
                 String level = st3.nextToken();
 
                 while (st3.hasMoreTokens()) {
                     if (levelIdx < levels.size()) {
                         if (!levels.get(levelIdx).equals(level)) {
                             throw new IllegalArgumentException("Multiple lists in mapping at level " + levelIdx + ": '" + levels.get(levelIdx) + "' and '" + level + "'");
                         }
                     } else {
                         levels.add(level);
                         // System.out.println("Levels now: " + levels);
                     }
                     level = st3.nextToken();
                     levelIdx++;
                 }
             }
             columnMapping.put(column.toUpperCase(), columnTarget);
         }
     }
 
 	/** Required to support ResultSetExtractor interface
 	 * 
 	 * @param rs resultSet to process
 	 * 
 	 * @return null
 	 */
     public Object extractData(ResultSet rs) throws SQLException, DataAccessException 
 	{
 		while (rs.next()) {
 			processRow(rs);
 		}
 		if (results.size()>0) { smch.processMap(results.get(0)); }
 		return null;
 	}
     
     
     /** Used by the ResultReader interface to return the results read by this class
      * 
      * @see org.springframework.jdbc.core.ResultReader#getResults()
      *
     public List getResults() {
     	return null;
     }
     */
 
     /**
      * Used by the ResultReader interface to process a single row from the database.
      * 
      * <p>The row is read and matched against the 'levels' specified in the 
      * object constructor. As values change, tree branches are created in the returned
      * structured List. 
      * 
      * @see org.springframework.jdbc.core.RowCallbackHandler#processRow(java.sql.ResultSet)
      */
     @SuppressWarnings("unchecked")
 	public void processRow(ResultSet rs)
         throws SQLException {
         Map<String, Object> row = (Map<String, Object>) rowMapper.mapRow(rs, this.rowNum++); // ClobRowMapper always returns a Map.
 		// System.out.println("Processing row " + Struct.structuredMapToString("row", row));
         // logger.debug("row is " + Struct.structuredMapToJson(row));
         
         int createLevel = 0;
         List<Map<String, Object>> createList = results;
         Map<String, Object> createRow = new HashMap<String, Object>();
         String createPrefix = "";
 
         // determine highest level that we can create at
         if (lastResultRow != null) {
             // System.out.println("lastResultRow processing");
             createLevel = levels.size() + 1;
 
             // find lowest level that has a different value
             for (Iterator<Map.Entry<String, String>> i = columnMapping.entrySet().iterator(); i.hasNext();) {
                 Map.Entry<String, String> entry = (Map.Entry<String, String>) i.next();
                 String column = (String) entry.getKey();
                 String columnTarget = (String) entry.getValue();
 
                 List<Map<String,Object>> containerList = results; // maybe
                 Map<String, Object> containerMap = lastResultRow;
 
                 String component;
                 int pos = columnTarget.indexOf('.');
                 int level = 0;
 
                 while (pos != -1) {
                     component = columnTarget.substring(0, pos);
                     columnTarget = columnTarget.substring(pos + 1);
 
                     if (!containerMap.containsKey(component)) {
                         throw new IllegalStateException("Missing field '" + component + "' in " + Struct.structuredMapToString("containerMap", containerMap) + "; last result row is " + Struct.structuredMapToString("lastResultRow", lastResultRow));
                     }
 
                     if (component.equals(levels.get(level))) {
                         level++;
                         containerList = (List<Map<String,Object>>) containerMap.get(component);
                         containerMap = (Map<String, Object>) containerList.get(containerList.size() - 1);
                         if (containerMap==null) {
                         	logger.error("null containerMap");
                         }
                     } else {
                         containerMap = (Map<String, Object>) containerMap.get(component);
                         if (containerMap==null) {
                         	logger.error("null containerMap");
                         }
 
                     }
 
                     pos = columnTarget.indexOf('.');
                 }
 
                 Object thisValue = row.get(column);
                 Object lastValue = containerMap.get(columnTarget);
                 // System.out.println("Comparing thisValue '" + thisValue + "' to lastValue '" + lastValue + "'");
 
                 if ((thisValue == null && lastValue != null) || (thisValue != null && !thisValue.equals(lastValue))) {
                     // values are different; create row
                     if (createLevel > level) {
                         createList = containerList;
 
                         // System.out.println("Reducing level to '" + level + "' because of " +
                         //   "column '" + columnTarget + "' differing (" + thisValue + " instead of previous: " + lastValue);
                         createLevel = level;
                     }
                 }
             }
         }
 
         if (createLevel > levels.size()) {
             // rows are completely identical -- don't add it to the list
             return;
         }
 
         for (int i = 0; i < createLevel; i++) {
             createPrefix = createPrefix + levels.get(i) + ".";
         }
 
         // generate 'createRow'
         for (Iterator<Map.Entry<String, String>> i = columnMapping.entrySet().iterator(); i.hasNext();) {
             Map.Entry<String, String> entry = i.next();
             String column = (String) entry.getKey();
             String columnTarget = (String) entry.getValue();
             if (!columnTarget.startsWith(createPrefix)) {
                 continue;
             }
             Object value = row.get(column); 
 
             //logger.debug("About to add column '" + columnTarget + "' from rs column '" + column + "'; createPrefix = '" + createPrefix + "' with value '" + value + "'");
             
             columnTarget = columnTarget.substring(createPrefix.length());
             //logger.debug("  columnTarget '" + columnTarget + "'");
 
             List<Map<String, Object>> containerList = createList;
             Map<String, Object> containerMap = createRow;
             
             int level = createLevel;  // ** was 0 ?
             String component;
             int pos = columnTarget.indexOf('.');
 
             while (pos != -1) {
                 component = columnTarget.substring(0, pos);
                 columnTarget = columnTarget.substring(pos + 1);
 
                 if (component.equals(levels.get(level))) {
                     level++;
                     containerList = (List<Map<String, Object>>) containerMap.get(component);
 
                     if (containerList == null) {
                         containerList = new ArrayList<Map<String, Object>>();
                         containerMap.put(component, containerList);
                         containerList.add(new HashMap<String, Object>());
                     }
 
                     containerMap = (Map<String, Object>) containerList.get(containerList.size() - 1);
                     if (containerMap==null) {
                     	logger.error("C null containerMap");
                     }
 
                 } else {
                     containerMap = (Map<String, Object>) containerMap.get(component);
                     if (containerMap==null) {
                     	logger.error("D null containerMap");
                     }
 
                 }
 
                 pos = columnTarget.indexOf('.');
             }
 
             containerMap.put(columnTarget, value);
         }
 
         if (createList == results) {
         	if (results.size()>0) { smch.processMap(results.get(0)); } 
         	results.clear(); // @TODO don't use a list for this, since we only ever hold a single object. Keeps it vaguely similar to StructuredResultReader a.k.a. StructuredListResultSetExtractor though.
         } else {
         	// smch.processSomethingElsePerhaps();
         }
         
         createList.add(createRow);
         lastResultRow = results.get(results.size() - 1);
         
     }
 
 }