package org.eclipse.debug.internal.ui;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.IFileEditorMapping;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.internal.WorkbenchPlugin;

public class LaunchConfigurationTypesPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
	
	// UI widgets
	private Label fFileTypeLabel;
	private TableViewer fFileTypeTableViewer;
	private Label fConfigTypeLabel;
	private TableViewer fConfigTypeTableViewer;
	private Button fDefaultButton;
	
	// Local mapping of file extensions to default launch configs.  It is necessary to keep a local
	// copy of this in this class so that the user can 'Cancel' out of any changes they make in this 
	// preference page.
	private Map fDefaultConfigsMap;

	/**
	 * Content provider for the file type TableViewer
	 */
	protected class FileTypeContentProvider implements IStructuredContentProvider {
		
		private String[] fContent;
		
		public FileTypeContentProvider(String[] content) {
			fContent = content;
		}
		
		/**
		 * @see IStructuredContentProvider#getElements(Object)
		 */
		public Object[] getElements(Object inputElement) {
			return fContent;
		}

		/**
		 * @see IContentProvider#dispose()
		 */
		public void dispose() {
		}

		/**
		 * @see IContentProvider#inputChanged(Viewer, Object, Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}

	}

	/**
	 * Label provider for the FileType table viewer
	 */
	protected class FileTypeLabelProvider extends LabelProvider implements ITableLabelProvider {
		
		private Map fExtensionToImageMap;
		
		public FileTypeLabelProvider() {
			initializeExtensionToImageMap();
		}
		
		/**
		 * Load a table of iamge descriptors keyed by the file extensions they apply to.
		 */
		private void initializeExtensionToImageMap() {
			fExtensionToImageMap = new HashMap(5);
			IFileEditorMapping[] array = WorkbenchPlugin.getDefault().getEditorRegistry().getFileEditorMappings();
			for (int i = 0; i < array.length; i++) {
				IFileEditorMapping mapping = array[i];
				fExtensionToImageMap.put(mapping.getExtension(), mapping.getImageDescriptor());
			}		
		}
		
		/**
		 * @see ITableLabelProvider#getColumnText(Object, int)
		 */
		public String getColumnText(Object object, int column) {
			if (column == 0) {
				return generateElementText(object);
			}
			return ""; //$NON-NLS-1$
		}
		
		/**
		 * @see ILabelProvider#getText(Object)
		 */
		public String getText(Object element) {
			return generateElementText(element);
		}
		
		/**
		 * @see ITableLabelProvider#getColumnImage(Object, int)
		 */
		public Image getColumnImage(Object object, int column) {
			ImageDescriptor imageDescriptor = (ImageDescriptor) fExtensionToImageMap.get((String)object);
			return imageDescriptor.createImage(true);
		}
		
		/**
		 * Convenience method that generates the displayable form of a file type
		 */
		private String generateElementText(Object obj) {
			StringBuffer buffer = new StringBuffer((String)obj);
			buffer.insert(0, "*.");			//$NON-NLS-1$
			return buffer.toString();
		}
	}

	/**
	 * Content provider for the configuration type TableViewer
	 */
	protected class ConfigTypeContentProvider implements IStructuredContentProvider {
		
		private String fFileTypeInput;
		
		/**
		 * @see IStructuredContentProvider#getElements(Object)
		 */
		public Object[] getElements(Object inputElement) {
			return getLaunchManager().getAllLaunchConfigurationTypesFor(fFileTypeInput);
		}

		/**
		 * @see IContentProvider#dispose()
		 */
		public void dispose() {
		}

		/**
		 * @see IContentProvider#inputChanged(Viewer, Object, Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			fFileTypeInput = (String) newInput;
		}

	}

	/**
	 * Label provider for the configuration table viewer
	 */
	protected class ConfigTypeLabelProvider extends LabelProvider implements ITableLabelProvider {		
		
		/**
		 * @see ITableLabelProvider#getColumnText(Object, int)
		 */
		public String getColumnText(Object object, int column) {
			if (column == 0) {
				return generateElementText(object);
			}
			return ""; //$NON-NLS-1$
		}
		
		/**
		 * @see ILabelProvider#getText(Object)
		 */
		public String getText(Object element) {
			return generateElementText(element);
		}
		
		/**
		 * @see ITableLabelProvider#getColumnImage(Object, int)
		 */
		public Image getColumnImage(Object object, int column) {
			String configTypeID = ((ILaunchConfigurationType)object).getIdentifier();
			return DebugUITools.getImage(configTypeID);
		}
		
		/**
		 * Convenience method that generates the displayable form of a file type
		 */
		private String generateElementText(Object obj) {
			ILaunchConfigurationType configType = (ILaunchConfigurationType) obj;
			StringBuffer buffer = new StringBuffer(configType.getName());
			String selectedFileType = getFileTypeSelection();
			if (getDefaultConfigsMap().get(selectedFileType).equals(configType)) {
				buffer.append(DebugUIMessages.getString("LaunchConfigurationTypesPreferencePage._(default)_1")); //$NON-NLS-1$
			}
			return buffer.toString();
		}
	}

	/**
	 * Creates the page's UI content.
	 */
	protected Control createContents(Composite parent) {
	
		Composite topComp = new Composite(parent, SWT.NULL);
		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		topComp.setLayout(layout);
		GridData gd;
	
		setFileTypeLabel(new Label(topComp, SWT.LEFT));
		getFileTypeLabel().setText(DebugUIMessages.getString("LaunchConfigurationTypesPreferencePage.File_types_2")); //$NON-NLS-1$
		gd = new GridData();
		gd.horizontalSpan = 2;
		getFileTypeLabel().setLayoutData(gd);
	
		setFileTypeTableViewer(new TableViewer(topComp, SWT.SINGLE | SWT.BORDER | SWT.FULL_SELECTION));
		String[] fileTypes = getLaunchManager().getAllRegisteredFileExtensions();
		getFileTypeTableViewer().setContentProvider(new FileTypeContentProvider(fileTypes));
		getFileTypeTableViewer().setLabelProvider(new FileTypeLabelProvider());
		getFileTypeTableViewer().addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent evt) {
				handleFileTypeSelectionChanged();
			}
		});
		gd = new GridData(GridData.FILL_BOTH);
		getFileTypeTableViewer().getTable().setLayoutData(gd);
		getFileTypeTableViewer().setInput(fileTypes);
	
		createSpacer(topComp, 1);
		createSpacer(topComp, 2);
	
		setConfigTypeLabel(new Label(topComp, SWT.LEFT));
		getConfigTypeLabel().setText(DebugUIMessages.getString("LaunchConfigurationTypesPreferencePage.Configuration_types_3")); //$NON-NLS-1$
		gd = new GridData();
		gd.horizontalSpan = 2;
		getConfigTypeLabel().setLayoutData(gd);
	
		setConfigTypeTableViewer(new TableViewer(topComp, SWT.SINGLE | SWT.BORDER));
		getConfigTypeTableViewer().setContentProvider(new ConfigTypeContentProvider());
		getConfigTypeTableViewer().setLabelProvider(new ConfigTypeLabelProvider());
		getConfigTypeTableViewer().addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent evt) {
				handleConfigTypeSelectionChanged();
			}
		});
		gd = new GridData(GridData.FILL_BOTH);
		getConfigTypeTableViewer().getTable().setLayoutData(gd);
		
		setDefaultButton(new Button(topComp, SWT.PUSH));
		getDefaultButton().setText(DebugUIMessages.getString("LaunchConfigurationTypesPreferencePage.Set_as_default_4")); //$NON-NLS-1$
		getDefaultButton().addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent evt) {
				handleDefaultButtonSelected();
			}
		});
		gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
		getDefaultButton().setLayoutData(gd);
		
		//WorkbenchHelp.setHelp(parent, new DialogPageContextComputer(this, IHelpContextIds.FILE_EDITORS_PREFERENCE_PAGE));
		
		return topComp;
	}

	protected void createSpacer(Composite composite, int columnSpan) {
		Label label = new Label(composite, SWT.NONE);
		GridData gd = new GridData();
		gd.horizontalSpan = columnSpan;
		label.setLayoutData(gd);
	}
	
	private void setDefaultConfigsMap(Map defaultConfigsMap) {
		fDefaultConfigsMap = defaultConfigsMap;
	}

	private Map getDefaultConfigsMap() {
		return fDefaultConfigsMap;
	}

	/*****************************************************************************
	 * 
	 * Accessors for the UI widgets
	 * 
	 *****************************************************************************/
	
	private void setDefaultButton(Button defaultButton) {
		fDefaultButton = defaultButton;
	}

	private Button getDefaultButton() {
		return fDefaultButton;
	}

	private void setConfigTypeTableViewer(TableViewer tableViewer) {
		fConfigTypeTableViewer = tableViewer;
	}

	private TableViewer getConfigTypeTableViewer() {
		return fConfigTypeTableViewer;
	}

	private void setConfigTypeLabel(Label configTypeLabel) {
		fConfigTypeLabel = configTypeLabel;
	}

	private Label getConfigTypeLabel() {
		return fConfigTypeLabel;
	}

	private void setFileTypeLabel(Label fileTypeLabel) {
		fFileTypeLabel = fileTypeLabel;
	}

	private Label getFileTypeLabel() {
		return fFileTypeLabel;
	}
	
	private void setFileTypeTableViewer(TableViewer tableViewer) {
		fFileTypeTableViewer = tableViewer;
	}
	
	private TableViewer getFileTypeTableViewer() {
		return fFileTypeTableViewer;
	}
	
	/*****************************************************************************
	 * 
	 * Event handling methods
	 * 
	 *****************************************************************************/
	
	/**
	 * Set the input for the config type viewer based on the current selection in the file type viewer.
	 * If there is no selection in the viewer, then the config type viewer's input is set to null.  
	 */
	protected void handleFileTypeSelectionChanged() {
		String newInput = getFileTypeSelection();
		getConfigTypeTableViewer().setInput(newInput);
	}
	
	/**
	 * Set the enabled state of the 'default' button based on the current selection in the 
	 * config type table viewer.
	 */
	protected void handleConfigTypeSelectionChanged() {
		ILaunchConfigurationType configType = getConfigTypeSelection();
		if (configType == null) {
			getDefaultButton().setEnabled(false);
		} else {
			getDefaultButton().setEnabled(true);			
		}
	}
	
	/**
	 * Set the currently selected config type in the config type viewer to be the default.
	 */
	protected void handleDefaultButtonSelected() {
		String fileType = getFileTypeSelection();
		ILaunchConfigurationType configType = getConfigTypeSelection();
		getDefaultConfigsMap().put(fileType, configType);
		getConfigTypeTableViewer().refresh();
	}
	
	/**
	 * Convenience method to return the first selected element in the file type viewer
	 */
	protected String getFileTypeSelection() {
		IStructuredSelection selection = (IStructuredSelection) getFileTypeTableViewer().getSelection();
		return (String) selection.getFirstElement();		
	}
	
	/**
	 * Convenience method to return the first selected element in the config type viewer
	 */
	protected ILaunchConfigurationType getConfigTypeSelection() {
		IStructuredSelection selection = (IStructuredSelection) getConfigTypeTableViewer().getSelection();
		return (ILaunchConfigurationType) selection.getFirstElement();		
	}
	
	/**
	 * @see IWorkbenchPreferencePage
	 */
	public void init(IWorkbench aWorkbench){
		readDefaultLaunchConfigs();
		noDefaultAndApplyButton();
	}

	/**
	 * @see IPreferencePage#performOk()
	 */
	public boolean performOk() {
		saveDefaultLaunchConfigs();
		return true;
	}
	
	/**
	 * Populate a local copy of the file extension-->default launch configs mapping from the launch manager.
	 */
	protected void readDefaultLaunchConfigs() {
		ILaunchManager launchManager = getLaunchManager();
		String[] allFileExtensions = launchManager.getAllRegisteredFileExtensions();
		setDefaultConfigsMap(new HashMap(allFileExtensions.length));
		for (int i = 0; i < allFileExtensions.length; i++) {
			String fileExtension = allFileExtensions[i];
			ILaunchConfigurationType configType = launchManager.getDefaultLaunchConfigurationType(fileExtension);
			getDefaultConfigsMap().put(fileExtension, configType);
		}
	}
	
	/**
	 * Save the current mapping of file extensions to default launch configs into the launch manager.
	 */
	protected void saveDefaultLaunchConfigs() {
		ILaunchManager launchManager = getLaunchManager();
		Iterator iterator = getDefaultConfigsMap().keySet().iterator();
		while (iterator.hasNext()) {
			String fileExtension = (String) iterator.next();
			ILaunchConfigurationType configType = (ILaunchConfigurationType) getDefaultConfigsMap().get(fileExtension);
			launchManager.setDefaultLaunchConfigurationType(fileExtension, configType.getIdentifier());
		}
	}
	
	/**
	 * Convenience method to retrieve the launch mananger
	 */	
	private ILaunchManager getLaunchManager() {
		return DebugPlugin.getDefault().getLaunchManager();
	}

}