/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.monitor;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.Preferences.IPropertyChangeListener;
import org.eclipse.core.runtime.Preferences.PropertyChangeEvent;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.mylar.internal.core.MylarContextManager;
import org.eclipse.mylar.internal.core.MylarPreferenceContstants;
import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
import org.eclipse.mylar.internal.monitor.monitors.ActionExecutionMonitor;
import org.eclipse.mylar.internal.monitor.monitors.ActivityChangeMonitor;
import org.eclipse.mylar.internal.monitor.monitors.BrowserMonitor;
import org.eclipse.mylar.internal.monitor.monitors.KeybindingCommandMonitor;
import org.eclipse.mylar.internal.monitor.monitors.MenuCommandMonitor;
import org.eclipse.mylar.internal.monitor.monitors.PerspectiveChangeMonitor;
import org.eclipse.mylar.internal.monitor.monitors.PreferenceChangeMonitor;
import org.eclipse.mylar.internal.monitor.monitors.WindowChangeMonitor;
import org.eclipse.mylar.internal.monitor.ui.wizards.UsageSubmissionWizard;
import org.eclipse.mylar.provisional.core.AbstractCommandMonitor;
import org.eclipse.mylar.provisional.core.IInteractionEventListener;
import org.eclipse.mylar.provisional.core.MylarPlugin;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.events.ShellListener;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IStartup;
import org.eclipse.ui.IWindowListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.update.internal.core.UpdateCore;
import org.eclipse.update.internal.ui.security.Authentication;
import org.eclipse.update.internal.ui.security.UserValidationDialog;
import org.osgi.framework.BundleContext;

/**
 * @author Mik Kersten
 */
public class MylarMonitorPlugin extends AbstractUIPlugin implements IStartup {

	public static String VERSION = "0.5";

	public static String UPLOAD_FILE_LABEL = "USAGE";

	private static final long HOUR = 3600 * 1000;

	private static final long DELAY_ON_USER_REQUEST = 3 * HOUR;

	private static final long DELAY_ON_FAILURE = 5 * HOUR;

	public static final String DEFAULT_TITLE = "Mylar Feedback";

	public static final String DEFAULT_DESCRIPTION = "Fill out the following form to help us improve Mylar based on your input.\n";

	public static final long DEFAULT_DELAY_BETWEEN_TRANSMITS = 14 * 24 * HOUR;

	public static final String DEFAULT_ETHICS_FORM = "doc/study-ethics.html";

	public static final String DEFAULT_VERSION = "";

	public static final String DEFAULT_UPLOAD_SERVER = "http://mylar.eclipse.org/feedback/";

	public static final String DEFAULT_UPLOAD_SCRIPT_ID = "getUID.cgi";

	public static final String DEFAULT_UPLOAD_SCRIPT = "upload.cgi";

	public static final String DEFAULT_UPLAOD_SCRIPT_QUESTIONNAIRE = "questionnaire.cgi";

	public static final String DEFAULT_ACCEPTED_URL_LIST = "";

	public static final String DEFAULT_CONTACT_CONSENT_FIELD = "false";

	public static final String UI_PLUGIN_ID = "org.eclipse.mylar.ui";

	public static final String MONITOR_LOG_NAME = "monitor-history";

	public static final String MONITOR_LOG_NAME_OLD = "workspace";

	public static final String PLUGIN_ID = "org.eclipse.mylar.monitor";

	public static final String OBFUSCATED_LABEL = "[obfuscated]";

	private InteractionEventLogger interactionLogger;

	private String customizingPlugin = null;

	private PreferenceChangeMonitor preferenceMonitor = new PreferenceChangeMonitor();

	private PerspectiveChangeMonitor perspectiveMonitor;

	private ActivityChangeMonitor activityMonitor;

	private MenuCommandMonitor menuMonitor;

	private WindowChangeMonitor windowMonitor;

	private KeybindingCommandMonitor keybindingCommandMonitor;

	private BrowserMonitor browserMonitor;

	private static MylarMonitorPlugin plugin;

