/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight.pagination;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import com.mindtree.techworks.insight.InsightConstants;
  import com.mindtree.techworks.insight.model.ILogEventModelMutator;
  import com.mindtree.techworks.insight.model.IMutatorListener;
  
  /**
   * The <code>PageSet</code> class holds the information of a collection of pages and 
   * has the methods for navigating through the collection  
   * 
   * 
   * 
   *@author  Antony Pulicken 
  * @version 1.0, Feb 01, 2005
   *
   */
  public class PageSet implements IMutatorListener{
  	
  	/**
  	 * Holds the current page instance
  	 */
  	private PageImpl pageImpl;
  	
  	/**
  	 * Holds the currentPage page instance
  	 */
  	private PageImpl currentPage;
  	
  	/**
  	 * The number of pages in  the pageset
  	 */
  	private long pageCnt;
  	
  
  	/**
  	 * Unique Namespace for the pageset
  	 */
  	private String namespace;
  	
  	/**
  	 * Current Page Number
  	 */
  	private long currentPageCnt;
  	
  	/**
  	 * The type of the ILogEventModelMutator using this PageSet
  	 */
  	private int mutatorType;	
  	
  	/**
  	 * Constructor
  	 */
  	public PageSet(){	
  		this.namespace = generateUniqueNS();
  		currentPageCnt = 1;
  		pageCnt = 0;
  		createNewPage();
  		this.currentPage = pageImpl;
  	}
  
  	/**
  	 * Creates a new Page 
  	 * @return
  	 */
  	private PageImpl createNewPage() {
  		pageCnt++;
  		this.pageImpl = PageImplFactory.getDefaultImpl();		
  		pageImpl.init(this);
  		// if mutator type is tailing set the current page as the last page
  		if (this.mutatorType == ILogEventModelMutator.TAILING_MUTATOR) {
  			getLast();
 		}
 		return pageImpl;
 	}
 
 	/**
 	 * Call back method to know whether the threshold is reached 
 	 */
 	protected void thresholdReached(){
 		storePage();
 		if(!String.valueOf(getCurrentPageCnt()).equals(pageImpl.getPageNamespace())){
 			pageImpl.clear();
 		}
 		createNewPage();
 	}
 	
 	/**
 	 * Stores the page
 	 */
 	private void storePage(){
 		pageImpl.store();
 	}
 
 	/**
 	 * Loads the page based on the pagenumber passed
 	 * @param pageNumber The page number to be loaded
 	 */
 	private void loadPage(long pageNumber){
 		currentPage.setPageNamespace(String.valueOf(pageNumber));	
 		currentPage.load();
 	}
 
 	
 	
 	/**
 	 * Returns the UniqueNameSpace
 	 * @return
 	 */
 	private String generateUniqueNS() {
 		return String.valueOf(this.hashCode());
 	}
 
 	/**
 	 * 
 	 * @return pageCnt The Page Count
 	 */
 	protected  long getPageCnt() {
 		return this.pageCnt;
 	}
 
 	
 	/**
 	 * Returns the current page 
 	 * @return currentPage 
 	 */	
 	public IPage getCurrentPage() {
 		return this.currentPage;
 	}
 
 	/**
 	 * Loads the page based on the direction 
 	 * @param direction 
 	 * @return currentPage
 	 * 
 	 */
 	public IPage navigate(String direction) {
 		if(direction.equals(InsightConstants.getLiteral("FIRST_PAGE"))){
 			getFirst();
 		}else if(direction.equals(InsightConstants.getLiteral("PREV_PAGE"))){
 			getPrevious();
 		}else if(direction.equals(InsightConstants.getLiteral("NEXT_PAGE"))){
 			getNext();
 		}else if(direction.equals(InsightConstants.getLiteral("LAST_PAGE"))){
 			getLast();
 		}
 		loadPage(currentPageCnt);
 		return currentPage;
 	}
 
 	/**
 	 * Sets the current page count to the next page
 	 * 
 	 */
 	private void getNext() {
 		if(currentPageCnt < pageCnt){
 			currentPageCnt = currentPageCnt + 1;	
 		}		
 	}
 
 	/**
 	 * Sets the current page count to the previous page
 	 * 
 	 */
 	private void getPrevious() {
 		if(currentPageCnt !=1){
 			currentPageCnt = currentPageCnt - 1;	
 		}
 	}
 
 	/**
 	 * Sets the current page count to the first page
 	 * 
 	 */
 	private void getFirst() {
 		currentPageCnt = 1;
 	}
 
 	/**
 	 * Sets the current page count to the last page
 	 * 
 	 */
 	private void getLast() {
 		currentPageCnt = pageCnt;
 	}
 	/**
 	 * @return Returns the namespace.
 	 */
 	protected String getNamespace() {
 		return namespace;
 	}
 	/**
 	 * @param namespace The namespace to set.
 	 */
 	protected void setNamespace(String namespace) {
 		this.namespace = namespace;
 	}
 	
 	/**
 	 * @param pageNumber
 	 */
 	public void loadPageByNumber (long pageNumber) {
 		if (this.currentPageCnt == pageNumber) {
 			return;
 		}
 		this.currentPageCnt = pageNumber;
 		loadPage(pageNumber);
 	}
 	
 	/**
 	 * Deletes all the files/directories associated with this PageSet
 	 *
 	 */
 	public void clear(){
 		currentPageCnt = 0;
 		pageCnt = 0;
 		pageImpl = null;
 		currentPage = null;
 		String dirToDel = System.getProperty("java.io.tmpdir") + InsightConstants.ROOT_CACHE_DIR + InsightConstants.FILE_SEPARATOR + getNamespace();
 		File file  =new File(dirToDel);
 		cleanDirectory(file);
 	}
 
 	/**
 	 * Clears all the Directories and Files created under the root cache directory
 	 * 
 	 *
 	 */
 	public static void clearAll(){
 		File rootDir = new File(System.getProperty("java.io.tmpdir") + InsightConstants.ROOT_CACHE_DIR);
 		cleanDirectory(rootDir);		
 	}
 	
 	/**
 	 * Deletes all the files/directories under the path passed to the method
 	 * @param fileDir The directory to be deleted
 	 */
 	private static void cleanDirectory(File fileDir){
 		List fileNames = new ArrayList();
 		if(fileDir.exists()){
 			String path = fileDir.getAbsolutePath() + InsightConstants.FILE_SEPARATOR;
 			String fileList[] = fileDir.list();
 			for(int i=0; i < fileList.length; i++){
 				File file = new File(path + fileList[i]);
 				if(file.isDirectory()){
 					fileNames.add(file);
 				}else{
 					if(file.getName().indexOf(InsightConstants.FILE_EXT) != -1){
 						file.delete();	
 					}
 				}
 			}
 			for(int i=0; i < fileNames.size(); i++){
 				File dir = (File)fileNames.get(i);
 				cleanDirectory(dir);						
 			}
 			fileDir.delete();  
 		}
 	}
 	
 	/**
 	 * @return Returns the lastPage.
 	 */
 	public IPage getLastPage() {
 		return this.pageImpl;
 	}
 	
 	/**
 	 * Returns the current page number
 	 * @return currentPageCnt The current pagenumber
 	 */
 	public long getCurrentPageCnt(){
 		return this.currentPageCnt;
 	}
 
 	/**
 	 * Returns the total number of pages 
 	 * @return pageCnt Total number of pages
 	 */
 	public long getTotalPageCnt(){
 		return this.pageCnt;
 	}
 
 	/**
 	 * Call back method using which the controller will be notifed by 
 	 * any LogEventModelMutators starts mutating the LogEventModel 
 	 * @see IMutatorListener#startMutating()
 	 */
 	public void startMutating (int mutatorType) {
 		this.mutatorType = mutatorType;
 	}
 	
 	/**
 	 * Call back method using which the controller will be notifed by 
 	 * any LogEventModelMutators ends mutating the LogEventModel
 	 * @see IMutatorListener#endMutating(int)
 	 */
 	public void endMutating (int infoFlag) {
 		storePage();
 	}
 	
 	/**
 	 * Gets the type of th mutator that is using this PageSet
 	 * @return Returns the mutatorType.
 	 */
 	public int getMutatorType() {
 		return mutatorType;
 	}
 	
 	/**
 	 * Sets the mutator type for this PageSet
 	 * @param mutatorType The mutatorType to set.
 	 */
 	public void setMutatorType(int mutatorType) {
 		this.mutatorType = mutatorType;
 	}
 	
 	/**
 	 * Returns the current page number
 	 * @return currentPageCnt The current pagenumber
 	 */
 	public  PageSetIterator getPageSetIterator(){
 		return new PageSetIterator();
 	}
 	
 	/**
 	 * The <code>PageSetIterator</code> class implements Iterator and has methods for 
 	 * iterating through the pageset  
 	 * 
 	 * @author antonypulicken
 	 * 
 	 *@author  Antony Pulicken 
 	* @version 1.0, Feb 01, 2005
 	 *
 	 */
 	private class PageSetIterator implements Iterator{
 		
 		/**
 		 * Page Count
 		 */
 		private long iteratorPageCnt;
 		
 		/**
 		 * Deafault Constructor
 		 */
 		public PageSetIterator() {
 			iteratorPageCnt = 0 ;
 		}
 		
 		/**
 		 * No implementation
 		 * @see java.util.Iterator#remove()
 		 */
 		public void remove() {
 			throw new NoSuchMethodError();			
 		}
 
 		/**
 		 * Returns true if there are more pages 
 		 * return boolean
 		 * @see java.util.Iterator#hasNext()
 		 */
 		public boolean hasNext() {
 			if(iteratorPageCnt < pageCnt){
 				iteratorPageCnt = iteratorPageCnt + 1;
 				return true;
 			}
 			loadPage(currentPageCnt);
 			return false;
 		}
 
 		/**
 		 * Returns the next page
 		 * return Object 
 		 * @see java.util.Iterator#next()
 		 */
 		public Object next() {
 			loadPage(iteratorPageCnt);
 			return currentPage;
 		}
 		/**
 		 * @return Returns the iteratorPageCnt.
 		 */
 		public long getIteratorPageCnt () {
 
 			return iteratorPageCnt;
 		}
 	}
 }