package org.gcube.portlets.user.databasesmanager.client.panels;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.gcube.portlets.user.databasesmanager.client.GWTdbManagerServiceAsync;
import org.gcube.portlets.user.databasesmanager.client.datamodel.FileModel;
import org.gcube.portlets.user.databasesmanager.client.datamodel.Result;
import org.gcube.portlets.user.databasesmanager.client.datamodel.SamplingResultWithFileFromServlet;
import org.gcube.portlets.user.databasesmanager.client.datamodel.Row;
import org.gcube.portlets.user.databasesmanager.client.datamodel.SubmitQueryData;
import org.gcube.portlets.user.databasesmanager.client.datamodel.SubmitQueryResultWithFileFromServlet;
import org.gcube.portlets.user.databasesmanager.client.events.LoadTablesEvent;
import org.gcube.portlets.user.databasesmanager.client.events.RandomSamplingEvent;
import org.gcube.portlets.user.databasesmanager.client.events.SamplingEvent;
import org.gcube.portlets.user.databasesmanager.client.events.SelectedItemEvent;
import org.gcube.portlets.user.databasesmanager.client.events.SelectedTableEvent;
import org.gcube.portlets.user.databasesmanager.client.events.ShowCreateTableEvent;
import org.gcube.portlets.user.databasesmanager.client.events.SmartSamplingEvent;
import org.gcube.portlets.user.databasesmanager.client.events.SubmitQueryEvent;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.LoadTablesEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.RandomSamplingEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SamplingEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SelectedItemEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.ShowCreateTableEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SmartSamplingEventHandler;
import org.gcube.portlets.user.databasesmanager.client.events.interfaces.SubmitQueryEventHandler;
import org.gcube.portlets.user.databasesmanager.client.resources.Images;
import org.gcube.portlets.user.databasesmanager.client.toolbar.GxtToolbarFunctionality;
import org.gcube.portlets.user.databasesmanager.shared.ConstantsPortlet;
import org.gcube.portlets.user.databasesmanager.shared.SessionExpiredException;
import org.gcube.portlets.widgets.sessionchecker.client.CheckSession;

import com.extjs.gxt.ui.client.Style;
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.Style.SelectionMode;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid.ClicksToEdit;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.RowData;
import com.extjs.gxt.ui.client.widget.layout.RowLayout;
import com.extjs.gxt.ui.client.widget.toolbar.PagingToolBar;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.HTML;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.PagingLoadConfig;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.GridEvent;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.event.WindowEvent;

//class that represents the container of all components
public class GxtBorderLayoutPanel extends ContentPanel {

	/* Create Root Logger */
	private static Logger rootLogger = Logger.getLogger("GxtBorderLayoutPanel");
	private ContentPanel north;
	private ContentPanel west;
	private LayoutContainer center;
	private ContentPanel centerUpper;
	private ContentPanel centerBottom;
	private GxtTreePanel treePanel;
	// top toolbar that contains the buttons
	private GxtToolbarFunctionality toolbar;
	// private List<String> listAttributes;
	// bus to manage events
	private HandlerManager eventBus = null;
	// RPC service
	private GWTdbManagerServiceAsync RPCservice = null;
	// dialog used to display the tables list
	private Dialog tablesLoaded = null;
	// to keep track of selected table in the tables list
	private String selectedTable = "";
	private String currentselectedTable = "";
	private FileModel table = new FileModel("");
	// variables to perform the table search
	private String keyword = "";
	private boolean startSearchTable = false;
	// toolbar for table search functionality
	private ToolBar toolBarTop = null;

	public GxtBorderLayoutPanel(HandlerManager eBus,
			GWTdbManagerServiceAsync service) throws Exception {
		eventBus = eBus;
		RPCservice = service;
		north = new ContentPanel();
		west = new ContentPanel();
		center = new LayoutContainer();
		treePanel = new GxtTreePanel(eventBus, service);
		// toolbar = new GxtToolbarFunctionality(eventBus);
		toolbar = new GxtToolbarFunctionality(eventBus, RPCservice);
		this.setHeaderVisible(false); // hide the header of the panel

		initLayout();
		createLayouts();
		addHandler();
	}

	private void initLayout() {
//		north.setLayout(new FitLayout());
		north.setHeaderVisible(false); // hide the header of the north panel
		north.setTopComponent(toolbar.getToolBar());
		north.add(toolbar.getToolBar());
		west.setLayout(new FitLayout());
		west.setHeading("Databases Resources");
		west.add(treePanel);
		west.setScrollMode(Scroll.AUTO);
		center.setLayout(new BorderLayout());
	}

	public void createLayouts() {
		// Border layout for the external container
		final BorderLayout borderLayoutNordWest = new BorderLayout();
		setLayout(borderLayoutNordWest);

		// NORD
		BorderLayoutData northData = new BorderLayoutData(LayoutRegion.NORTH,
				25, 25, 70);
		northData.setSplit(false); // Split bar between regions
		// northData.setFloatable(true);
		// northData.setCollapsible(true);
		// northData.setHideCollapseTool(false);
		// northData.setSplit(true);
		northData.setMargins(new Margins(0, 0, 1, 0));

		// WEST
		BorderLayoutData westData = new BorderLayoutData(LayoutRegion.WEST,
				330, 330, 400);
		westData.setSplit(true);
		westData.setCollapsible(true);
		westData.setMargins(new Margins(0, 1, 0, 0));

		// CENTER
		BorderLayoutData centerData = new BorderLayoutData(LayoutRegion.CENTER);
		centerData.setMargins(new Margins(0));
		// center.setHeading("Information");
		centerData.setSplit(true);
		centerData.setCollapsible(true);

		// CENTER UPPER
		centerUpper = new ContentPanel();
		centerUpper.setLayout(new FitLayout());
		centerUpper.setHeading("Database Information");
		centerUpper.setScrollMode(Scroll.NONE);
		// centerUpper.setBottomComponent(toolBar);
		// toolBar.hide();
		BorderLayoutData centerUpperData = new BorderLayoutData(
				LayoutRegion.NORTH, 250, 100, 250);
		centerUpperData.setSplit(true); // Split bar between regions
		// northData.setFloatable(true);
		centerUpperData.setCollapsible(false);
		// northData.setHideCollapseTool(false);
		// northData.setSplit(true);
		centerUpperData.setMargins(new Margins(0, 0, 1, 0));

		// CENTER BOTTOM
		centerBottom = new ContentPanel();
		centerBottom.setLayout(new FitLayout());
		centerBottom.setHeading("Information Details");
		centerBottom.setScrollMode(Scroll.NONE);
		BorderLayoutData centerBottomData = new BorderLayoutData(
				LayoutRegion.CENTER);
		centerBottomData.setSplit(true);
		centerBottomData.setCollapsible(false);
		centerBottomData.setMargins(new Margins(0));
		// centerBottomData.setMargins(new Margins(1, 0, 0, 0));

		// to add the central panels to the second container
		center.add(centerUpper, centerUpperData);
		center.add(centerBottom, centerBottomData);

		add(north, northData);
		add(west, westData);
		add(center, centerData);
		// add(east, eastData);
	}