	private List<IActionExecutionListener> actionExecutionListeners = new ArrayList<IActionExecutionListener>();

	private List<AbstractCommandMonitor> commandMonitors = new ArrayList<AbstractCommandMonitor>();

	private ResourceBundle resourceBundle;

	private static Date lastTransmit = null;

	private boolean notifiedOfUserIdSubmission = false;

	private Authentication uploadAuthentication = null;

	private static boolean performingUpload = false;

	private boolean questionnaireEnabled = true;

	private boolean backgroundEnabled = false;

	private StudyParameters studyParameters = new StudyParameters();

	private IWindowListener WINDOW_LISTENER = new IWindowListener() {
		public void windowActivated(IWorkbenchWindow window) {
		}

		public void windowDeactivated(IWorkbenchWindow window) {
		}

		public void windowClosed(IWorkbenchWindow window) {
			if (window.getShell() != null) {
				window.getShell().removeShellListener(SHELL_LISTENER);
			}
		}

		public void windowOpened(IWorkbenchWindow window) {
			if (window.getShell() != null && !PlatformUI.getWorkbench().isClosing()) {
				window.getShell().addShellListener(SHELL_LISTENER);
			}
		}
	};

	private ShellListener SHELL_LISTENER = new ShellListener() {

		public void shellDeactivated(ShellEvent arg0) {
			if (!isPerformingUpload() && MylarPlugin.getDefault() != null) {
				for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
					listener.stopObserving();
			}
		}

		public void shellActivated(ShellEvent arg0) {
			if (!MylarPlugin.getDefault().suppressWizardsOnStartup() && MylarPlugin.getDefault() != null) {
				// checkForStudyPhasePromotion();
				checkForStatisticsUpload();
			}
			if (!isPerformingUpload() && MylarPlugin.getDefault() != null) {
				for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
					listener.startObserving();
			}
		}

		public void shellDeiconified(ShellEvent arg0) {
		}

		public void shellIconified(ShellEvent arg0) {
		}

		public void shellClosed(ShellEvent arg0) {
		}
	};

	private IPropertyChangeListener DATA_DIR_MOVE_LISTENER = new IPropertyChangeListener() {
		public void propertyChange(PropertyChangeEvent event) {
			if (event.getProperty().equals(MylarPreferenceContstants.PREF_DATA_DIR)) {
				if (event.getOldValue() instanceof String) {
					if (!isPerformingUpload()) {
						for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
							listener.stopObserving();
						interactionLogger.moveOutputFile(getMonitorLogFile().getAbsolutePath());
						for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
							listener.startObserving();
					}
				}
			} else {
			}
		}
	};

	public MylarMonitorPlugin() {
		plugin = this;
	}

	private void initDefaultPrefs() {
		getPreferenceStore().setDefault(MylarMonitorPreferenceConstants.PREF_MONITORING_OBFUSCATE, true);
	}

