package net.sourceforge.phpdt.internal.debug.ui.launcher;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.sourceforge.phpdt.core.JavaCore;
import net.sourceforge.phpdt.internal.core.JavaProject;
import net.sourceforge.phpdt.internal.debug.ui.PHPDebugUiMessages;
import net.sourceforge.phpdt.internal.debug.ui.PHPDebugUiPlugin;
import net.sourceforge.phpdt.internal.debug.ui.preferences.EditInterpreterDialog;
import net.sourceforge.phpdt.internal.debug.ui.preferences.EditPathMapDialog;
import net.sourceforge.phpdt.internal.launching.PHPInterpreter;
import net.sourceforge.phpdt.internal.launching.PHPLaunchConfigurationAttribute;
import net.sourceforge.phpdt.internal.launching.PHPRuntime;
import net.sourceforge.phpdt.internal.ui.PHPUiImages;
import net.sourceforge.phpeclipse.LoadPathEntry;
import net.sourceforge.phpeclipse.PHPeclipsePlugin;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.ui.AbstractLaunchConfigurationTab;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
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.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.internal.dialogs.ListContentProvider;

public class PHPEnvironmentTab extends AbstractLaunchConfigurationTab {
	protected ListViewer loadPathListViewer;
	protected java.util.List installedInterpretersWorkingCopy;
	protected Combo interpreterCombo;
	protected Button loadPathDefaultButton;
	protected Button fRemoteDebugCheckBox;
	protected Button fPathMapRemoveButton;
	protected Button fPathMapAddButton;
	protected Button fPathMapEditButton;
	protected Text fRemoteSourcePath;
	protected Table fRemoteDebugPathMapTable;
	protected TabFolder tabFolder;
	
	private class RemoteDebugTabListener extends SelectionAdapter implements ModifyListener {

		/* (non-Javadoc)
		 * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
		 */
		public void modifyText(ModifyEvent e) {
			updateLaunchConfigurationDialog();
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
		 */
		public void widgetSelected(SelectionEvent e) {
			Object source= e.getSource();
			if (source == fRemoteDebugPathMapTable) {
				setPathMapButtonsEnableState();
			} else if (source == fPathMapAddButton) {
				handlePathMapAddButtonSelected();
			} else if (source == fPathMapEditButton) {
				handlePathMapEditButtonSelected();
			} else if (source == fPathMapRemoveButton) {
				handlePathMapRemoveButtonSelected();
			} else if (source == fRemoteDebugCheckBox) {
				setRemoteTabEnableState();		
			} else {
				updateLaunchConfigurationDialog();;
		}
			
		}

	}
	
	private static final String EMPTY_STRING = "";	 //$NON-NLS-1$
	private RemoteDebugTabListener fListener= new RemoteDebugTabListener();
	
	private static final boolean DEFAULT_REMOTE_DEBUG= false;
	static String [] columnTitles	= { PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMapTableTitle.local"),
																		PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMapTableTitle.remote")
																	};
	public PHPEnvironmentTab() {
		super();
	}

	public void createControl(Composite parent) {
		Composite composite = createPageRoot(parent);

		tabFolder = new TabFolder(composite, SWT.NONE);
		GridData gridData = new GridData(GridData.FILL_BOTH);
		tabFolder.setLayoutData(gridData);

		addLoadPathTab(tabFolder);
		addInterpreterTab(tabFolder);
		addRemoteDebugTab(tabFolder);
	}
	
	protected void addRemoteDebugTab(TabFolder tabFolder)
	{
		Label label;
				
		TabItem remoteDebugTab = new TabItem(tabFolder, SWT.NONE, 0);
		remoteDebugTab.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.label"));
		
		Composite comp = new Composite(tabFolder, SWT.NONE);
		comp.setLayout(new GridLayout());	
		remoteDebugTab.setControl(comp);		
		GridData gd;
		
		fRemoteDebugCheckBox = new Button(comp, SWT.CHECK);
		fRemoteDebugCheckBox.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.RemoteCheckBox.label"));
		fRemoteDebugCheckBox.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING));
		fRemoteDebugCheckBox.addSelectionListener(fListener);
		
