/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.0 (the "License").
    * You may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: ComboBoxTableCreator.java
   * Created: 2009-03-17
   * Author: elmo, jjarzabe, bmilos
   * $Id$
   */
  
  package pl.edu.agh.cast.importer.wizard.utils;
  
  import java.util.LinkedList;
  import java.util.List;
  
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.custom.CCombo;
  import org.eclipse.swt.custom.TableEditor;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  import org.eclipse.swt.widgets.Button;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Table;
  import org.eclipse.swt.widgets.TableColumn;
  import org.eclipse.swt.widgets.TableItem;
  
  import pl.edu.agh.cast.importer.base.data.RawDataRow;
  import pl.edu.agh.cast.importer.base.data.RawTabularData;
  import pl.edu.agh.cast.importer.base.parser.analyzer.IAnalyzer;
  import pl.edu.agh.cast.importer.base.util.DataTypeInfo;
  import pl.edu.agh.cast.importer.wizard.dialog.analyzer.AbstractDataTypeConfigDialog;
  import pl.edu.agh.cast.importer.wizard.page.AnalyzersSelectionPage;
  import pl.edu.agh.cast.importer.wizard.util.Messages;
  
  /**
   * SWT table creator, which creates tables with comboboxes as labels and configuration buttons above.
   * 
   * @author AGH CAST Team
   */
  public class ComboBoxTableCreator {
  
  	private static final int MAX_ROWS_TO_DISPLAY = 50;
  
  	private static final int VISIBLE_ITEMS_COUNT = 10;
  
  	private static final String EMPTY_STRING = ""; //$NON-NLS-1$
  
  	private AnalyzersSelectionPage mediator;
  
  	private RawTabularData data;
  
  	private Table table;
  
  	private Button[] configButtons;
  
  	private CCombo[] combos;
  
  	private DataTypeInfo[] selectedDataTypes;
  
  	/**
  	 * The default constructor.
  	 * 
  	 * @param mediator
  	 *            the mediating wizard page
  	 */
  	public ComboBoxTableCreator(AnalyzersSelectionPage mediator) {
  		this.mediator = mediator;
  	}
  
  	/**
  	 * Creates table basing on column names and tokenized raw tabular data.
  	 * 
  	 * @param container
  	 *            the table container
  	 * @param comboItems
  	 *            the combobox items
  	 * @param comboData
  	 *            the combobox data
  	 * @param rawTabData
  	 *            the data to be inserted into the table
  	 */
  	public void createTable(Composite container, String[] comboItems, Object[] comboData, RawTabularData rawTabData) {
  		if (table != null) {
  			table.dispose();
  		}
  		table = new Table(container, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
  		table.setHeaderVisible(false);
  		table.setLinesVisible(true);
  
  		if (rawTabData == null) {
  			return;
  		}
 		this.data = rawTabData;
 		this.selectedDataTypes = new DataTypeInfo[data.getColumnsCount()];
 
 		prepareTableColumns(comboItems);
 
 		TableItem tableItem = new TableItem(table, SWT.NONE);
 		makeFirstTableRowAsConfigButtons(tableItem);
 
 		TableItem tableItem2 = new TableItem(table, SWT.NONE);
 		makeTableColumnsHeadersAsComboBoxes(comboItems, comboData, tableItem2);
 
 		int size = Math.min(MAX_ROWS_TO_DISPLAY, data.size());
 		fillTableRows(tableItem2, size);
 	}
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------HELPER METHODS------------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Prepares the table columns.
 	 */
 	private void prepareTableColumns(String[] comboItems) {
 		for (int columnIndex = 0; columnIndex < data.getColumnsCount(); columnIndex++) {
 			TableColumn tableColumn = new TableColumn(table, SWT.NONE);
 			tableColumn.setText(comboItems[0]);
 			tableColumn.pack();
 			tableColumn.setWidth(150);
 		}
 	}
 
 	/**
 	 * Makes columns headers as comboboxes.
 	 */
 	private void makeFirstTableRowAsConfigButtons(TableItem tableItem) {
 		configButtons = new Button[data.getColumnsCount()];
 		for (int columnIndex = 0; columnIndex < data.getColumnsCount(); columnIndex++) {
 			TableEditor editor = new TableEditor(table);
 			Button configBtn = new Button(table, SWT.PUSH);
 			configButtons[columnIndex] = configBtn;
 			configBtn.pack();
 
 			final int columnIndexCp = columnIndex; // final variable for anonymous access
 			configBtn.addSelectionListener(new SelectionAdapter() {
 				@Override
 				public void widgetSelected(SelectionEvent event) {
 					handleConfigButtonSelection(columnIndexCp);
 				}
 
 			});
 			editor.grabHorizontal = true;
 
 			configBtn.setText(Messages.ComboBoxTableCreator_ConfigureBtnLabel);
 			configBtn.setEnabled(false);
 			editor.minimumWidth = configBtn.getSize().x;
 			editor.minimumHeight = table.getItemHeight() + table.getBorderWidth();
 			editor.horizontalAlignment = SWT.FILL;
 			editor.verticalAlignment = SWT.FILL;
 			editor.grabVertical = true;
 			editor.grabHorizontal = true;
 			editor.setEditor(configBtn, tableItem, columnIndex);
 		}
 	}
 
 	/**
 	 * Makes columns headers as comboboxes.
 	 */
 	private void makeTableColumnsHeadersAsComboBoxes(String[] comboItems, Object[] comboData, TableItem tableItem) {
 		combos = new CCombo[data.getColumnsCount()];
 		// comboBox.itemsCount = columnsLabels.count + 1 (+ 'ignore')
 		for (int columnIndex = 0; columnIndex < data.getColumnsCount(); columnIndex++) {
 			TableEditor editor = new TableEditor(table);
 			CCombo combo = new CCombo(table, SWT.CHECK | SWT.READ_ONLY | SWT.BORDER);
 			combos[columnIndex] = combo;
 			combo.pack();
 
 			final int columnIndexCp = columnIndex; // final variable for anonymous access
 			combo.addSelectionListener(new SelectionAdapter() {
 				@Override
 				public void widgetSelected(SelectionEvent event) {
 					CCombo selectedCombo = (CCombo)event.getSource();
 					int selectedComboIndex = selectedCombo.getSelectionIndex();
 					DataTypeInfo selectedDataType = null;
 
 					if (selectedComboIndex != 0) {
 						// selectedComboIndex is decreased by 1, because the first position in the combo is taken up by
 						// the 'ignore' entry
 						selectedDataType = ((DataTypeInfo[])selectedCombo.getData())[selectedComboIndex - 1];
 					}
 
 					handleComboSelection(columnIndexCp, selectedDataType);
 				}
 
 			});
 			editor.grabHorizontal = true;
 
 			combo.setItems(comboItems);
 			combo.setData(comboData);
 			combo.add(Messages.ComboBoxTableCreator_Ignored, 0);
 			combo.select(0);
 			combo.setVisibleItemCount(VISIBLE_ITEMS_COUNT);
 
 			editor.minimumWidth = combo.getSize().x;
 			editor.minimumHeight = combo.getSize().y;
 			editor.horizontalAlignment = SWT.FILL;
 			editor.verticalAlignment = SWT.FILL;
 			editor.grabVertical = true;
 			editor.grabHorizontal = true;
 			editor.setEditor(combo, tableItem, columnIndex);
 		}
 	}
 
 	/**
 	 * Fills table rows to the pointed size.
 	 */
 	private void fillTableRows(TableItem tableItem, int size) {
 		for (int rowsIndex = 0; rowsIndex < size; rowsIndex++) {
 			final TableItem tabItem = new TableItem(table, SWT.NONE);
 
 			for (int columnIndex = 0; columnIndex < data.getColumnsCount(); columnIndex++) {
 				String valueToSet = null;
 				RawDataRow row = data.get(rowsIndex);
 				if (columnIndex < row.size()) {
 					valueToSet = row.get(columnIndex);
 				}
 				if (valueToSet == null) {
 					valueToSet = EMPTY_STRING;
 				}
 				tabItem.setText(columnIndex, valueToSet);
 			}
 		}
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------ACTION METHODS------------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Selects event for prepared combobox.
 	 * 
 	 * @param columnIndex
 	 *            the index of the data column
 	 * @param dataType
 	 *            the selected data type
 	 */
 	private void handleComboSelection(int columnIndex, DataTypeInfo dataType) {
 		if (dataType == null) {
 			selectedDataTypes[columnIndex] = null;
 			disableConfigButton(columnIndex);
 
 		} else {
 			selectedDataTypes[columnIndex] = new DataTypeInfo(dataType);
 			AbstractDataTypeConfigDialog dialog = mediator.getDataTypeConfigDialogInstance(dataType.getDataTypeId());
 			if (dialog != null) {
 				enableConfigButton(columnIndex);
 			} else {
 				disableConfigButton(columnIndex);
 			}
 		}
 
 		mediator.widgetModified();
 	}
 
 	private void handleConfigButtonSelection(int columnIndex) {
 		DataTypeInfo selectedDataType = selectedDataTypes[columnIndex];
 		if (selectedDataType != null) {
 			AbstractDataTypeConfigDialog dialog = mediator.getDataTypeConfigDialogInstance(selectedDataType
 			        .getDataTypeId());
 			if (dialog != null) {
 				dialog.setData(this, columnIndex, getSelectedAnalyzer(columnIndex));
 				dialog.open();
 			}
 		}
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------HELPER METHODS------------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Enables configuration button in column with the specified index.
 	 * 
 	 * @param columnIndex
 	 *            the column index
 	 */
 	public void enableConfigButton(int columnIndex) {
 		configButtons[columnIndex].setEnabled(true);
 	}
 
 	/**
 	 * Disables configuration button in column with the specified index.
 	 * 
 	 * @param columnIndex
 	 *            the column index
 	 */
 	public void disableConfigButton(int columnIndex) {
 		configButtons[columnIndex].setEnabled(false);
 	}
 
 	/**
 	 * Delegated method.
 	 * 
 	 * {@inheritDoc}
 	 * 
 	 * @see AnalyzersSelectionPage#widgetModified()
 	 */
 	public void widgetModified() {
 		mediator.widgetModified();
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------GETTERS AND SETTERS-----------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Delegate method.
 	 * 
 	 * {@inheritDoc}
 	 * 
 	 * @see RawTabularData#getDistinctTokensInColumn(int)
 	 */
 	public List<String> getDistinctTokensInColumn(int columnIndex) {
 		return data.getDistinctTokensInColumn(columnIndex);
 	}
 
 	/**
 	 * Retrieves the selected combobox data (analyzers).
 	 * 
 	 * @return selected combobox data
 	 */
 	public List<Object> getSelectedComboData() {
 		if (selectedDataTypes == null) {
 			return null;
 		}
 
 		List<Object> result = new LinkedList<Object>();
 		for (DataTypeInfo dataType : selectedDataTypes) {
 			if (dataType != null) {
 				result.add(dataType.getAnalyzer());
 			} else {
 				result.add(null);
 			}
 		}
 
 		return result;
 	}
 
 	/**
 	 * Retrieves the selected captions for tabular data columns.
 	 * 
 	 * @return selected column captions
 	 */
 	public List<String> getSelectedColumnCaptions() {
 		if (selectedDataTypes == null) {
 			return null;
 		}
 
 		List<String> captions = new LinkedList<String>();
 
 		for (DataTypeInfo dataType : selectedDataTypes) {
 			if (dataType != null) {
 				captions.add(dataType.getName());
 			}
 		}
 
 		return captions;
 	}
 
 	private IAnalyzer getSelectedAnalyzer(int columnIndex) {
 		if (selectedDataTypes == null) {
 			return null;
 		}
 
 		DataTypeInfo dataType = selectedDataTypes[columnIndex];
 
 		return dataType.getAnalyzer();
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 }