	/**
	 * Used to start plugin on startup -> entry in plugin.xml to invoke this
	 */
	public void earlyStartup() {
		final IWorkbench workbench = PlatformUI.getWorkbench();
		workbench.getDisplay().asyncExec(new Runnable() {
			public void run() {
				initDefaultPrefs();
				new MonitorExtensionPointReader().initExtensions();

				interactionLogger = new InteractionEventLogger(getMonitorLogFile());
				
				perspectiveMonitor = new PerspectiveChangeMonitor();
				activityMonitor = new ActivityChangeMonitor();
				windowMonitor = new WindowChangeMonitor();
				menuMonitor = new MenuCommandMonitor();
				keybindingCommandMonitor = new KeybindingCommandMonitor();
				browserMonitor = new BrowserMonitor();
				
				setAcceptedUrlMatchList(studyParameters.getAcceptedUrlList());

				if (getPreferenceStore().getBoolean(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED)) {
					getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED, false); // will
					// be
					// reset
					startMonitoring();
				}

				if (plugin.getPreferenceStore().contains(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE)) {
					lastTransmit = new Date(plugin.getPreferenceStore().getLong(
							MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE));
				} else {
					lastTransmit = new Date();
					plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
							lastTransmit.getTime());
				}
			}
		});
	}

	public void startMonitoring() {
		if (getPreferenceStore().getBoolean(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED))
			return;
		interactionLogger.startObserving();
		for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
			listener.startObserving();

		IWorkbench workbench = PlatformUI.getWorkbench();
		MylarPlugin.getDefault().addInteractionListener(interactionLogger);
		getCommandMonitors().add(keybindingCommandMonitor);

		getActionExecutionListeners().add(new ActionExecutionMonitor());
		workbench.addWindowListener(WINDOW_LISTENER);
		for (IWorkbenchWindow w : workbench.getWorkbenchWindows()) {
			if (w.getShell() != null) {
				w.getShell().addShellListener(SHELL_LISTENER);
			}
		}
		MylarPlugin.getDefault().getPluginPreferences().addPropertyChangeListener(DATA_DIR_MOVE_LISTENER);
		MylarPlugin.getDefault().addWindowPerspectiveListener(perspectiveMonitor);
		workbench.getActivitySupport().getActivityManager().addActivityManagerListener(activityMonitor);
		workbench.getDisplay().addFilter(SWT.Selection, menuMonitor);
		workbench.addWindowListener(windowMonitor);

		installBrowserMonitor(workbench);

		if (!MylarPlugin.getDefault().suppressWizardsOnStartup()) {
			checkForFirstMonitorUse();
		}
		getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED, true);
	}
	
	public void addMonitoredPreferences(Preferences preferences) { 
		preferences.addPropertyChangeListener(preferenceMonitor);
	}
	
	public void removeMonitoredPreferences(Preferences preferences) {
		preferences.removePropertyChangeListener(preferenceMonitor);
	}

//	private void installPreferenceMonitoring() {
//		((IEclipsePreferences) getPreferenceStore().getp())
//		.addNodeChangeListener(getNodeChangeListener());
		
//		Bundle[] bundles = PDERuntimePlugin.getDefault().getBundleContext().getBundles();
//		for (Bundle bundle : bundles) {
//			if (bundle.getHeaders().get(Constants.FRAGMENT_HOST) == null) {
//				if (bundle.getState() == Bundle.ACTIVE) {
//					System.err.println(">> " + bundle.getClass());
//				}
//			}
//		}

		// for (String namespace :
		// Platform.getExtensionRegistry().getNamespaces()) {
		// IExtension extension =
		// Platform.getExtensionRegistry().getExtension(namespace);
		// System.err.println(">>> " + extension);
		// }