	// to add handlers
	private void addHandler() {

		eventBus.addHandler(SelectedItemEvent.TYPE,
				new SelectedItemEventHandler() {
					public void onSelectedItem(
							SelectedItemEvent selectedItemEvent) {
						// force the clean of the content panel
						centerBottom.removeAll();
						centerBottom.layout(true);

						// to get the selected item with its depth
						List<FileModel> data = treePanel.getTreePanel()
								.getSelectionModel().getSelectedItems();
						FileModel selectedItem = data.get(0);
						int DepthSelectedItem = treePanel.getTreeStore()
								.getDepth(selectedItem);
						String text = selectedItem.getName();
						rootLogger.log(Level.INFO, "selected item: " + text);

						// disable table details and sampling buttons
						toolbar.disableButtonsOperationsOnTable();
						// enable appropriate buttons according the selected
						// item
						toolbar.enableButtonOnToolbar(DepthSelectedItem,
								selectedItem.isSchema(),
								selectedItem.getDatabaseType());

						// clean variable at each item selection event
						table = new FileModel("");

						// clean variable
						selectedTable = "";
						currentselectedTable = "";

						if (DepthSelectedItem != 3) {
							centerUpper.removeAll();
							centerUpper.layout(true);
						}
						if (DepthSelectedItem == 3) { // the item selected is a
							// database.

							// show database information in the panel
							// display information about the selected database
							displayDBInfo(data.get(0));
						}
					}
				});

		eventBus.addHandler(LoadTablesEvent.TYPE, new LoadTablesEventHandler() {
			@Override
			public void onLoadTables(LoadTablesEvent loadTablesEvent) {
				// load tables
				loadTables();
			}
		});

		eventBus.addHandler(SubmitQueryEvent.TYPE,
				new SubmitQueryEventHandler() {
					@Override
					public void onSubmitQuery(SubmitQueryEvent submitQueryEvent) {
						Integer dialogID = new Integer(submitQueryEvent
								.getDialogID());
						rootLogger.log(Level.INFO, "dialogID: " + dialogID);
						submitQuery(dialogID);
					}
				});

		eventBus.addHandler(SamplingEvent.TYPE, new SamplingEventHandler() {
			@Override
			public void onSampling(SamplingEvent samplingEvent) {
				sample();
			}
		});

		eventBus.addHandler(SmartSamplingEvent.TYPE,
				new SmartSamplingEventHandler() {
					@Override
					public void onSmartSampling(
							SmartSamplingEvent smartSamplingEvent) {
						smartSample();
					}
				});

		eventBus.addHandler(RandomSamplingEvent.TYPE,
				new RandomSamplingEventHandler() {
					@Override
					public void onRandomSampling(
							RandomSamplingEvent randomSamplingEvent) {
						randomSample();
					}
				});

		eventBus.addHandler(ShowCreateTableEvent.TYPE,
				new ShowCreateTableEventHandler() {
					@Override
					public void onShowCreateTable(
							ShowCreateTableEvent showCreateTableEvent) {
						// get the selected item in the tree
						List<FileModel> data = treePanel.getTreePanel()
								.getSelectionModel().getSelectedItems();

						// if the selected table is equal to the previous table
						// keep track that table details have been just
						// displayed
						if (!(table.getName().equals(currentselectedTable))) {
							table.setName(currentselectedTable);
							table.setTableDetailsDisplayed(false);
						}
						rootLogger.log(Level.INFO,
								"selected table: " + table.getName());
						// get table details
						getTableDetails(table);
					}
				});
	
//		eventBus.addHandler(RefreshDataEvent.TYPE,
//				new RefreshDataEventHandler() {
//					@Override
//					public void onRefreshData(RefreshDataEvent refreshDataEvent) {
//					}
//				});
	}