		label = new Label(comp, SWT.NONE);
		label.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.RemoteSourcePath.label"));
		fRemoteSourcePath = new Text(comp, SWT.BORDER | SWT.SINGLE);
		gd = new GridData(GridData.FILL_HORIZONTAL);
		fRemoteSourcePath.setLayoutData(gd);		
		fRemoteSourcePath.addModifyListener(fListener);
		
		createVerticalSpacer(comp,1);
		
		Composite pathMapComp = new Composite(comp, SWT.NONE);
		gd = new GridData(GridData.FILL_BOTH);
		pathMapComp.setLayoutData(gd);
		GridLayout parametersLayout = new GridLayout();
		parametersLayout.numColumns = 2;
		parametersLayout.marginHeight = 0;
		parametersLayout.marginWidth = 0;
		pathMapComp.setLayout(parametersLayout);

		
		Label pathMapLabel = new Label(pathMapComp, SWT.NONE);
		pathMapLabel.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.label"));
		gd = new GridData();
		gd.horizontalSpan = 2;
		pathMapLabel.setLayoutData(gd);

		
		fRemoteDebugPathMapTable = new Table(pathMapComp, SWT.BORDER | SWT.MULTI);
		TableLayout tableLayout = new TableLayout();
		fRemoteDebugPathMapTable.setLayout(tableLayout);

		gd = new GridData(GridData.FILL_BOTH);
		fRemoteDebugPathMapTable.setLayoutData(gd);
		TableColumn column1 = new TableColumn(this.fRemoteDebugPathMapTable, SWT.NONE);
		column1.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.Table.Title.local")); //$NON-NLS-1$
		TableColumn column2 = new TableColumn(this.fRemoteDebugPathMapTable, SWT.NONE);
		column2.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.Table.Title.remote"));		 //$NON-NLS-1$
		tableLayout.addColumnData(new ColumnWeightData(100));
		tableLayout.addColumnData(new ColumnWeightData(100));
		fRemoteDebugPathMapTable.setHeaderVisible(true);
		fRemoteDebugPathMapTable.setLinesVisible(true);
		fRemoteDebugPathMapTable.addSelectionListener(fListener);
		fRemoteDebugPathMapTable.addMouseListener(new MouseAdapter() {
					public void mouseDoubleClick(MouseEvent e) {
						setPathMapButtonsEnableState();
						if (fPathMapEditButton.isEnabled()) {
							handlePathMapEditButtonSelected();
						}
					}
				});		
//		fRemoteDebugPathMapTable.setEnabled(false);		
	