//	}

	public void stopMonitoring() {
		if (!getPreferenceStore().getBoolean(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED))
			return;
		interactionLogger.stopObserving();
		for (IInteractionEventListener listener : MylarPlugin.getDefault().getInteractionListeners())
			listener.stopObserving();

		IWorkbench workbench = PlatformUI.getWorkbench();
		MylarPlugin.getDefault().removeInteractionListener(interactionLogger);

		getCommandMonitors().remove(keybindingCommandMonitor);
		getActionExecutionListeners().remove(new ActionExecutionMonitor());

		workbench.removeWindowListener(WINDOW_LISTENER);
		for (IWorkbenchWindow w : workbench.getWorkbenchWindows()) {
			if (w.getShell() != null) {
				w.getShell().removeShellListener(SHELL_LISTENER);
			}
		}
		MylarPlugin.getDefault().getPluginPreferences().removePropertyChangeListener(DATA_DIR_MOVE_LISTENER);

		MylarPlugin.getDefault().removeWindowPerspectiveListener(perspectiveMonitor);
		workbench.getActivitySupport().getActivityManager().removeActivityManagerListener(activityMonitor);
		workbench.getDisplay().removeFilter(SWT.Selection, menuMonitor);
		workbench.removeWindowListener(windowMonitor);

		uninstallBrowserMonitor(workbench);
		getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED, false);
	}

	@Override
	public void start(BundleContext context) throws Exception {
		super.start(context);
	}

	@Override
	public void stop(BundleContext context) throws Exception {
		super.stop(context);
		plugin = null;
		resourceBundle = null;
	}

	public void actionObserved(IAction action, String info) {
		for (IActionExecutionListener listener : actionExecutionListeners) {
			listener.actionObserved(action);
		}
	}

	public List<IActionExecutionListener> getActionExecutionListeners() {
		return actionExecutionListeners;
	}

	public List<AbstractCommandMonitor> getCommandMonitors() {
		return commandMonitors;
	}

	private void installBrowserMonitor(IWorkbench workbench) {
		workbench.addWindowListener(browserMonitor);
		IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
		for (int i = 0; i < windows.length; i++) {
			windows[i].addPageListener(browserMonitor);
			IWorkbenchPage[] pages = windows[i].getPages();
			for (int j = 0; j < pages.length; j++) {
				pages[j].addPartListener(browserMonitor);
			}
		}
	}

	private void uninstallBrowserMonitor(IWorkbench workbench) {
		workbench.removeWindowListener(browserMonitor);
		IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
		for (int i = 0; i < windows.length; i++) {
			windows[i].removePageListener(browserMonitor);
			IWorkbenchPage[] pages = windows[i].getPages();
			for (int j = 0; j < pages.length; j++) {
				pages[j].removePartListener(browserMonitor);
			}
		}
	}

	// /**
	// * @param newPath the fully filesystem path
	// */
	// public File moveMonitorLogFile(String newPath) throws IOException {
	// getPreferenceStore().setValue(PREF_LOG_FILE, newPath);
	// File newFile = interactionLogger.moveOutputFile(newPath);
	// return newFile;
	// }

	public File getMonitorLogFile() {
		File file = new File(MylarPlugin.getDefault().getDataDirectory() + File.separator + MONITOR_LOG_NAME
				+ MylarContextManager.CONTEXT_FILE_EXTENSION);

		File oldFile = new File(MylarPlugin.getDefault().getDataDirectory() + File.separator + MONITOR_LOG_NAME_OLD
				+ MylarContextManager.CONTEXT_FILE_EXTENSION);
		if (oldFile.exists()) {
			oldFile.renameTo(file);
		} else if (!file.exists() || !file.canWrite()) {
			try {
				file.createNewFile();
			} catch (IOException e) {
				MylarStatusHandler.log(e, "could not create monitor file");
			}
		}
		return file;
	}

	private long getUserTransimitDelay() {
		return DELAY_ON_USER_REQUEST / HOUR;
	}

	public void userCancelSubmitFeedback(Date currentTime, boolean wait3Hours) {
		if (wait3Hours) {
			lastTransmit.setTime(currentTime.getTime() + DELAY_ON_USER_REQUEST
					- studyParameters.getTransmitPromptPeriod());
			plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
					lastTransmit.getTime());
		} else {
			long day = HOUR * 24;
			lastTransmit.setTime(currentTime.getTime() + day - studyParameters.getTransmitPromptPeriod());
			plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
					lastTransmit.getTime());
		}
	}

	/**
	 * Returns the shared instance.
	 */
	public static MylarMonitorPlugin getDefault() {
		return plugin;
	}

	/**
	 * Returns the string from the plugin's resource bundle, or 'key' if not
	 * found.
	 */
	public static String getResourceString(String key) {
		ResourceBundle bundle = MylarMonitorPlugin.getDefault().getResourceBundle();
		try {
			return (bundle != null) ? bundle.getString(key) : key;
		} catch (MissingResourceException e) {
			return key;
		}
	}

	/**
	 * Returns the plugin's resource bundle,
	 */
	public ResourceBundle getResourceBundle() {
		try {
			if (resourceBundle == null)
				resourceBundle = ResourceBundle.getBundle("org.eclipse.mylar.monitor.MonitorPluginResources");
		} catch (MissingResourceException x) {
			resourceBundle = null;
		}
		return resourceBundle;
	}

	private void checkForFirstMonitorUse() {
		if (!isMonitoringEnabled())
			return;
		if (!notifiedOfUserIdSubmission
				&& !MylarPlugin.getDefault().getPreferenceStore().contains(MylarPreferenceContstants.USER_ID)) {
			notifiedOfUserIdSubmission = true;
			UsageSubmissionWizard wizard = new UsageSubmissionWizard(false);
			wizard.init(PlatformUI.getWorkbench(), null);
			WizardDialog dialog = new WizardDialog(Display.getDefault().getActiveShell(), wizard);
			dialog.create();
			dialog.open();
		}
	}

	private void checkForStatisticsUpload() {
		if (!isMonitoringEnabled())
			return;
		if (plugin == null || plugin.getPreferenceStore() == null)
			return;
		if (plugin.getPreferenceStore().contains(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE)) {
			lastTransmit = new Date(plugin.getPreferenceStore().getLong(
					MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE));
		} else {
			lastTransmit = new Date();
			plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
					lastTransmit.getTime());
		}
		Date currentTime = new Date();
		if (currentTime.getTime() > lastTransmit.getTime() + studyParameters.getTransmitPromptPeriod()) {
			String ending = getUserTransimitDelay() == 1 ? "" : "s";
			MessageDialog message = new MessageDialog(Display.getDefault().getActiveShell(), "Send Usage Feedback",
					null, "Send Mylar Usage Statistics feedback now?", MessageDialog.QUESTION, new String[] {
							IDialogConstants.YES_LABEL, "Remind me in " + getUserTransimitDelay() + " hour" + ending,
							"Remind me tomorrow" }, 0);
			int result = 0;
			if ((result = message.open()) == 0) {
				// time must be stored right away into preferences, to prevent
				// other threads
				lastTransmit.setTime(new Date().getTime());
				plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
						currentTime.getTime());

				UsageSubmissionWizard wizard = new UsageSubmissionWizard();
				wizard.init(PlatformUI.getWorkbench(), null);
				// Instantiates the wizard container with the wizard and
				// opens it
				WizardDialog dialog = new WizardDialog(Display.getDefault().getActiveShell(), wizard);
				dialog.create();
				dialog.open();
				if (wizard.failed()) {
					lastTransmit.setTime(currentTime.getTime() + DELAY_ON_FAILURE
							- studyParameters.getTransmitPromptPeriod());
					plugin.getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_PREVIOUS_TRANSMIT_DATE,
							currentTime.getTime());
				}
			} else {
				if (result == 1) {
					userCancelSubmitFeedback(currentTime, true);
				} else {
					userCancelSubmitFeedback(currentTime, false);
				}
				message.close();
			}
		}
	}

	public void incrementObservedEvents(int increment) {
		int numEvents = getPreferenceStore().getInt(MylarMonitorPreferenceConstants.PREF_NUM_USER_EVENTS);
		numEvents += increment;
		getPreferenceStore().setValue(MylarMonitorPreferenceConstants.PREF_NUM_USER_EVENTS, numEvents);
	}

	public void configureProxy(HttpClient httpClient) {
		if (UpdateCore.getPlugin().getPluginPreferences().getBoolean(UpdateCore.HTTP_PROXY_ENABLE)) {
			String proxyHost = UpdateCore.getPlugin().getPluginPreferences().getString(UpdateCore.HTTP_PROXY_HOST);
			int proxyPort = UpdateCore.getPlugin().getPluginPreferences().getInt(UpdateCore.HTTP_PROXY_PORT);
			httpClient.getHostConfiguration().setProxy(proxyHost, proxyPort);

			if (uploadAuthentication == null)
				uploadAuthentication = UserValidationDialog.getAuthentication(proxyHost,
						"(Leave fields blank if authentication is not required)");
			if (uploadAuthentication != null) {
				httpClient.getState().setProxyCredentials(
						new AuthScope(proxyHost, proxyPort),
						new UsernamePasswordCredentials(uploadAuthentication.getUser(), uploadAuthentication
								.getPassword()));
			}
		}
	}

	public static IPreferenceStore getPrefs() {
		return getDefault().getPreferenceStore();
	}

	public static boolean isPerformingUpload() {
		return performingUpload;
	}

	public static void setPerformingUpload(boolean performingUpload) {
		MylarMonitorPlugin.performingUpload = performingUpload;
	}

	public InteractionEventLogger getInteractionLogger() {
		return interactionLogger;
	}

	public boolean isQuestionnaireEnabled() {
		return questionnaireEnabled;
	}

	public void setQuestionnaireEnabled(boolean questionnaireEnabled) {
		this.questionnaireEnabled = questionnaireEnabled;
	}

	class MonitorExtensionPointReader {

		public static final String EXTENSION_ID_STUDY = "org.eclipse.mylar.monitor.study";

		public static final String ELEMENT_SCRIPTS = "scripts";

		public static final String ELEMENT_SCRIPTS_VERSION = "version";

		public static final String ELEMENT_SCRIPTS_SERVER_URL = "url";

		public static final String ELEMENT_SCRIPTS_UPLOAD_USAGE = "upload";

		public static final String ELEMENT_SCRIPTS_GET_USER_ID = "userId";

		public static final String ELEMENT_SCRIPTS_UPLOAD_QUESTIONNAIRE = "questionnaire";

		public static final String ELEMENT_UI = "ui";

		public static final String ELEMENT_UI_TITLE = "title";

		public static final String ELEMENT_UI_DESCRIPTION = "description";

		public static final String ELEMENT_UI_UPLOAD_PROMPT = "daysBetweenUpload";

		public static final String ELEMENT_UI_QUESTIONNAIRE_PAGE = "questionnairePage";

		public static final String ELEMENT_UI_BACKGROUND_PAGE = "backgroundPage";

		public static final String ELEMENT_UI_CONSENT_FORM = "consentForm";

		public static final String ELEMENT_UI_CONTACT_CONSENT_FIELD = "useContactField";

		public static final String ELEMENT_MONITORS = "monitors";

		public static final String ELEMENT_MONITORS_BROWSER_URL = "browserUrlFilter";

		private boolean extensionsRead = false;

		// private MonitorExtensionPointReader thisReader = new
		// MonitorExtensionPointReader();

		@SuppressWarnings("deprecation")
		public void initExtensions() {
			try {
				if (!extensionsRead) {
					IExtensionRegistry registry = Platform.getExtensionRegistry();
					IExtensionPoint extensionPoint = registry.getExtensionPoint(EXTENSION_ID_STUDY);
					if (extensionPoint != null) {
						IExtension[] extensions = extensionPoint.getExtensions();
						for (int i = 0; i < extensions.length; i++) {
							IConfigurationElement[] elements = extensions[i].getConfigurationElements();
							for (int j = 0; j < elements.length; j++) {
								if (elements[j].getName().compareTo(ELEMENT_SCRIPTS) == 0) {
									readScripts(elements[j]);
								} else if (elements[j].getName().compareTo(ELEMENT_UI) == 0) {
									readForms(elements[j]);
								} else if (elements[j].getName().compareTo(ELEMENT_MONITORS) == 0) {
									readMonitors(elements[j]);
								}
							}
							customizingPlugin = extensions[i].getNamespace();
							getPreferenceStore()
									.setValue(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED, true);
						}
						extensionsRead = true;
					}
				}
			} catch (Throwable t) {
				MylarStatusHandler.fail(t, "could not read monitor extension", false);
			}
		}

		private void readScripts(IConfigurationElement element) {
			studyParameters.setVersion(element.getAttribute(ELEMENT_SCRIPTS_VERSION));
			studyParameters.setScriptsUrl(element.getAttribute(ELEMENT_SCRIPTS_SERVER_URL));
			studyParameters.setScriptsUpload(element.getAttribute(ELEMENT_SCRIPTS_UPLOAD_USAGE));
			studyParameters.setScriptsUserId(element.getAttribute(ELEMENT_SCRIPTS_GET_USER_ID));
			studyParameters.setScriptsQuestionnaire(element.getAttribute(ELEMENT_SCRIPTS_UPLOAD_QUESTIONNAIRE));
		}

		private void readForms(IConfigurationElement element) throws CoreException {
			studyParameters.setTitle(element.getAttribute(ELEMENT_UI_TITLE));
			studyParameters.setDescription(element.getAttribute(ELEMENT_UI_DESCRIPTION));
			if (element.getAttribute(ELEMENT_UI_UPLOAD_PROMPT) != null) {
				Integer uploadInt = new Integer(element.getAttribute(ELEMENT_UI_UPLOAD_PROMPT));
				studyParameters.setTransmitPromptPeriod(HOUR * 24 * uploadInt);
			}
			studyParameters.setUseContactField(element.getAttribute(ELEMENT_UI_CONTACT_CONSENT_FIELD));

			try {
				if (element.getAttribute(ELEMENT_UI_QUESTIONNAIRE_PAGE) != null) {
					Object questionnaireObject = element.createExecutableExtension(ELEMENT_UI_QUESTIONNAIRE_PAGE);
					if (questionnaireObject instanceof IQuestionnairePage) {
						IQuestionnairePage page = (IQuestionnairePage) questionnaireObject;
						studyParameters.setQuestionnairePage(page);
					}
				} else {
					MylarMonitorPlugin.getDefault().setQuestionnaireEnabled(false);
				}
			} catch (CoreException throwable) {
				MylarStatusHandler.fail(throwable, "could not load questionnaire", false);
				MylarMonitorPlugin.getDefault().setQuestionnaireEnabled(false);
			}

			try {
				if (element.getAttribute(ELEMENT_UI_BACKGROUND_PAGE) != null) {
					Object backgroundObject = element.createExecutableExtension(ELEMENT_UI_BACKGROUND_PAGE);
					if (backgroundObject instanceof IBackgroundPage) {
						IBackgroundPage page = (IBackgroundPage) backgroundObject;
						studyParameters.setBackgroundPage(page);
						MylarMonitorPlugin.getDefault().setBackgroundEnabled(true);
					}
				} else {
					MylarMonitorPlugin.getDefault().setBackgroundEnabled(false);
				}
			} catch (CoreException throwable) {
				MylarStatusHandler.fail(throwable, "could not load background page", false);
				MylarMonitorPlugin.getDefault().setBackgroundEnabled(false);
			}

			studyParameters.setFormsConsent("/" + element.getAttribute(ELEMENT_UI_CONSENT_FORM));

		}

		private void readMonitors(IConfigurationElement element) throws CoreException {
			// TODO: This should parse a list of filters but right now it takes
			// the
			// entire string as a single filter.
			// ArrayList<String> urlList = new ArrayList<String>();
			String urlList = element.getAttribute(ELEMENT_MONITORS_BROWSER_URL);
			studyParameters.setAcceptedUrlList(urlList);
		}
	}

	public StudyParameters getStudyParameters() {
		return studyParameters;
	}

	public String getCustomizingPlugin() {
		return customizingPlugin;
	}

	public boolean isMonitoringEnabled() {
		return getPreferenceStore().getBoolean(MylarMonitorPreferenceConstants.PREF_MONITORING_ENABLED);
	}

	public String getCustomizedByMessage() {
		String customizedBy = MylarMonitorPlugin.getDefault().getCustomizingPlugin();
		String message = "NOTE: You have previously downloaded the Mylar monitor and a user study plug-in with id: "
				+ customizedBy + "\n" + "If you are not familiar with this plug-in do not upload data.";
		return message;
	}

	/**
	 * @return true if the list was set
	 */
	public boolean setAcceptedUrlMatchList(String urlBuffer) {
		if (browserMonitor != null) {
			browserMonitor.setAcceptedUrls(urlBuffer);
			return true;
		} else {
			return false;
		}
	}

	public boolean isBackgroundEnabled() {
		return backgroundEnabled;
	}

	public void setBackgroundEnabled(boolean backgroundEnabled) {
		this.backgroundEnabled = backgroundEnabled;
	}

	public String getExtensionVersion() {
		return studyParameters.getVersion();
	}

	public boolean usingContactField() {
		if (studyParameters.getUseContactField().equals("true"))
			return true;
		else
			return false;
	}
}