	// method to load the tables list
	private void loadTables() {
		// clean variable
		// selectedTable = null;

		// disable table details and sampling buttons
		// toolbar.disableButtonsOperationsOnTable();
		// clear the panel
		// centerBottom.removeAll();
		// centerBottom.layout(true);

		// get the selected item
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		FileModel element = data.get(0);
		// recover data inputs
		final LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
		// check if the table has an associated schema
		String resource = "";
		String database = "";
		String schema = "";

		final String elementType;

		if (element.isDatabase()) { // the selected item is a database
			rootLogger.log(Level.INFO, "selected element is a database ");
			database = element.getName();
			resource = treePanel.getTreeStore().getParent(element).getName();
			// add data
			dataInput.put("ResourceName", resource);
			dataInput.put("DatabaseName", database);
			dataInput.put("SchemaName", "");
			elementType = ConstantsPortlet.DATABASE;
		} else { // the selected item is a schema
			rootLogger.log(Level.INFO, "selected element is a schema ");
			FileModel db = treePanel.getTreeStore().getParent(element);
			database = db.getName();
			resource = treePanel.getTreeStore().getParent(db).getName();
			schema = element.getName();
			// add data
			dataInput.put("ResourceName", resource);
			dataInput.put("DatabaseName", database);
			dataInput.put("SchemaName", schema);
			elementType = ConstantsPortlet.SCHEMA;
		}

		// print check
		rootLogger.log(Level.INFO, "ResourceName: " + resource);
		rootLogger.log(Level.INFO, "DatabaseName: " + database);
		rootLogger.log(Level.INFO, "SchemaName: " + schema);

		// create RpcProxy object to use the load configuration
		RpcProxy<PagingLoadResult<Result>> proxy = new RpcProxy<PagingLoadResult<Result>>() {
			@Override
			protected void load(Object loadConfig,
					final AsyncCallback<PagingLoadResult<Result>> callback) {
				rootLogger.log(Level.SEVERE, "Start RPC - getTables");

				rootLogger.log(Level.INFO, "keyword rpc: " + keyword);
				rootLogger.log(Level.INFO, "Search Table rpc: "
						+ startSearchTable);
				// remote rpc
				RPCservice.LoadTables((PagingLoadConfig) loadConfig, dataInput,
						elementType, startSearchTable, keyword,
						new AsyncCallback<PagingLoadResult<Result>>() {
							@Override
							public void onFailure(Throwable caught) {
								rootLogger.log(Level.SEVERE,
										"FAILURE RPC LoadTables");

								if (caught instanceof SessionExpiredException) {
									rootLogger.log(Level.INFO,
											"Session expired");
									CheckSession.showLogoutDialog();
									return;
								}
								// caught.printStackTrace();
								callback.onFailure(caught);
								// hide the dialog
								tablesLoaded.hide();

								if (caught.getMessage().contains(
										"Result not available")) {
									MessageBox.alert("Warning ",
											"<br/>Message:"
													+ "no tables available",
											null);
								} else {
									MessageBox.alert("Error ", "<br/>Message:"
											+ caught.getMessage(), null);
								}
								if (keyword == null) {
									startSearchTable = false;
								}
							}

							@Override
							public void onSuccess(
									PagingLoadResult<Result> result) {
								rootLogger.log(Level.SEVERE,
										"SUCCESS RPC LoadTables");
								callback.onSuccess(result);

								if (keyword == null) {
									startSearchTable = false;
								}
								// enable toolbar in the dialog
								toolBarTop.enable();

								// if (result != null) {
								//
								// List<Result> data = result.getData();
								// if (data.size() == 0) {
								// MessageBox
								// .alert("Warning ",
								// "<br/>Message:"
								// + "no tables availables",
								// null);
								// return;
								// }
								// }

							}
						});
				// rootLogger.log(Level.SEVERE, "End RPC LoadTables");
			}
		};

		// loader to load page enabled set of data
		final PagingLoader<PagingLoadResult<Result>> loader = new BasePagingLoader<PagingLoadResult<Result>>(
				proxy);
		// loader.addListener(Loader.BeforeLoad, new Listener<LoadEvent>() {
		// public void handleEvent(LoadEvent be) {
		// BasePagingLoadConfig m = be.<BasePagingLoadConfig> getConfig();
		// m.set("start", m.get("offset"));
		// // m.set("ext", "js");
		// // m.set("lightWeight", true);
		// // m.set("sort", (m.get("sortField") == null) ? "" :
		// m.get("sortField"));
		// // m.set("dir", (m.get("sortDir") == null || (m.get("sortDir") !=
		// null && m.<SortDir> get("sortDir").equals(
		// // SortDir.NONE))) ? "" : m.get("sortDir"));
		// }
		// });
		// loader.setRemoteSort(true);

		// to create the listStore using the loader
		final ListStore<Result> result = new ListStore<Result>(loader);

		// bind the loader with a PagingToolBar.
		final PagingToolBar toolBar = new PagingToolBar(100);
		toolBar.bind(loader);

		// create the column configuration
		ColumnModel cm = createColumnModelForTables();

		// create the grid with a result list and the column model
		final EditorGrid<Result> grid = new EditorGrid<Result>(result, cm);
//		final Grid<Result> grid = new Grid<Result>(result, cm);
		// set the double click for row edit
		grid.setClicksToEdit(ClicksToEdit.TWO);
		// grid.setStateId("TablesList");
		// grid.setStateful(true);
		grid.setLoadMask(true);
		grid.setBorders(true);
		//to enable text selection
		grid.disableTextSelection(false);
		// grid.setAutoExpandColumn("comments");
		// grid.setStyleAttribute("borderTop", "none");
		grid.setStripeRows(true);
		// to manage the table selection in the grid
		grid.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
		

		// add the search functionality
		// Top toolbar for search table functionality
		toolBarTop = new ToolBar();

		// TextField for specify the table name to search
		final TextField<String> searchTable = new TextField<String>();
		searchTable.setEmptyText("enter a text");
		searchTable.setToolTip("search a table in the database");
		searchTable.setAllowBlank(true);

		// add the button search
		final Button searchButton = new Button("", Images.iconSearch());
		searchButton.setToolTip("Search");

		// add the button cancel
		Button cancel = new Button("", Images.iconCancel());
		cancel.setToolTip("Cancel");

		// add Buttons and TextField to the toolbar
		toolBarTop.add(searchTable);
		toolBarTop.add(searchButton);
		toolBarTop.add(cancel);

		searchButton.addSelectionListener(new SelectionListener<ButtonEvent>() {
			@Override
			public void componentSelected(ButtonEvent ce) {
				// start search calling the rpc
				// get the keyword
				keyword = searchTable.getValue();
				startSearchTable = true;
				rootLogger.log(Level.INFO, "keyword: " + keyword);
				rootLogger.log(Level.INFO, "Search Table: " + startSearchTable);
				PagingLoadConfig config = new BasePagingLoadConfig();
				// The offset for the first record to retrieve.
				config.setOffset(0);
				// The number of records being requested.
				config.setLimit(100);

				// Map<String, Object> state = grid.getState();
				// if (state.containsKey("offset")) {
				// int offset = (Integer) state.get("offset");
				// int limit = (Integer) state.get("limit");
				// config.setOffset(offset);
				// config.setLimit(limit);
				// }
				// if (state.containsKey("sortField")) {
				// config.setSortField((String) state.get("sortField"));
				// config.setSortDir(SortDir.valueOf((String) state
				// .get("sortDir")));
				// }
				loader.load(config);
			}
		});

		cancel.addSelectionListener(new SelectionListener<ButtonEvent>() {
			@Override
			public void componentSelected(ButtonEvent ce) {
				// clear variables
				keyword = null;
				startSearchTable = false;
				// clear the textfield
				searchTable.clear();
				PagingLoadConfig config = new BasePagingLoadConfig();
				config.setOffset(0);
				config.setLimit(100);
				loader.load(config);
			}
		});

		// "Enter" listener for the search table functionality
		searchTable.addKeyListener(new KeyListener() {
			@Override
			public void componentKeyDown(ComponentEvent event) {
				super.componentKeyDown(event);
				if (event.getKeyCode() == KeyCodes.KEY_ENTER)
					searchButton.fireEvent(Events.Select);
			}
		});

		// listener to manage the table selection in the grid
		grid.addListener(Events.RowClick, new Listener<GridEvent<Result>>() {
			@Override
			public void handleEvent(final GridEvent<Result> be) {
				rootLogger.log(Level.INFO, "RowClick Event->table clicked: "
						+ grid.getSelectionModel().getSelectedItems().get(0)
								.getValue());
				// select the item
				grid.getSelectionModel().select(
						grid.getSelectionModel().getSelectedItems().get(0),
						true);

				// tablesLoaded.addListener(Events.Hide, new
				// Listener<WindowEvent>() {
				// @Override
				// public void handleEvent(WindowEvent be) {
				// // TODO Auto-generated method stub
				// System.out.println("closing the window");
				// }
				// });
			}
		});

		grid.addListener(Events.BeforeEdit, new Listener<GridEvent<Result>>() {
			@Override
			public void handleEvent(final GridEvent<Result> be) {
				rootLogger.log(Level.INFO, "table edited: "
						+ be.getValue().toString());
				// selectedTable = be.getValue().toString();
			}
		});

		// this listener catch the Attach event.It fires when
		// the Tables List button is selected.
		// it seems to fire when the event source is attached to the browser's
		// document or detached from it.
		grid.addListener(Events.Attach, new Listener<GridEvent<Result>>() {
			public void handleEvent(GridEvent<Result> be) {
				rootLogger.log(Level.INFO, "event Attach handled");
				// disable the top toolbar at the first tables loading in such a
				// way to disallow a user the search. It will be enabled in the
				// rpc when the tables are retrieved.
				toolBarTop.disable();

				PagingLoadConfig config = new BasePagingLoadConfig();
				// The offset for the first record to retrieve.
				config.setOffset(0);
				// The number of records being requested.
				config.setLimit(100);

				// if (state.containsKey("offset")) {
				// // rootLogger.log(Level.INFO, "state contains offset");
				// int offset = (Integer) state.get("offset");
				// rootLogger.log(Level.INFO, "offset: " + offset);
				// int limit = (Integer) state.get("limit");
				// rootLogger.log(Level.INFO, "limit: " + limit);
				// config.setOffset(offset);
				// config.setLimit(limit);
				// }
				// if (state.containsKey("sortField")) {
				// config.setSortField((String) state.get("sortField"));
				// config.setSortDir(SortDir.valueOf((String) state
				// .get("sortDir")));
				// }
				loader.load(config);
			}
		});

		tablesLoaded = new Dialog();
		tablesLoaded.setLayout(new FitLayout());
		// ADD CANCEL BUTTON
//		tablesLoaded.addButton(new Button("CANCEL"));
		tablesLoaded.setHeading("Tables");
		tablesLoaded.setResizable(false);
		tablesLoaded.setModal(true);
		tablesLoaded.setBlinkModal(true);
		tablesLoaded.setSize(600, 400);
		tablesLoaded.setScrollMode(Scroll.NONE);
		tablesLoaded.setHideOnButtonClick(true);
		tablesLoaded.setMaximizable(true);
		tablesLoaded.setMinimizable(false);
		tablesLoaded.setClosable(true);
		tablesLoaded.setBottomComponent(toolBar);
		// toolBarTop.getAriaSupport().setLabel("Table Search");

		// enter event in the search
		// TextField<String> searchTable = new TextField<String>();
		// searchTable.setFieldLabel("Search: ");
		// searchTable.addListener(Events.KeyPress, new Listener<FieldEvent>() {
		// @Override
		// public void handleEvent(FieldEvent be) {
		// // TODO Auto-generated method stub
		// // start search calling the rpc
		// // get the keyword
		// keyword = searchTable.getValue();
		// startSearchTable = true;
		// rootLogger.log(Level.INFO, "keyword: " + keyword);
		// rootLogger.log(Level.INFO, "Search Table: " + startSearchTable);
		// PagingLoadConfig config = new BasePagingLoadConfig();
		// config.setOffset(0);
		// config.setLimit(100);
		// loader.load(config);
		// }
		// });
		tablesLoaded.setTopComponent(toolBarTop);

		// listener to manage the table selection in the grid
		final Button ok = (Button) tablesLoaded.getButtonBar().getWidget(0);
		ok.disable();
		rootLogger.log(Level.INFO, "button: " + ok.getText());
		
//		Button canc = (Button) tablesLoaded.getButtonBar().getWidget(1);
//		rootLogger.log(Level.INFO, "button: " + canc.getText());

		// listener for buttons
		ok.addSelectionListener(new SelectionListener<ButtonEvent>() {
			@Override
			public void componentSelected(ButtonEvent ce) {
				keyword = null;
				startSearchTable = false;

				// if (selectedTable != null) {
				if (!currentselectedTable.equals(selectedTable)) {
					currentselectedTable = selectedTable;
					// refresh the content in the two panels
					centerBottom.removeAll();
					centerBottom.layout(true);
					centerUpper.removeAll();
					centerUpper.layout(true);

					// display the table in the panel "Database Information"
					displayTableName(currentselectedTable);

					// to get the selected item in the tree panel
					List<FileModel> data = treePanel.getTreePanel()
							.getSelectionModel().getSelectedItems();
					FileModel selectedItem = data.get(0);

					// fire event
					eventBus.fireEvent(new SelectedTableEvent(selectedItem,
							currentselectedTable));
				}
			}
		});

		//CANC BUTTON that closes the window
//		canc.addSelectionListener(new SelectionListener<ButtonEvent>() {
//			@Override
//			public void componentSelected(ButtonEvent ce) {
//				keyword = null;
//				startSearchTable = false;
//				// refresh the database information panel
//				// centerUpper.removeAll();
//				// centerUpper.layout(true);
//				tablesLoaded.hide();
//			}
//		});
		
		tablesLoaded.addListener(Events.Hide, new Listener<WindowEvent>() {
			@Override
			public void handleEvent(WindowEvent be) {
				
				keyword = null;
				startSearchTable = false;
				tablesLoaded.hide();
				
				rootLogger.log(Level.INFO, "Window Tables closed");
				
			}});

		// listener to manage the table selection in the grid
		grid.getSelectionModel().addSelectionChangedListener(
				new SelectionChangedListener<Result>() {
					@Override
					public void selectionChanged(
							SelectionChangedEvent<Result> se) {
						selectedTable = grid.getSelectionModel()
								.getSelectedItems().get(0).getValue();
						rootLogger.log(Level.INFO,
								"SelectionChangedListener->table selected: "
										+ selectedTable);

						ok.enable();
					}
				});
		tablesLoaded.add(grid);
		tablesLoaded.show();
	}

