/*
    * 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: FileParamsSelectionPage.java
   * Created: 2009-03-19
   * Author: bmilos
   * $Id$
   */
  
  package pl.edu.agh.cast.importer.wizard.page;
  
  import java.io.IOException;
  import java.nio.charset.Charset;
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.jface.viewers.ArrayContentProvider;
  import org.eclipse.jface.viewers.ComboViewer;
  import org.eclipse.jface.viewers.LabelProvider;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.widgets.Combo;
  import org.eclipse.swt.widgets.Composite;
  
  import pl.edu.agh.cast.Activator;
  import pl.edu.agh.cast.importer.base.data.RawTabularData;
  import pl.edu.agh.cast.importer.base.tokenizer.IImportTokenizer;
  import pl.edu.agh.cast.importer.base.tokenizer.ITokenizerOption;
  import pl.edu.agh.cast.importer.base.util.ImporterUtil;
  import pl.edu.agh.cast.importer.base.util.TokenizerInfo;
  import pl.edu.agh.cast.importer.wizard.util.ConversionRulesPageInfo;
  import pl.edu.agh.cast.importer.wizard.util.Messages;
  
  /**
   * Page of the import wizard, which serves for initial selection of all basic information that are required by the
   * import process, such as selection of the data file format, domain model and encoding.
   * 
   * @author AGH CAST Team
   */
  public class FileParamsSelectionPage extends AbstractImportWizardPage {
  
  	private FileParamsSelectionPageComposite composite;
  
  	private List<TokenizerInfo> tokenizerInfos;
  
  	private List<ConversionRulesPageInfo> conversionRulesPageInfos;
  
  	private Logger log = Activator.getLogger();
  
  	private IImportTokenizer importTokenizer;
  
  	/**
  	 * The default constructor.
  	 */
  	public FileParamsSelectionPage() {
  		super(Messages.ImporterWizard_FileParamsSelectionPageTitle,
  		        Messages.ImporterWizard_FileParamsSelectionPageDescription);
  	}
  
  	/**
  	 * {@inheritDoc}
  	 * 
  	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
  	 */
  	public void createControl(Composite parent) {
  		composite = new FileParamsSelectionPageComposite(parent, SWT.NULL, this);
  		setControl(composite);
  
  		refreshSelectedData();
  	}
  
  	protected boolean isComplete() {
  		return composite.getSelectedConversionRulesSelectionPageInfo() != null
  		        && composite.getSelectedFormatId() != null;
  	}
  
  	/*
  	 * -----------------------------------------------------------------------------------------------------------
  	 * --------------------------OVERRIDED METHODS-------------------------------------------------------
  	 * -----------------------------------------------------------------------------------------------------------
  	 */
  
  	/**
  	 * {@inheritDoc}
  	 * 
  	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractImportWizardPage#initPage()
  	 */
  	@Override
  	public void initPage() {
 		refreshSelectedData();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * 
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractImportWizardPage#refreshImportData()
 	 */
 	@Override
 	public void refreshImportData() {
 		if (!isComplete()) {
 			return;
 		}
 		final String formatId = composite.getSelectedFormatId();
 
 		getImportProcess().setConversionRulesSelectionPageId(
 		        composite.getSelectedConversionRulesSelectionPageInfo().getId());
 
 		if (formatId != null) {
 			importTokenizer = null;
 			try {
 				importTokenizer = getImporterUtil().getTokenizerInstance(formatId);
 			} catch (CoreException e) {
 				final String errorMsg = "CoreException while retrieving instance of tokenizer with id: " //$NON-NLS-1$
 				        + formatId;
 				log.error(errorMsg, e);
 				throw new RuntimeException(errorMsg, e);
 			}
 
 			importTokenizer.setEncoding(composite.getSelectedEncoding());
 			getImportProcess().setTokenizer(importTokenizer);
 		}
 
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------HELPER METHODS------------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Loads a data preview by importing a given amount of rows (<code>PREVIEW_ROWS_LIMIT</code>) of a specified data
 	 * file, with use of a tokenizer of a specified identifier and its options.
 	 * 
 	 * <p>
 	 * TODO: now the method loads a preview of only a single tabular data; future versions must include tabs for every
 	 * tokenized tabular data
 	 * 
 	 *@param fileEncoding
 	 *            the file selected file encoding
 	 * @param tokenizerOptions
 	 *            the options for the tokenizer
 	 * @param previewRowsLimit
 	 *            the limit of rows previewed
 	 * 
 	 * @return the raw tabular data ready for preview
 	 */
 	public RawTabularData loadPreview(Charset fileEncoding, List<ITokenizerOption> tokenizerOptions,
 	        int previewRowsLimit) {
 		try {
 			importTokenizer = getImporterUtil().getTokenizerInstance(composite.getSelectedFormatId());
 			importTokenizer.setEncoding(fileEncoding);
 			importTokenizer.setTokenizerOptions(tokenizerOptions);
 			getImportProcess().setTokenizer(importTokenizer);
 			return getImportProcess().getTokenizePreview();
 		} catch (CoreException e) {
 			log.debug("Exception while loading file preview", e); //$NON-NLS-1$
 		}
 		return null;
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------GETTERS AND SETTERS------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Sets data and items to display for the domain model combo on <code>InitImportPageComposite</code>.
 	 * 
 	 * @param domainModelCombo
 	 *            the domain model combo
 	 */
 	public void setDomainModelComboData(Combo domainModelCombo) {
 		if (conversionRulesPageInfos == null) {
 			try {
 				conversionRulesPageInfos = getImportWizard().getWizardUtil().getConversionRulesSelectionPageInfos();
 				Collections.sort(conversionRulesPageInfos);
 			} catch (CoreException e) {
 				String errorMsg = "CoreException while retrieving model infos from model util."; //$NON-NLS-1$
 				log.error(errorMsg, e);
 			}
 		}
 
 		String[] modelNames = new String[conversionRulesPageInfos.size()];
 		ConversionRulesPageInfo[] pageInfos = new ConversionRulesPageInfo[conversionRulesPageInfos.size()];
 
 		int i = 0;
 		for (ConversionRulesPageInfo pageInfo : conversionRulesPageInfos) {
 			modelNames[i] = pageInfo.getName();
 			pageInfos[i] = pageInfo;
 			i++;
 		}
 
 		domainModelCombo.setItems(modelNames);
 		domainModelCombo.setData(pageInfos);
 	}
 
 	/**
 	 * Sets data and items to display for the file format combo on <code>InitImportPageComposite</code>.
 	 * 
 	 * @param fileFormatCombo
 	 *            the file format combo
 	 */
 	public void setFormatComboData(Combo fileFormatCombo) {
 		if (tokenizerInfos == null) {
 			try {
 				tokenizerInfos = getImporterUtil().getTokenizerInfos();
 				Collections.sort(tokenizerInfos);
 			} catch (CoreException e) {
 				String errorMsg = "CoreException while retrieving tokenizer infos from importer util."; //$NON-NLS-1$
 				log.error(errorMsg, e);
 			}
 		}
 
 		String[] tokenzierIds = new String[tokenizerInfos.size()];
 
 		int i = 0;
 		for (TokenizerInfo tokenizerInfo : tokenizerInfos) {
 			tokenzierIds[i++] = tokenizerInfo.getTokenizerId();
 		}
 
 		ComboViewer viewer = new ComboViewer(fileFormatCombo);
 		viewer.setContentProvider(new ArrayContentProvider());
 		viewer.setLabelProvider(new LabelProvider() {
 			@Override
 			public String getText(Object element) {
 				return ((TokenizerInfo)element).getName();
 			}
 
 		});
 		viewer.setInput(tokenizerInfos);
 
 		// fileFormatCombo.setItems(tokenizerNames);
 		// TODO use tokenizer ids retrieved from combo viewer
 		fileFormatCombo.setData(tokenzierIds);
 	}
 
 	/**
 	 * Retrieves description of a tokenizer of the specified identifier.
 	 * 
 	 * @param tokenizerId
 	 *            the tokenizer id
 	 * @return tokenizer description
 	 */
 	public String getTokenizerDescription(String tokenizerId) {
 		try {
 			return getImporterUtil().getTokenizerDescription(tokenizerId);
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving description of tokenizer with id: " //$NON-NLS-1$
 			        + tokenizerId;
 			log.error(errorMsg, e);
 			throw new RuntimeException(errorMsg, e);
 		}
 	}
 
 	/**
 	 * Retrieves all file extensions supported by all tokenizers, mapped to their tokenizer's identifiers.
 	 * 
 	 * @return all supported file extensions mappings
 	 */
 	public Map<String, String> getAllSupportedFileExtensions() {
 		try {
 			return getImporterUtil().getSupportedFileExtensions();
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving all supported file extensions."; //$NON-NLS-1$
 			log.error(errorMsg, e);
 			throw new RuntimeException(errorMsg, e);
 		}
 	}
 
 	/**
 	 * Retrieves the charset for selected file, on the basis of selected file format (tokenizer).
 	 * 
 	 * @return the file charset
 	 */
 	public Charset getFileCharset() {
 		try {
 			return getImporterUtil().getFileCharset(getImportProcess().getFilePath(), composite.getSelectedFormatId());
 		} catch (IOException e) {
 			// do nothing
 			return null;
 		} catch (CoreException e) {
 			// do nothing
 			return null;
 		}
 	}
 
 	private void refreshSelectedData() {
 		if (composite != null && getImportProcess().shouldChangeTokenizePreview()) {
 			composite.refreshPage(getImportProcess().getFilePath());
 		}
 	}
 
 	/**
 	 * Sets the selected encoding.
 	 * 
 	 * @param charset
 	 *            the selected encoding
 	 */
 	public void setSelectedEncoding(Charset charset) {
 		this.composite.setSelectedEncoding(charset);
 	}
 
 	public IImportTokenizer getTokenizer() {
 		return importTokenizer;
 	}
 
 	private ImporterUtil getImporterUtil() {
 		return getImportWizard().getImporterUtil();
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 }