		Composite envButtonComp = new Composite(pathMapComp, SWT.NONE);
		GridLayout envButtonLayout = new GridLayout();
		envButtonLayout.marginHeight = 0;
		envButtonLayout.marginWidth = 0;
		envButtonComp.setLayout(envButtonLayout);
		gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING | GridData.HORIZONTAL_ALIGN_FILL);
		envButtonComp.setLayoutData(gd);

		
		fPathMapAddButton = createPushButton(envButtonComp ,PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.Button.Add.label"), null); //$NON-NLS-1$
		fPathMapAddButton.addSelectionListener(fListener);
//		fPathMapAddButton.setEnabled(false);
		
		fPathMapEditButton = createPushButton(envButtonComp,PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.Button.Edit.label"), null); //$NON-NLS-1$
		fPathMapEditButton.addSelectionListener(fListener);
//		fPathMapEditButton.setEnabled(false);
		
		fPathMapRemoveButton = createPushButton(envButtonComp,PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.remoteDebugTab.PathMap.Button.Remove.label"), null); //$NON-NLS-1$
		fPathMapRemoveButton.addSelectionListener(fListener);
//		fPathMapRemoveButton.setEnabled(false);
	

	}
	
	void handlePathMapAddButtonSelected()
	{
		EditPathMapDialog dialog=
			new EditPathMapDialog(
				getShell(),
				"Edit File Map",
				new String[] {EMPTY_STRING, EMPTY_STRING});
		openNewPathMapDialog(dialog,null);		
//		dialog.create();
//		if (dialog.open()==EditPathMapDialog.OK)
//		{
//			TableItem item = new TableItem (fRemoteDebugPathMapTable, SWT.NONE);
//			item.setText(0,dialog.getLocalPath());
//			item.setText(1,dialog.getRemotePath());
//			updateLaunchConfigurationDialog();
//		}
//		updateLaunchConfigurationDialog();
		setPathMapButtonsEnableState();
	}
	
	void handlePathMapRemoveButtonSelected()
	{
		int[] selectedIndices = this.fRemoteDebugPathMapTable.getSelectionIndices();
		this.fRemoteDebugPathMapTable.remove(selectedIndices);
		setPathMapButtonsEnableState();
		updateLaunchConfigurationDialog();
	}
	
	void handlePathMapEditButtonSelected()
	{
		TableItem selectedItem = this.fRemoteDebugPathMapTable.getSelection()[0];
			String local = selectedItem.getText(0);
			String remote = selectedItem.getText(1);
		EditPathMapDialog dialog=
			new EditPathMapDialog(
				getShell(),
				"Edit File Map",
				new String[] {local, remote});
			openNewPathMapDialog(dialog, selectedItem);		
	}


	/**
	 * Set the enabled state of whole tab.
	 */
	private void setRemoteTabEnableState() {
		boolean state=fRemoteDebugCheckBox.getSelection();
		fRemoteSourcePath.setEnabled(state);
		 		
		fRemoteDebugPathMapTable.setEnabled(state);
		if (!state)
		{
			fPathMapEditButton.setEnabled(false);
			fPathMapRemoveButton.setEnabled(false);		
			fPathMapAddButton.setEnabled(false);
		} else {
			setPathMapButtonsEnableState();
		}

		updateLaunchConfigurationDialog();
	}
	
	
	/**
	 * Set the enabled state of the three environment variable-related buttons based on the
	 * selection in the PathMapTable widget.
	 */
	private void setPathMapButtonsEnableState() {
//	just do nothing for now
//
		if(fRemoteDebugCheckBox.getSelection())
		{
			int selectCount = this.fRemoteDebugPathMapTable.getSelectionIndices().length;
			if (selectCount < 1) {
				fPathMapEditButton.setEnabled(false);
				fPathMapRemoveButton.setEnabled(false);
			} else {
				fPathMapRemoveButton.setEnabled(true);
				if (selectCount == 1) {
					fPathMapEditButton.setEnabled(true);
				} else {
					fPathMapEditButton.setEnabled(false);
				}
			}		
			fPathMapAddButton.setEnabled(true);
		}
	}
	
	/**
	 * Show the specified dialog and update the pathMapTable table based on its results.
	 * 
	 * @param updateItem the item to update, or <code>null</code> if
	 *  adding a new item
	 */
	private void openNewPathMapDialog(EditPathMapDialog dialog, TableItem updateItem) {
		if (dialog.open() != EditPathMapDialog.OK) {
			return;
		}
		String[] pathPair = dialog.getPathPair();
		TableItem tableItem = updateItem;
		if (tableItem == null) {
			tableItem = getTableItemForName(pathPair[0]);
			if (tableItem == null) {
				tableItem = new TableItem(this.fRemoteDebugPathMapTable, SWT.NONE);
			}
		}
		tableItem.setText(pathPair);
		this.fRemoteDebugPathMapTable.setSelection(new TableItem[] {tableItem});
		updateLaunchConfigurationDialog();	
	}
	
	/**
	 * Helper method that indicates whether the specified parameter name is already present 
	 * in the parameters table.
	 */
	private TableItem getTableItemForName(String candidateName) {
		TableItem[] items = this.fRemoteDebugPathMapTable.getItems();
		for (int i = 0; i < items.length; i++) {
			String name = items[i].getText(0);
			if (name.equals(candidateName)) {
				return items[i];
			}
		}
		return null;
	}	
	
	

	protected void addLoadPathTab(TabFolder tabFolder) {
		Composite loadPathComposite = new Composite(tabFolder, SWT.NONE);
		loadPathComposite.setLayout(new GridLayout());

		loadPathListViewer = new ListViewer(loadPathComposite, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL | SWT.H_SCROLL);
		loadPathListViewer.setContentProvider(new ListContentProvider());
		loadPathListViewer.setLabelProvider(new LoadPathEntryLabelProvider());
		loadPathListViewer.getList().setLayoutData(new GridData(GridData.FILL_BOTH));

		TabItem loadPathTab = new TabItem(tabFolder, SWT.NONE, 0);
		loadPathTab.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.loadPathTab.label"));
		loadPathTab.setControl(loadPathComposite);
		loadPathTab.setData(loadPathListViewer);

		loadPathDefaultButton = new Button(loadPathComposite, SWT.CHECK);
		loadPathDefaultButton.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.loadPathDefaultButton.label"));
		loadPathDefaultButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING));
		loadPathDefaultButton.addSelectionListener(getLoadPathDefaultButtonSelectionListener());
		
		loadPathDefaultButton.setEnabled(false); //for now, until the load path is customizable on the configuration
	}

	protected SelectionListener getLoadPathSelectionListener() {
		return new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				System.out.println("Loadpath list selection occurred: " + e.getSource());
			}
		};
	}
	
	

	protected SelectionListener getLoadPathDefaultButtonSelectionListener() {
		return new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				setUseLoadPathDefaults(((Button) e.getSource()).getSelection());
			}
		};
	}

	protected void addInterpreterTab(TabFolder tabFolder) {
		Composite interpreterComposite = new Composite(tabFolder, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		layout.marginHeight = 0;
		layout.marginWidth = 0;
		interpreterComposite.setLayout(layout);
		interpreterComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		createVerticalSpacer(interpreterComposite, 2);

		interpreterCombo = new Combo(interpreterComposite, SWT.READ_ONLY);
		interpreterCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		initializeInterpreterCombo(interpreterCombo);
		interpreterCombo.addModifyListener(getInterpreterComboModifyListener());

		Button interpreterAddButton = new Button(interpreterComposite, SWT.PUSH);
		interpreterAddButton.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.interpreterAddButton.label"));
		interpreterAddButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent evt) {
				PHPInterpreter newInterpreter = new PHPInterpreter(null, null);
				EditInterpreterDialog editor = new EditInterpreterDialog(getShell(), PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.editInterpreterDialog.title"));
				editor.create();
				editor.setInterpreterToEdit(newInterpreter);
				if (EditInterpreterDialog.OK == editor.open()) {
					PHPRuntime.getDefault().addInstalledInterpreter(newInterpreter);
					interpreterCombo.add(newInterpreter.getName());
					interpreterCombo.select(interpreterCombo.indexOf(newInterpreter.getName()));
				}
			}
		});

		TabItem interpreterTab = new TabItem(tabFolder, SWT.NONE);
		interpreterTab.setText(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.interpreterTab.label"));
		interpreterTab.setControl(interpreterComposite);
	}

	protected ModifyListener getInterpreterComboModifyListener() {
		return new ModifyListener() {
			public void modifyText(ModifyEvent evt) {
				updateLaunchConfigurationDialog();
			}
		};
	}

	protected void createVerticalSpacer(Composite comp, int colSpan) {
		Label label = new Label(comp, SWT.NONE);
		GridData gd = new GridData();
		gd.horizontalSpan = colSpan;
		label.setLayoutData(gd);
	}

	public void setDefaults(ILaunchConfigurationWorkingCopy configuration) {
	}

	public void initializeFrom(ILaunchConfiguration configuration) {
		initializeLoadPath(configuration);
		initializeInterpreterSelection(configuration);
		initializeRemoteDebug(configuration);
	}
	
	protected void initializeRemoteDebug(ILaunchConfiguration configuration)
	{
		String s[];
		int startIdx =0;
		int idx;
		try{
			fRemoteDebugCheckBox.setSelection(
		  		configuration.getAttribute(PHPLaunchConfigurationAttribute.REMOTE_DEBUG,DEFAULT_REMOTE_DEBUG));
		} catch(CoreException ce) {
			fRemoteDebugCheckBox.setSelection(DEFAULT_REMOTE_DEBUG);
		}
		setRemoteTabEnableState();
		try{
			fRemoteSourcePath.setText(
					configuration.getAttribute(PHPLaunchConfigurationAttribute.REMOTE_PATH,""));
		} catch(CoreException ce) {
			fRemoteSourcePath.setText("");
		}
			
		updatePathMapFromConfig(configuration);
		 
	}
	
	private void updatePathMapFromConfig(ILaunchConfiguration config) {
		Map envVars = null;
		try {
			if (config != null) {
				envVars = config.getAttribute(PHPLaunchConfigurationAttribute.FILE_MAP, (Map)null);
			}
			updatePathMapTable(envVars, this.fRemoteDebugPathMapTable);
			setPathMapButtonsEnableState();
		} catch (CoreException ce) {
			log(ce);
		}
	}

	private void updatePathMapTable(Map map, Table tableWidget) {
		tableWidget.removeAll();
		if (map == null) {
			return;
		}
		Iterator iterator = map.keySet().iterator();
		while (iterator.hasNext()) {
			String key = (String) iterator.next();
			String value = (String) map.get(key);
			TableItem tableItem = new TableItem(tableWidget, SWT.NONE);
			tableItem.setText(new String[] {key, value});			
		}
	}

	protected void initializeLoadPath(ILaunchConfiguration configuration) {
		boolean useDefaultLoadPath = true;
		try {
			useDefaultLoadPath = configuration.getAttribute(PHPLaunchConfigurationAttribute.USE_DEFAULT_LOAD_PATH, true);
			setUseLoadPathDefaults(useDefaultLoadPath);
			if (useDefaultLoadPath) {
				String projectName = configuration.getAttribute(PHPLaunchConfigurationAttribute.PROJECT_NAME, "");
				if (projectName != "") {
				    IProject aProject = PHPeclipsePlugin.getWorkspace().getRoot().getProject(projectName);
					if ((aProject != null) && JavaCore.isPHPProject(aProject)) {
					      JavaProject thePHPProject = new JavaProject();
					      thePHPProject.setProject(aProject);						
						List loadPathEntries = thePHPProject.getLoadPathEntries();
						loadPathListViewer.setInput(loadPathEntries);
					}
				}
			}
		} catch (CoreException e) {
			log(e);
		}
	}

	protected void setUseLoadPathDefaults(boolean useDefaults) {
		loadPathListViewer.getList().setEnabled(!useDefaults);
		loadPathDefaultButton.setSelection(useDefaults);
	}

	protected void initializeInterpreterSelection(ILaunchConfiguration configuration) {
		String interpreterName = null;
		try {
			interpreterName = configuration.getAttribute(PHPLaunchConfigurationAttribute.SELECTED_INTERPRETER, "");
		} catch (CoreException e) {
			log(e);
		}
		if (interpreterName != null && !interpreterName.equals(""))
			interpreterCombo.select(interpreterCombo.indexOf(interpreterName));
	}

	protected void initializeInterpreterCombo(Combo interpreterCombo) {
		installedInterpretersWorkingCopy = new ArrayList();
		installedInterpretersWorkingCopy.addAll(PHPRuntime.getDefault().getInstalledInterpreters());

		String[] interpreterNames = new String[installedInterpretersWorkingCopy.size()];
		for (int interpreterIndex = 0; interpreterIndex < installedInterpretersWorkingCopy.size(); interpreterIndex++) {
			PHPInterpreter interpreter = (PHPInterpreter) installedInterpretersWorkingCopy.get(interpreterIndex);
			interpreterNames[interpreterIndex] = interpreter.getName();
		}
		interpreterCombo.setItems(interpreterNames);

		PHPInterpreter selectedInterpreter = PHPRuntime.getDefault().getSelectedInterpreter();
		if (selectedInterpreter != null)
			interpreterCombo.select(interpreterCombo.indexOf(selectedInterpreter.getName()));
	}

	public void performApply(ILaunchConfigurationWorkingCopy configuration) {
		int selectionIndex = interpreterCombo.getSelectionIndex();
		if (selectionIndex >= 0)
			configuration.setAttribute(PHPLaunchConfigurationAttribute.SELECTED_INTERPRETER, interpreterCombo.getItem(selectionIndex));

		configuration.setAttribute(PHPLaunchConfigurationAttribute.USE_DEFAULT_LOAD_PATH, loadPathDefaultButton.getSelection());

		if (!loadPathDefaultButton.getSelection()) {
			List loadPathEntries = (List) loadPathListViewer.getInput();
			List loadPathStrings = new ArrayList();
			for (Iterator iterator = loadPathEntries.iterator(); iterator.hasNext();) {
				LoadPathEntry entry = (LoadPathEntry) iterator.next();
				loadPathStrings.add(entry.getPath().toString());
			}
			configuration.setAttribute(PHPLaunchConfigurationAttribute.CUSTOM_LOAD_PATH, loadPathStrings);
		}
		
		configuration.setAttribute(PHPLaunchConfigurationAttribute.REMOTE_DEBUG, fRemoteDebugCheckBox.getSelection());
		configuration.setAttribute(PHPLaunchConfigurationAttribute.FILE_MAP, getMapFromPathMapTable());		
		configuration.setAttribute(PHPLaunchConfigurationAttribute.REMOTE_PATH, fRemoteSourcePath.getText());
	}

	protected Composite createPageRoot(Composite parent) {
		Composite composite = new Composite(parent, SWT.NULL);
		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		composite.setLayout(layout);
		createVerticalSpacer(composite, 2);
		setControl(composite);

		return composite;
	}
	
	private Map getMapFromPathMapTable() {
		TableItem[] items = fRemoteDebugPathMapTable.getItems();
		if (items.length == 0) {
			return null;
		}
		Map map = new HashMap(items.length);
		for (int i = 0; i < items.length; i++) {
			TableItem item = items[i];
			String key = item.getText(0);
			String value = item.getText(1);
			map.put(key, value);
		}		
		return map;
	}

	public String getName() {
		return PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.name");
	}

	public boolean isValid(ILaunchConfiguration launchConfig) {
		try {
			String selectedInterpreter = launchConfig.getAttribute(PHPLaunchConfigurationAttribute.SELECTED_INTERPRETER, "");
			if (selectedInterpreter.length() == 0) {
				setErrorMessage(PHPDebugUiMessages.getString("LaunchConfigurationTab.PHPEnvironment.interpreter_not_selected_error_message"));
				return false;
			}
		} catch (CoreException e) {
			log(e);
		}
		
		setErrorMessage(null);
		return true;
	}
	
	protected void log(Throwable t) {
		PHPDebugUiPlugin.log(t);
	}

	public Image getImage() {
		return PHPUiImages.get(PHPUiImages.IMG_CTOOLS_PHP);
	}

}