/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
package com.nokia.s60tools.appdep.core.data;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.widgets.Display;

import com.nokia.s60tools.appdep.core.AppDepCacheIndexManager;
import com.nokia.s60tools.appdep.core.ICacheIndexListener;
import com.nokia.s60tools.appdep.exceptions.CacheFileDoesNotExistException;
import com.nokia.s60tools.appdep.resources.Messages;
import com.nokia.s60tools.appdep.ui.wizards.ICacheIndexCreatorObserver;

/**
 * Registers the valid cache index creation requests
 * and perform creation of registered cache indices 
 * when asked to do so.
 */
public class CacheIndexCreator implements Runnable, IRunnableWithProgress, ICacheIndexListener{

	/**
	 * Observer needing to get informed when cache index creation is ready.
	 */
	private final ICacheIndexCreatorObserver indexCreatorObserver;

	/**
	 * Count of cache indices to be created.
	 * Accessed only via increment and decrement methods
	 */
	private int cacheIndicesToBeCreatedCount = 0;
	
	/**
	 * Stores cache index creation requests.
	 */
	private ArrayList<CacheIndexCreationRequest> cacheIndexCreationReqArr = null;
	
	/**
	 * Reference to cache index manager.
	 */
	AppDepCacheIndexManager indexMgr = null;
	
	/**
	 * Reference to progress monitor of the job launching cache index creation.
	 */
	private IProgressMonitor monitorStored = null;
	
	/**
	 * Constructor to be launched from JUnit tests.
	 * @param indexCreatorObserver Observer needing to get informed when cache index creation is ready.
	 */
	public CacheIndexCreator(){
		this.indexCreatorObserver = null;
		this.allocateMembers();
	}
	
	/**
	 * Constructor to be launched from UI
	 * @param indexCreatorObserver Observer needing to get informed when cache index creation is ready.
	 */
	public CacheIndexCreator(ICacheIndexCreatorObserver indexCreatorObserver){
		this.indexCreatorObserver = indexCreatorObserver;
		allocateMembers();
	}
	
	/**
	 * Allocates member variables not initialized via constructor parameters.
	 */
	public void allocateMembers(){
		cacheIndexCreationReqArr = new ArrayList<CacheIndexCreationRequest>();				
	}
	
	/**
	 * Increments cache index creation count.
	 * @return incremented count.
	 */
	synchronized private int incrementIndicesToBeCreatedCount(){
		return (++cacheIndicesToBeCreatedCount);
	}
	
	/**
	 * Decrements cache index creation count.
	 * @return decremented count.
	 */
	synchronized private int decrementIndicesToBeCreatedCount(){
		return (--cacheIndicesToBeCreatedCount);			
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.operation.IRunnableWithProgress#run(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {

		if(monitorStored == null){			
			monitorStored = monitor;
			int steps = cacheIndexCreationReqArr.size();
			if(monitorStored != null){ // There is no monitor initialized in JUnit tests
				monitorStored.beginTask(Messages.getString("CacheIndexCreator.Creating_Cache_Indices"), steps); //$NON-NLS-1$			
			}
			handleIndexCreationRequests();			
		}//if			
		
	} //run

	/**
	 * Handles registered cache index creation request.
	 */
	private void handleIndexCreationRequests() {
		for (Iterator<CacheIndexCreationRequest> iter = cacheIndexCreationReqArr.iterator(); iter.hasNext();) {
			CacheIndexCreationRequest req = iter.next();
			try {
				// Requesting
				File cacheFile = new File(req.getCacheFile());
				if(!cacheFile.exists()){
					throw new CacheFileDoesNotExistException(cacheFile.getAbsolutePath());
				}
				CacheIndex.getCacheIndexInstance(cacheFile, req.getBuildDir());
			} catch (CacheFileDoesNotExistException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		} //for
		
		// Resetting array after all request have been handled
		cacheIndexCreationReqArr.clear();
	}

	/**
	 * Registers cache index creation request for a target identified 
	 * in parameters, if does not registered already.
	 * @param cacheFileAbsolutePathName Cache file path name for target to be registerd.
	 * @param buildDirAbsolutePathName Build directory file path name for target to be registerd.
	 */
	public void registerCacheIndexCreation(String cacheFileAbsolutePathName, 
			   String buildDirAbsolutePathName) {
								
		//Checking if we already have the cache index
		if(CacheIndex.cacheIndexExistsFor(cacheFileAbsolutePathName)){
			// Already exists, no need to re-create
			return;
		}
		
		// Checking that we do not already have the same request?...
		for (Iterator<CacheIndexCreationRequest> iter = cacheIndexCreationReqArr.iterator(); iter.hasNext();) {
			CacheIndexCreationRequest req = iter.next();
			if(req.getCacheFile().equalsIgnoreCase(cacheFileAbsolutePathName)){
				// Request already registered!
				return;
			}
		}
		
		// Not registered yet, registering...
		if(indexMgr == null){
			indexMgr = AppDepCacheIndexManager.getInstance();			
			indexMgr.addListener(this);								
		}
		
		incrementIndicesToBeCreatedCount();
		cacheIndexCreationReqArr.add(new CacheIndexCreationRequest(cacheFileAbsolutePathName, 
												   buildDirAbsolutePathName));
		
	}
	
	/**
	 * Checks if there are any cache creation requests.
	 * @return <code>true</code> if requests, otherwise <code>false</code>.
	 */
	public boolean hasIndexCreationRequests(){
		return (cacheIndexCreationReqArr.size() > 0);
	}
		
	/* (non-Javadoc)
	 * @see com.nokia.s60tools.appdep.core.ICacheIndexListener#cacheIndexCreationCompleted(com.nokia.s60tools.appdep.core.data.CacheIndex)
	 */
	public void cacheIndexCreationCompleted(CacheIndex cacheIndexObj) {
					
		final ICacheIndexListener listenerObj = this;
		final CacheIndex cacheIndexObjFinal = cacheIndexObj;
		
		Runnable monitorStatusUpdateRunnable = new Runnable(){
			public void run(){
				try {
					// One cache index creation step completed
					if(monitorStored != null){ // There is no monitor initialized in JUnit tests
						monitorStored.worked(1);						
					}
					
					try {
						// Refreshing tree view
						if(indexCreatorObserver != null){
							indexCreatorObserver.cacheIndexCreated(cacheIndexObjFinal);
						}						
					} catch (Exception e) {
						// User might have been Canceled the wizard
						// and widget is disposed and this call fails
						// Just then ignoring and making sure that
						// done() is called for monitor. 
					}
					
					// Updating count of work that is still pending
					// and testing if all the work has been done
					if(decrementIndicesToBeCreatedCount() == 0){
						if(monitorStored != null){ // There is no monitor initialized in JUnit tests
							monitorStored.done();
						}
						indexMgr.removeListener(listenerObj);
						// Forcing the manager creation next time
						// if new registrations happen during 
						// the lifetime of this object
						indexMgr = null;
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		};
		
		// Update request done in its own thread
		// in order not to cause invalid thread access
		Display.getDefault().asyncExec(monitorStatusUpdateRunnable);
	
	}

	/* (non-Javadoc)
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		handleIndexCreationRequests();			
	}

}