package org.musicontroller.gui.admin;
   
   import java.util.Set;
   
   import org.apache.tapestry.event.PageBeginRenderListener;
   import org.apache.tapestry.event.PageEndRenderListener;
   import org.apache.tapestry.event.PageEvent;
   import org.apache.tapestry.html.BasePage;
   import org.musicontroller.core.Keyword;
  import org.musicontroller.dao.Dao;
  
  /**
   * Page that handles the management of Keywords.
   * 
   * @author Varienaja
   * @version $Id: Keywordmanagement.java,v 1.1 2010/03/16 18:55:43 varienaja Exp $
   */
  public abstract class Keywordmanagement extends BasePage {
  	public abstract Dao getDao();
  	
  	private Keyword[][] _matrix;
  	private int _currentRow;
  	
  	public abstract int getRow();
  	public abstract void setRow(int row);
  
  	public abstract int getColumn();
  	public abstract void setColumn(int column);
  	
  	public Keywordmanagement() {
  		super();
  		addPageBeginRenderListener(
  			new PageBeginRenderListener() {
  		        public void pageBeginRender(PageEvent e) {
  		        	_matrix = null;
  		        }
  			}		
  		);
  		
  		this.addPageEndRenderListener(
  			new PageEndRenderListener() {
  				public void pageEndRender(PageEvent e) {
  					_matrix = null;
  				}
  			}
  		);
  
  	}
  	
  	/**
  	 * Returns the hierarchical Keyword matrix.
  	 * @return The keyword matrix.
  	 */
  	public Keyword[][] getMatrix() {
  		if (_matrix==null) {
  			Set<Keyword> parents = Keyword.constructHierarchy(getDao().listKeywords());
  			int maxX = getMaxHierarchyDepth(parents);
  			int maxY = getRowCount(parents);
  			_matrix = new Keyword[maxX][maxY];
  			
  			_currentRow = 0;
  			fillMatrix(parents, 0);
  		}
  		return _matrix;
  	}
  	
  	private void fillMatrix(Set<Keyword> parents, int x) {
  		for (Keyword k : parents) {
  			_matrix[x][_currentRow] = k;
  			if (k.getChildCount()>0) {
  				fillMatrix(k.getChildren(), x+1);
  			} else {
  				_currentRow++;
  			}
  		}
  	}
  	
  	/**
  	 * @return The maximum depth of a Keyword hierarchy.
  	 */
  	private int getMaxHierarchyDepth(Set<Keyword> parents) {
  		int result = 1;
  		for (Keyword k : parents) {
  			int depth = getMaxDepth(k);
  			if (depth > result) {
  				result = depth;
  			}
  		}
  		return result;
  	}
  	
  	private int getMaxDepth(Keyword k) {
  		int result = 1;
  		if (k.getChildCount()>0) {
  			for (Keyword candidate : k.getChildren()) {
  				int depth = 1 + getMaxDepth(candidate);
  				if (depth > result) {
  					result = depth;
  				}
 			}
 		}
 		return result;
 	}
 	
 	/**
 	 * In order to render the table with the keyword-hierarchy, we need to know
 	 * the amount of rows.
 	 * @return The amount of rows to render.
 	 */
 	private int getRowCount(Set<Keyword> parents) {
 		int result = 0;
 		for (Keyword k : parents) {
 			int childcount = k.getChildCount();
 			result += childcount==0 ? 1 : childcount;
 		}
 		return result;
 	}
 
 	/**
 	 * Provides an integer-array for looping over all rows for the Keyword
 	 * hierarchy table.
 	 * @return
 	 */
 	public int[] getRows() {
 		int length = 0;
 		
 		Keyword[][] matrix = getMatrix();
 		if (matrix.length>0) {
 			length = matrix[0].length;
 		}
 		
 		int[] result = new int[length];
 		for (int i=0; i<result.length; i++) {
 			result[i] = i;
 		}
 		return result;
 	}
 	
 	/**
 	 * Provides an integer-array for looping over all columns for the Keyword
 	 * hierarchy table.
 	 * @return
 	 */
 	public int[] getColumns() {
 		int[] result = new int[getMatrix().length];
 		for (int i=0; i<result.length; i++) {
 			result[i] = i;
 		}
 		return result;
 	}
 	
 	public Keyword getKeyword() {
 		return getMatrix()[getColumn()][getRow()];
 	}
 	
 	public int getMaxHierarchyDepth() {
 		return getMatrix().length;
 	}
 	
 	/**
 	 * The rowspan is the number of childs that do not have children.
 	 * @return
 	 */
 	public int getRowspan() {
 		return getRowspan(getKeyword());
 	}
 	
 	private int getRowspan(Keyword keyword) {
 		int result = 0;
 		
 		if (keyword.getChildCount()>0) {
 			for (Keyword child : keyword.getChildren()) {
 				result += getRowspan(child);	
 			}
 		} else {
 			return 1;
 		}
 		
 		return result;
 	}
 
 }