	// method to submit a query
	private void submitQuery(final Integer dialogID) {
		// get the selected item
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		FileModel selectedItem = data.get(0);

		// get information related to the selected item
		// recover input data
		LinkedHashMap<String, String> dataForSubmitQuery = new LinkedHashMap<String, String>();
		dataForSubmitQuery.put("ResourceName", selectedItem.getResourceName());
		dataForSubmitQuery.put("DatabaseName", selectedItem.getDatabaseName());

		// print check
		// System.out.println("ResourceName" + selectedItem.getResourceName());
		// System.out.println("DatabaseName" + selectedItem.getDatabaseName());

		// get data list (inserted in the form)
		LinkedHashMap<Integer, SubmitQueryData> submitQueryDataList = toolbar
				.getSubmitQueryDataList();
		// get dialog list
		LinkedHashMap<Integer, Dialog> dialogList = toolbar.getDialogFormList();
		// get the dialog related to the ID
		final Dialog form = dialogList.get(dialogID);
		// get the data form related to the ID
		final SubmitQueryData dataQuery = submitQueryDataList.get(dialogID);
		// get the UID related to submitQuery operation
		LinkedHashMap<Integer, String> uidSubmitQueryList = toolbar
				.getUIDSubmitQueryList();
		final String UID = uidSubmitQueryList.get(dialogID);

		// rootLogger.log(Level.INFO, "query: "+ dataQuery.getQuery() +
		// "submitquery->dialogID: "
		// + dialogID);

		// determine the language
		String dialect;

		if (selectedItem.isDatabase()) { // the selected item is a database
			// System.out.println("the selected item is a database");
			rootLogger.log(Level.INFO, "the selected item is a database");
			// determine the dialect recovering the dialect
			dialect = selectedItem.getDBInfo().get(2).getValue();
			rootLogger.log(Level.INFO,
					"determined Dialect for smart correction: " + dialect);
		} else {
			FileModel parent1 = treePanel.getTreeStore()
					.getParent(selectedItem);
			if (parent1.isDatabase()) { // the selected item is a schema
				rootLogger.log(Level.INFO, "the selected item is a schema");
				// determine the dialect recovering the dialect
				dialect = parent1.getDBInfo().get(2).getValue();
				rootLogger.log(Level.INFO,
						"determined Dialect for smart correction: " + dialect);
			} else { // the selected item is a table
						// System.out.println("the selected item is a table");
				rootLogger.log(Level.INFO, "the selected item is a table");
				FileModel parent2 = treePanel.getTreeStore().getParent(parent1);
				// determine the dialect recovering the dialect
				dialect = parent2.getDBInfo().get(2).getValue();
				rootLogger.log(Level.INFO,
						"determined Dialect for smart correction: " + dialect);
			}
		}
		String language = ConstantsPortlet.NONE;

		if (dialect.toUpperCase().contains(ConstantsPortlet.POSTGRES)) {
			language = ConstantsPortlet.POSTGRES;
		}
		if (dialect.toUpperCase().contains(ConstantsPortlet.MYSQL)) {
			language = ConstantsPortlet.MYSQL;
		}
		rootLogger.log(Level.INFO, "Dialect used for smart correction: "
				+ language);

		// remote rpc
		RPCservice.submitQuery(dataForSubmitQuery, dataQuery.getQuery(), true,
				dataQuery.getSmartCorrection(), language, UID,
				new AsyncCallback<SubmitQueryResultWithFileFromServlet>() {

					// TODO: TO REMOVE data "true" as input if you manage the
					// read-only query in the form

					@Override
					public void onFailure(Throwable caught) {
						// Window.alert(caught.getMessage());
						rootLogger
								.log(Level.SEVERE, "FAILURE RPC submitQuery ");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}

						// Listener<MessageBoxEvent> l = new
						// Listener<MessageBoxEvent>() {
						// public void handleEvent(MessageBoxEvent ce) {
						// // Button btn = ce.getButtonClicked();
						// // Info.display("MessageBox",
						// // "The '{0}' button was pressed",
						// // btn.getHtml());
						// // Button btn = ce.getButtonClicked();
						//
						// if (form.getBody().isMasked())
						// form.getBody().unmask();
						// }
						// };

						if (!(caught.getMessage().equals("ServerException"))) {
							if (caught.getMessage().contains(
									"Result not available")) {
								MessageBox.alert("Warning ", "<br/>Message:"
										+ "The query returned 0 values", null);
							} else {
								MessageBox.alert("Error ", "<br/>Message:"
										+ caught.getMessage(), null);
							}
						}

						// if (!(caught instanceof
						// javax.xml.ws.soap.SOAPFaultException)){
						// MessageBox.alert("Error ",
						// "<br/>Message:" + caught.getMessage(), l);
						// }

						if (form.getBody().isMasked())
							form.getBody().unmask();

						if (form.getButtonById(Dialog.OK).isEnabled() == false) {
							form.getButtonById(Dialog.OK).enable();
						}
					}

					@Override
					public void onSuccess(
							SubmitQueryResultWithFileFromServlet obj) {
						rootLogger.log(Level.SEVERE, "SUCCESS RPC submitQuery");

						if (obj != null) {
							// get list attributes
							List<String> listAttributes = obj.getListOutput();

							if (form.getBody().isMasked())
								form.getBody().unmask();

							if (form.getButtonById(Dialog.OK).isEnabled() == false) {
								form.getButtonById(Dialog.OK).enable();
							}

							// if listAttributes is null the computation has
							// been removed from the statisticalManager.In this
							// case no message is displayed.
							if (listAttributes == null) {
								return;
							}

							if (listAttributes.size() == 0) {
								// if (form.getBody().isMasked())
								// form.getBody().unmask();
								rootLogger.log(Level.SEVERE,
										"No results have been returned");
								MessageBox.alert("Warning ", "<br/>Message:"
										+ "The query returned 0 values", null);
								return;
							}

							String query = "";

							if (dataQuery.getSmartCorrection() == false) {
								query = dataQuery.getQuery();
							} else {
								query = obj.getConvertedQuery();
							}
							// if ((listAttributes == null)
							// || (listAttributes.size() == 0)) {
							//
							// // if (form.getBody().isMasked())
							// // form.getBody().unmask();
							//
							// rootLogger.log(Level.SEVERE,
							// "No results have been returned");
							//
							// MessageBox.alert("Error ", "<br/>Message:"
							// + "Result not available", null);
							// return;
							// }

							rootLogger.log(Level.SEVERE,
									"SUCCESS RPC submitQuery");
							rootLogger.log(Level.SEVERE, "output size: "
									+ listAttributes.size());

							// recover query
							// Result query = result.remove(0);
							// recover converted query
							// Result convertedQuery;

							// if (dataQuery.getSmartCorrection() == true) {
							// result.remove(0);
							// // convertedQuery = result.get(1);
							// }

							// get the attributes list for the result table
							// List<String> listAttributes = new
							// ArrayList<String>();
							// listAttributes = getListAttributes(result.get(0)
							// .getValue());
							// // remove the header in order to parse only the
							// result
							// result.remove(0);

							// parse the result in order to obtain a table
							// boolean submitQueryEventManaged = true;
							// parseResult(result, form, dialogID,
							// submitQueryEventManaged);

							// parseSubmitQueryResult(result, form, dialogID,
							// listAttributes, dataQuery.getQuery());

							// get path
							String fileName = obj.getFileName();
							parseSubmitQueryResult(form, dialogID,
									listAttributes, query, fileName, UID);

						}

					}
				});
	}

	// start the parsing of the submit result in order to obtain a table
	private void parseSubmitQueryResult(Dialog dialog, final int dialogID,
			final List<String> listAttributes, String query, String fileName,
			final String UID) {

		final Dialog form = dialog;
		// define the proxy and create the grid to display in the dialog
		// create RpcProxy object to use the load configuration
		RpcProxy<PagingLoadResult<Row>> proxy = new RpcProxy<PagingLoadResult<Row>>() {
			@Override
			protected void load(Object loadConfig,
					final AsyncCallback<PagingLoadResult<Row>> callback) {
				rootLogger.log(Level.SEVERE,
						"Start RPC - loadSubmitQueryResult");

				// remote rpc
				RPCservice.loadSubmitResult((PagingLoadConfig) loadConfig,
						listAttributes, UID,
						new AsyncCallback<PagingLoadResult<Row>>() {
							@Override
							public void onFailure(Throwable caught) {
								rootLogger.log(Level.SEVERE,
										"FAILURE RPC loadSubmitQueryResult");

								if (caught instanceof SessionExpiredException) {
									rootLogger.log(Level.INFO,
											"Session expired");
									CheckSession.showLogoutDialog();
									return;
								}

								Listener<MessageBoxEvent> l = new Listener<MessageBoxEvent>() {
									public void handleEvent(MessageBoxEvent ce) {
										if (form.getBody().isMasked())
											form.getBody().unmask();

										if (form.getButtonById(Dialog.OK)
												.isEnabled() == false) {
											form.getButtonById(Dialog.OK)
													.enable();
										}
									}
								};

								MessageBox.alert("Error ", "<br/>Message:"
										+ caught.getMessage(), l);
								callback.onFailure(caught);
							}

							@Override
							public void onSuccess(PagingLoadResult<Row> result) {
								rootLogger.log(Level.SEVERE,
										"SUCCESS RPC loadSubmitQueryResult");

								if (result != null) {
									callback.onSuccess(result);
									List<Row> rows = result.getData();

									if (form.getBody().isMasked())
										form.getBody().unmask();

									if (form.getButtonById(Dialog.OK)
											.isEnabled() == false) {
										form.getButtonById(Dialog.OK).enable();
									}

									if ((rows == null) || (rows.size() == 0)) {
										rootLogger
												.log(Level.SEVERE,
														"No results have been returned");

										MessageBox
												.alert("Warning ",
														"<br/>Message:"
																+ "The query returned 0 values",
														null);

										return;
									}
								}
								// if (result != null) {
								// rootLogger.log(Level.SEVERE,
								// "rows not null");
								// }
							}
						});
			}
		};

		// loader to load page enabled set of data
		final PagingLoader<PagingLoadResult<Row>> loader = new BasePagingLoader<PagingLoadResult<Row>>(
				proxy);

		// to create the listStore using the loader
		final ListStore<Row> store = new ListStore<Row>(loader);
		// bind the loader with a PagingToolBar.
		final PagingToolBar toolBar = new PagingToolBar(100);
		toolBar.bind(loader);

		// create the grid with a result list and the column model
		Grid<Row> grid;
		grid = new Grid<Row>(store, createColumnModel(listAttributes));
		grid.setLoadMask(true);
		grid.setBorders(true);
		grid.setStripeRows(true);
		// to manage the table selection in the grid
		grid.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);

		grid.addListener(Events.Attach, new Listener<GridEvent<Row>>() {
			public void handleEvent(GridEvent<Row> be) {
				rootLogger.log(Level.INFO, "event Attach handled");

				// disable the top toolbar at the first tables loading in such a
				// way to disallow a user the search. It will be enabled in the
				// rpc when the tables are retrieved.
				// toolBarTop.disable();

				PagingLoadConfig config = new BasePagingLoadConfig();
				// The offset for the first record to retrieve.
				config.setOffset(0);
				// The number of records being requested.
				config.setLimit(100);

				// if (state.containsKey("offset")) {
				// // rootLogger.log(Level.INFO, "state contains offset");
				// int offset = (Integer) state.get("offset");
				// rootLogger.log(Level.INFO, "offset: " + offset);
				// int limit = (Integer) state.get("limit");
				// rootLogger.log(Level.INFO, "limit: " + limit);
				// config.setOffset(offset);
				// config.setLimit(limit);
				// }
				// if (state.containsKey("sortField")) {
				// config.setSortField((String) state.get("sortField"));
				// config.setSortDir(SortDir.valueOf((String) state
				// .get("sortDir")));
				// }
				loader.load(config);
			}
		});

		// // Display the submit query result as a table
		// Dialog submitResult = new Dialog();
		// submitResult.setLayout(new FitLayout());
		//
		// //TODO TO MODIFY
		// submitResult.setHeading("Result");
		// submitResult.setSize(600, 400);
		//
		// submitResult.add(grid);
		// submitResult.show();

		// Display the submit query result as a table
		Dialog submitResult = new Dialog() {
			// override the maximize event modifying it with
			// a different behaviour if the mimimize event
			// occurs
			public void maximize() {
				if (isCollapsed()) {
					expand();
				} else {
					super.maximize();
				}
			}
		};

		// submitResult.setLayout(new FitLayout());
		submitResult.setHeading("Result Query " + dialogID);
		submitResult.setResizable(false);
		submitResult.setSize(600, 400);
		submitResult.setScrollMode(Scroll.NONE);
		submitResult.setHideOnButtonClick(true);
		submitResult.setMaximizable(true);
		submitResult.setMinimizable(true);
		// submitResult.setBottomComponent(toolBar);

		submitResult.setLayout(new RowLayout(Style.Orientation.VERTICAL));
		// to add the panel of the converted query and the panel that display
		// the query's result
		ContentPanel q = new ContentPanel();
		q.setLayout(new FitLayout());
		q.setHeaderVisible(false);
		q.addText(query);
		submitResult.add(q, new RowData(1, 0.3));

		ContentPanel g = new ContentPanel();
		g.setLayout(new FitLayout());
		g.setHeaderVisible(false);
		g.setBottomComponent(toolBar);
		g.add(grid);
		g.layout(true);

		// mimimize event handled
		submitResult.addListener(Events.Minimize, new Listener<WindowEvent>() {
			@Override
			public void handleEvent(WindowEvent be) {
				// collapse the dialog
				be.getWindow().collapse();
			}
		});
		// maximize event handled
		submitResult.addListener(Events.Maximize, new Listener<WindowEvent>() {
			@Override
			public void handleEvent(WindowEvent be) {
				// expand the dialog
				if (be.getWindow().isCollapsed()) {
					be.getWindow().expand();
				}
			}
		});

		submitResult.addListener(Events.Hide, new Listener<WindowEvent>() {
			@Override
			public void handleEvent(WindowEvent be) {
				// call rpc to remove the stored result
				RPCservice.refreshDataOnServer(UID, new AsyncCallback<Void>() {
					@Override
					public void onFailure(Throwable caught) {
						rootLogger.log(Level.SEVERE,
								"FAILURE RPC refreshDataOnServer");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}
					}

					@Override
					public void onSuccess(Void result) {
						rootLogger.log(Level.SEVERE,
								"SUCCESS RPC refreshDataOnServer");
					}
				});
			}
		});
		
		// listener on the dialog "ok" button
		submitResult.getButtonById(Dialog.OK).addSelectionListener(
				new SelectionListener<ButtonEvent>() {
					@Override
					public void componentSelected(ButtonEvent ce) {

						rootLogger.log(Level.SEVERE,
								"button ok clicked");
						
						// call rpc to remove the stored result
						RPCservice.refreshDataOnServer(UID, new AsyncCallback<Void>() {
							@Override
							public void onFailure(Throwable caught) {
								rootLogger.log(Level.SEVERE,
										"FAILURE RPC refreshDataOnServer");

								if (caught instanceof SessionExpiredException) {
									rootLogger.log(Level.INFO, "Session expired");
									CheckSession.showLogoutDialog();
									return;
								}
							}

							@Override
							public void onSuccess(Void result) {
								rootLogger.log(Level.SEVERE,
										"SUCCESS RPC refreshDataOnServer");
							}
						});
						
					}
				});

		// add the button to download the result
		final String urlFile = Window.Location.getProtocol() + "//"
				+ Window.Location.getHost() + fileName;

		Button download = new Button("Download",
				new SelectionListener<ButtonEvent>() {
					@Override
					public void componentSelected(ButtonEvent ce) {
						Window.open(urlFile, "Result File", "_blank");
					}
				});
		submitResult.addButton(download);
		// submitResult.add(grid);
		submitResult.add(g, new RowData(1, 0.7));
		submitResult.show();
	}

	// method to perform the sample table
	private void sample() {
		final GxtBorderLayoutPanel obj = this;
		rootLogger.log(Level.SEVERE, "Start RPC - sample");

		// get the selected table
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		// the selected item
		FileModel selectedItem = data.get(0);
		// recover data inputs
		final LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
		// check if the table has an associated schema
		FileModel schema;
		FileModel database;
		FileModel resource;

		String elementType;

		if (selectedItem.isDatabase()) {
			// the table has not a schema because the selected item is a
			// database
			database = selectedItem;
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", "");
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + "");
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);

			elementType = ConstantsPortlet.DATABASE;
		} else {
			// the table has a schema because the selected item is a schema
			schema = selectedItem;
			database = treePanel.getTreeStore().getParent(schema);
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", schema.getName());
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);

			elementType = ConstantsPortlet.SCHEMA;
		}

		// to mask the entire content panel
		obj.mask("Sampling the table", "x-mask-loading");

		// call remote service
		RPCservice.sample(dataInput, elementType,
				new AsyncCallback<SamplingResultWithFileFromServlet>() {
					@Override
					public void onFailure(Throwable caught) {
						// Window.alert(caught.getMessage());
						rootLogger.log(Level.SEVERE, "FAILURE RPC sample");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}

						if (caught.getMessage()
								.contains("Result not available")) {
							MessageBox.alert("Warning ", "<br/>Message:"
									+ "The table has 0 rows", null);
						} else {
							MessageBox.alert("Error ",
									"<br/>Message:" + caught.getMessage(), null);
						}
						if (obj.isMasked()) {
							obj.unmask();
						}
					}

					@Override
					public void onSuccess(
							SamplingResultWithFileFromServlet samplingResult) {
						rootLogger.log(Level.SEVERE, "SUCCESS RPC sample");

						if (samplingResult != null) {
							// get data
							List<Result> result = samplingResult
									.getListOutput();
							// get the attributes list for the result
							// table
							List<String> listAttributes = new ArrayList<String>();
							listAttributes = getListAttributes(result.get(0)
									.getValue());
							// remove the header in order to parse only
							// the result
							result.remove(0);
							rootLogger.log(Level.SEVERE, "output size: "
									+ result.size());

							// get path
							String fileName = samplingResult.getFileName();
							// parse the result in order to obtain a
							// table
							parseResult(result, listAttributes, fileName);

						} else {
							MessageBox.alert("Error ", "<br/>Message: "
									+ "no data available", null);

							if (obj.isMasked()) {
								obj.unmask();
							}

						}

					}
				});

	}

	// method that performs the smart sample
	private void smartSample() {
		final GxtBorderLayoutPanel obj = this;
		rootLogger.log(Level.SEVERE, "Start RPC - smartSample");
		// get the selected table
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		// the selected item
		FileModel selectedItem = data.get(0);
		// recover data inputs for the algorithm
		final LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
		// check if the table has an associated schema
		FileModel schema;
		FileModel database;
		FileModel resource;

		String elementType;

		if (selectedItem.isDatabase()) {
			// the table has not a schema
			database = selectedItem;
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", "");
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + "");
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
			elementType = ConstantsPortlet.DATABASE;
		} else {
			// the table has a schema
			schema = selectedItem;
			database = treePanel.getTreeStore().getParent(schema);
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", schema.getName());
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
			elementType = ConstantsPortlet.SCHEMA;
		}
		// to mask the entire content panel
		obj.mask("Sampling the table", "x-mask-loading");

		// call remote service
		RPCservice.smartSample(dataInput, elementType,
				new AsyncCallback<SamplingResultWithFileFromServlet>() {
					@Override
					public void onFailure(Throwable caught) {
						// Window.alert(caught.getMessage());
						rootLogger.log(Level.SEVERE, "FAILURE RPC smartSample");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}
						if (caught.getMessage()
								.contains("The table has 0 rows")) {
							MessageBox.alert("Warning ", "<br/>Message:"
									+ "The table has 0 rows", null);
						} else {
							MessageBox.alert("Error ",
									"<br/>Message:" + caught.getMessage(), null);
						}
						if (obj.isMasked()) {
							obj.unmask();
						}
					}

					@Override
					public void onSuccess(
							SamplingResultWithFileFromServlet samplingResult) {
						rootLogger.log(Level.SEVERE, "SUCCESS RPC smartSample");

						if (samplingResult != null) {
							// get data
							List<Result> result = samplingResult
									.getListOutput();
							// get the attributes list for the result
							// table
							List<String> listAttributes = new ArrayList<String>();
							listAttributes = getListAttributes(result.get(0)
									.getValue());
							// remove the header in order to parse only
							// the result
							result.remove(0);
							rootLogger.log(Level.SEVERE, "output size: "
									+ result.size());
							// get path
							String fileName = samplingResult.getFileName();
							// parse the result in order to obtain a
							// table
							parseResult(result, listAttributes, fileName);
						} else {
							MessageBox.alert("Error ", "<br/>Message: "
									+ "no data available", null);

							if (obj.isMasked()) {
								obj.unmask();
							}

						}
					}
				});
	}

	// method to perform the random sample
	private void randomSample() {
		final GxtBorderLayoutPanel obj = this;
		rootLogger.log(Level.SEVERE, "Start RPC - randomSample");
		// get the selected table
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		// the selected item
		FileModel selectedItem = data.get(0);
		// recover data inputs for the algorithm
		final LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();

		// check if the table has an associated schema
		FileModel schema;
		FileModel database;
		FileModel resource;

		String elementType;

		if (selectedItem.isDatabase()) {
			// the table has not a schema
			database = selectedItem;
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", "");
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + "");
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
			elementType = ConstantsPortlet.DATABASE;
		} else {
			// the table has a schema
			schema = selectedItem;
			database = treePanel.getTreeStore().getParent(schema);
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", schema.getName());
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
			elementType = ConstantsPortlet.SCHEMA;
		}

		// to mask the entire content panel
		obj.mask("Sampling the table", "x-mask-loading");

		// call remote service
		RPCservice.randomSample(dataInput, elementType,
				new AsyncCallback<SamplingResultWithFileFromServlet>() {
					@Override
					public void onFailure(Throwable caught) {
						// Window.alert(caught.getMessage());
						rootLogger
								.log(Level.SEVERE, "FAILURE RPC randomSample");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}

						if (caught.getMessage()
								.contains("Result not available")) {
							MessageBox.alert("Warning ", "<br/>Message:"
									+ "The table has 0 rows", null);
						} else {
							MessageBox.alert("Error ",
									"<br/>Message:" + caught.getMessage(), null);
						}
						if (obj.isMasked()) {
							obj.unmask();
						}
					}

					@Override
					public void onSuccess(
							SamplingResultWithFileFromServlet samplingResult) {
						rootLogger
								.log(Level.SEVERE, "SUCCESS RPC randomSample");

						if (samplingResult != null) {
							// get data
							List<Result> result = samplingResult
									.getListOutput();
							// get the attributes list for the result
							// table
							List<String> listAttributes = new ArrayList<String>();
							listAttributes = getListAttributes(result.get(0)
									.getValue());
							// remove the header in order to parse only
							// the result
							result.remove(0);
							rootLogger.log(Level.SEVERE, "output size: "
									+ result.size());
							// get path
							String fileName = samplingResult.getFileName();
							// parse the result in order to obtain a
							// table
							parseResult(result, listAttributes, fileName);
						} else {
							MessageBox.alert("Error ", "<br/>Message: "
									+ "no data available", null);

							if (obj.isMasked()) {
								obj.unmask();
							}

						}
					}
				});
	}

	// start the parsing of the submit result in order to obtain a table
	private void parseResult(List<Result> result,
			final List<String> listAttributes, final String fileName) {
		// to unmask the entire content panel
		final GxtBorderLayoutPanel obj = this;
		// final Dialog form = dialog;

		RPCservice.parseCVSString(result, listAttributes,
				new AsyncCallback<List<Row>>() {
					@Override
					public void onFailure(Throwable caught) {
						// Window.alert(caught.getMessage());
						rootLogger.log(Level.SEVERE, "FAILURE RPC parseResult");

						if (caught instanceof SessionExpiredException) {
							rootLogger.log(Level.INFO, "Session expired");
							CheckSession.showLogoutDialog();
							return;
						}

						MessageBox.alert("Error ",
								"<br/>Message:Error in server while loading data. Exception: " + caught.getMessage(), null);

						// if the submit query event has been performed the
						// dialog form is unmasked otherwise if a sampling
						// operation is performed the entire panel is masked.
						if (obj.isMasked()) {
							obj.unmask();
						}
						// if (submitQueryEventManaged == true) {
						//
						// if (form.getBody().isMasked())
						// form.getBody().unmask();
						// } else {
						// if (obj.isMasked()) {
						// obj.unmask();
						// }
						// }
					}

					@Override
					public void onSuccess(List<Row> rows) {
						rootLogger.log(Level.SEVERE, "SUCCESS RPC parseResult");

						if (rows != null) {
							// Display the submit query result as a table
							Dialog sampleResult = new Dialog() {

								// override the maximize event modifying it with
								// a different behaviour if the mimimize event
								// occurs
								public void maximize() {
									if (isCollapsed()) {
										expand();
									} else {
										super.maximize();
									}
								}

							};

							// if (submitQueryEventManaged == true) {
							// submitResult.setHeading("Result Query "
							// + dialogID);
							// } else {
							// submitResult.setHeading("Result");
							// }

							sampleResult.setLayout(new FitLayout());
							sampleResult.setHeading("Result");
							sampleResult.setResizable(false);
							// submitResult.setHeading("Submit Query");
							// submitResult.setWidth(290);
							// submitResult.setHeight(250);
							// submitResult.setModal(true);
							// submitResult.setBlinkModal(true);
							// submitResult.setBodyStyle("padding:9px;");
							sampleResult.setSize(600, 400);
							// submitResult.setScrollMode(Scroll.AUTO);
							sampleResult.setScrollMode(Scroll.NONE);
							sampleResult.setHideOnButtonClick(true);
							sampleResult.setMaximizable(true);
							sampleResult.setMinimizable(true);
							// submitResult.addText("Result Table");

							ListStore<Row> store = new ListStore<Row>();
							store.add(rows);

							Grid<Row> grid;
							grid = new Grid<Row>(store,
									createColumnModel(listAttributes));

							// grid.setAutoExpandColumn("value");
							grid.setBorders(true);
							// grid.setAutoWidth(true);
							RowData data = new RowData(.5, 1);
							data.setMargins(new Margins(6));

							// mimimize event handled
							sampleResult.addListener(Events.Minimize,
									new Listener<WindowEvent>() {
										@Override
										public void handleEvent(WindowEvent be) {
											// collapse the dialog
											be.getWindow().collapse();
										}
									});
							// maximize event handled
							sampleResult.addListener(Events.Maximize,
									new Listener<WindowEvent>() {
										@Override
										public void handleEvent(WindowEvent be) {
											// expand the dialog
											if (be.getWindow().isCollapsed()) {
												be.getWindow().expand();
											}
										}
									});

							// add the button to download the result
							final String urlFile = Window.Location
									.getProtocol()
									+ "//"
									+ Window.Location.getHost() + fileName;

							Button download = new Button("Download",
									new SelectionListener<ButtonEvent>() {
										@Override
										public void componentSelected(
												ButtonEvent ce) {
											Window.open(urlFile, "Result File",
													"_blank");
										}
									});
							sampleResult.addButton(download);
							sampleResult.add(grid, data);
							sampleResult.show();

							// if the submit query event has been performed the
							// dialog form is unmasked otherwise if a sampling
							// operation is performed the entire panel is
							// masked.

							// if (submitQueryEventManaged == true) {
							// if (form.getBody().isMasked())
							// form.getBody().unmask();
							// } else {
							// if (obj.isMasked()) {
							// obj.unmask();
							// }
							// }

							if (obj.isMasked()) {
								obj.unmask();
							}
						} else {
							// if (submitQueryEventManaged == true) {
							// if (form.getBody().isMasked())
							// form.getBody().unmask();
							// } else {
							// if (obj.isMasked()) {
							// obj.unmask();
							// }
							// }

							if (obj.isMasked()) {
								obj.unmask();
							}
						}
					}
				});
	}

	// get attributes list for display the result in a table
	private List<String> getListAttributes(String value) {
		List<String> listAttributes = new ArrayList<String>();
		// recover attribute fields for the result table
		String headers = value;
		// rootLogger.log(Level.INFO, "Headers fields table: " + headers);
		listAttributes = parseAttributesTableResult(headers);
		rootLogger.log(Level.INFO,
				"attributes number: " + listAttributes.size());

		// rootLogger.log(Level.INFO, "attributes list: ");
		// print check
		// for (int i = 0; i < listAttributes.size(); i++) {
		// rootLogger.log(Level.INFO, "attribute: " + listAttributes.get(i));
		// }
		return listAttributes;
	}

	// create column configuration for the grid
	private ColumnModel createColumnModel(List<String> listAttributes) {
		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
		ColumnConfig column;
		column = new ColumnConfig();
		// column.setId("index");
		// column.setHeader("Index");
		// column.setWidth(100);
		// column.setSortable(false);
		// configs.add(column);

		for (int i = 0; i < listAttributes.size(); i++) {
			// rootLogger.log(Level.INFO, "attribute: " +
			// listAttributes.get(i));
			column = new ColumnConfig();
			column.setId(listAttributes.get(i));
			// column.setId("\"" + fields.get(i) + "\"");
			column.setHeader(listAttributes.get(i));
			column.setWidth(100);
			column.setSortable(false);
			configs.add(column);
		}
		return new ColumnModel(configs);
	}

	private List<String> parseAttributesTableResult(String phrase) {
		String delimiter = ",";
		List<String> elements = new ArrayList<String>();
		int idxdelim = -1;
		phrase = phrase.trim();

		while ((idxdelim = phrase.indexOf(delimiter)) >= 0) {
			elements.add(phrase.substring(0, idxdelim));
			phrase = phrase.substring(idxdelim + 1).trim();
		}
		elements.add(phrase);
		return elements;
	}

	// create column configuration for the grid
	private ColumnModel createColumnModelForDBInfo(List<Result> result) {
		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
		ColumnConfig column = new ColumnConfig();
		column.setId("index");
		column.setHeader("Property");
		column.setWidth(100);
		// column.setSortable(false);

//		TextField<String> textProperty = new TextField<String>();
//		// text.setAllowBlank(false);
//		column.setEditor(new CellEditor(textProperty));
		configs.add(column);

		column = new ColumnConfig();
		column.setId("value");
		column.setHeader("Value");
		column.setWidth(600);
		// column.setSortable(false);

//		TextField<String> textValue = new TextField<String>();
//		// text.setAllowBlank(false);
//		column.setEditor(new CellEditor(textValue));
		configs.add(column);

//		ListStore<Result> store = new ListStore<Result>();
//		store.add(result);
		return new ColumnModel(configs);
	}

	// create column configuration for the grid
	private ColumnModel createColumnModelForTables() {
		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
		ColumnConfig column = new ColumnConfig();
		// column.setId("index");
		// column.setHeader("Index");
		// column.setWidth(100);
		// configs.add(column);

//		column = new ColumnConfig();
		column.setId("value");
		column.setHeader("Name");
		column.setWidth(600);
		// column.setSortable(false);

//		TextField<String> textValue = new TextField<String>();
//		// text.setAllowBlank(false);
//		column.setEditor(new CellEditor(textValue));
		configs.add(column);
		// ListStore<Result> store = new ListStore<Result>();
		// store.add(result);
		return new ColumnModel(configs);
	}

	private void displayDBInfo(FileModel element) {
		rootLogger.log(Level.INFO, "displaying info");
		List<Result> dataDB = element.getDBInfo();

		if (dataDB != null) {
			rootLogger.log(Level.INFO, "info size: " + dataDB.size());
			ListStore<Result> store = new ListStore<Result>();
			store.add(dataDB);
//			EditorGrid<Result> grid = new EditorGrid<Result>(store,
//					createColumnModelForDBInfo(dataDB));
			Grid<Result> grid = new Grid<Result>(store,
					createColumnModelForDBInfo(dataDB));
			// grid.setAutoExpandColumn("name");
			grid.setBorders(true);
			grid.disableTextSelection(false);
			// grid.setAutoWidth(true);
			// RowData data = new RowData(.5, 1);
			// data.setMargins(new Margins(6));
			centerUpper.removeAll();
			// centerUpper.add(grid, data);
			centerUpper.add(grid);
			centerUpper.layout(true);
		}
	}

	// method to get the table details
	private void getTableDetails(final FileModel Table) {
		// to unmask the entire content panel
		final GxtBorderLayoutPanel obj = this;
		rootLogger.log(Level.SEVERE, "Start RPC - getTableDetails");

		// get the selected table
		List<FileModel> data = treePanel.getTreePanel().getSelectionModel()
				.getSelectedItems();
		// the selected item
		FileModel selectedItem = data.get(0);
		// recover data inputs fo the algorithm
		final LinkedHashMap<String, String> dataInput = new LinkedHashMap<String, String>();
		// check if the table has an associated schema
		FileModel schema;
		FileModel database;
		FileModel resource;

		if (selectedItem.isDatabase()) {
			// the table has not a schema
			database = selectedItem;
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", "");
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + "");
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
		} else {
			// the table has a schema
			schema = selectedItem;
			database = treePanel.getTreeStore().getParent(schema);
			resource = treePanel.getTreeStore().getParent(database);

			dataInput.put("ResourceName", resource.getName());
			dataInput.put("DatabaseName", database.getName());
			dataInput.put("SchemaName", schema.getName());
			dataInput.put("TableName", currentselectedTable);

			rootLogger.log(Level.INFO, "ResourceName: " + resource.getName());
			rootLogger.log(Level.INFO, "DatabaseName: " + database.getName());
			rootLogger.log(Level.INFO, "SchemaName: " + schema.getName());
			rootLogger.log(Level.INFO, "TableName: " + currentselectedTable);
		}

		// details for the table are displayed if they have not been displayed
		// yet
		if (Table.isTableDetailsDisplayed()) {
			displayTableDetails(Table);
		} else {
			// to mask the entire content panel
			obj.mask("Loading details", "x-mask-loading");

			// call remote service
			RPCservice.getTableDetails(dataInput,
					new AsyncCallback<LinkedHashMap<String, FileModel>>() {
						@Override
						public void onFailure(Throwable caught) {
							rootLogger.log(Level.SEVERE,
									"FAILURE RPC getTableDetails");

							if (caught instanceof SessionExpiredException) {
								rootLogger.log(Level.INFO, "Session expired");
								CheckSession.showLogoutDialog();
								return;
							}

							MessageBox.alert("Error ",
									"<br/>Message:" + caught.getMessage(), null);

							if (obj.isMasked()) {
								obj.unmask();
							}
						}

						@Override
						public void onSuccess(
								LinkedHashMap<String, FileModel> result) {
							rootLogger.log(Level.SEVERE,
									"SUCCESS RPC getTableDetails");

							// details are recovered about
							// the selected table
							if (result.size() != 0) {
								// recover keys from the
								// result
								Set<String> keys = result.keySet();
								Object[] array = keys.toArray();

								// recover details
								List<Result> TableDetails = new ArrayList<Result>();

								for (int i = 0; i < result.size(); i++) {
									if (array[i].toString().contains(
											"CreateTable")) {
										// recover the
										// showCreateTable
										// statement
										Result row = new Result(
												"Create statement", result.get(
														array[i].toString())
														.getName());
										TableDetails.add(row);
									}

									if (array[i].toString().contains(
											"Column Names")) {
										// recover the
										// column names
										Result row = new Result("Column names",
												result.get(array[i].toString())
														.getName());
										TableDetails.add(row);
									}

									if (array[i].toString().contains(
											"NumberRows")) {
										// recover the
										// column names
										Result row = new Result(
												"Number of rows", result.get(
														array[i].toString())
														.getName());
										TableDetails.add(row);
									}
								}
								Table.setTableDetails(TableDetails);
								displayTableDetails(Table);
								Table.setTableDetailsDisplayed(true);
							}
						}
					});
		}
	}

	private void displayTableDetails(FileModel table) {
		rootLogger.log(Level.INFO, "displaying table details");

		List<Result> tableDetails = table.getTableDetails();
		rootLogger.log(Level.INFO, "details size: " + tableDetails.size());

		ListStore<Result> store = new ListStore<Result>();
		store.add(tableDetails);
//		EditorGrid<Result> grid = new EditorGrid<Result>(store,
//				createColumnModelForDBInfo(tableDetails));
		Grid<Result> grid = new Grid<Result>(store,
				createColumnModelForDBInfo(tableDetails));
		// grid.setAutoExpandColumn("name");
		grid.setBorders(true);
		grid.disableTextSelection(false);
		// grid.setAutoWidth(true);
		// RowData data = new RowData(.5, .1);
		// data.setMargins(new Margins(6));
		centerBottom.removeAll();
		// centerBottom.add(grid, data);
		centerBottom.add(grid);
		centerBottom.layout(true);

		// to unmask the entire content panel
		if (this.isMasked()) {
			this.unmask();
		}
	}

	private void displayTableName(String tableName) {
		rootLogger.log(Level.INFO, "displaying table name " + tableName
				+ " in the panel");
		final Result table = new Result("Selected table", tableName);
		final ListStore<Result> store = new ListStore<Result>();
		store.add(table);

		// create column configuration
		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
		ColumnConfig column = new ColumnConfig();
		column.setId("index");
		column.setHeader("Description");
		column.setWidth(100);
		configs.add(column);

		column = new ColumnConfig();
		column.setId("value");
		column.setHeader("Value");
		column.setWidth(600);

//		TextField<String> textValue = new TextField<String>();
//		column.setEditor(new CellEditor(textValue) {
//			// public Object preProcessValue(Object value) {
//			// System.out.println("value preProcess: " +
//			// store.getModels().get(0).getValue());
//			// return store.getModels().get(0).getValue();
//			// }
//			public Object postProcessValue(Object value) {
//				// System.out.println("value postProcess: " +
//				// store.findModel(table).getValue());
//				return store.findModel(table).getValue();
//			}
//		});

		configs.add(column);
		ColumnModel cm = new ColumnModel(configs);

		// grid
//		EditorGrid<Result> grid = new EditorGrid<Result>(store, cm);
		Grid<Result> grid = new Grid<Result>(store, cm);
		grid.disableTextSelection(false);
		// display information in the panel
		centerUpper.removeAll();
		centerUpper.add(grid);
		centerUpper.layout(true);
	}
}