/*
    * 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: GeneralConversionRulesSelectionPage.java
   * Created: 2009-04-01
   * Author: bmilos
   * $Id$
   */
  
  package pl.edu.agh.cast.importer.wizard.general;
  
  import java.util.List;
  
  import org.eclipse.osgi.util.NLS;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.widgets.Combo;
  import org.eclipse.swt.widgets.Composite;
  
  import pl.edu.agh.cast.importer.base.converter.rules.IConversionRule;
  import pl.edu.agh.cast.importer.base.data.TabularData;
  import pl.edu.agh.cast.importer.base.general.GeneralImportConverter;
  import pl.edu.agh.cast.importer.base.general.IDateConversionRule;
  import pl.edu.agh.cast.importer.base.general.ISourceNodeConversionRule;
  import pl.edu.agh.cast.importer.base.general.ITargetNodeConversionRule;
  import pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage;
  import pl.edu.agh.cast.importer.wizard.util.Messages;
  import pl.edu.agh.cast.importer.wizard.utils.AbstractWizardPageHelper;
  import pl.edu.agh.cast.ui.util.MsgBoxHelper;
  
  /**
   * Page of the import wizard, which serves for selection of conversion rules for each domain field. This page is
   * specific for general domain model.
   *
   * @author AGH CAST Team
   */
  public class GeneralConversionRulesSelectionPage extends AbstractConversionRulesSelectionPage {
  
  	/**
  	 * Name of the conversion rules selection page for the general domain model.
  	 */
  	public static final String PAGE_ID = "pl.edu.agh.cast.importer.wizard.rulespage.general"; //$NON-NLS-1$
  
  	private GeneralConversionRulesSelectionPageComposite composite;
  
  	private ISourceNodeConversionRule sourceNodeRule;
  
  	private ITargetNodeConversionRule targetNodeRule;
  
  	private IDateConversionRule dateRule;
  
  	private TabularData previewDataCache;
  
  	/**
  	 * The default constructor.
  	 */
  	public GeneralConversionRulesSelectionPage() {
  		super(Messages.ImporterWizard_GeneralRulesSelectionPageTitle,
  		        Messages.ImporterWizard_GeneralRulesSelectionPageDescription);
  		converter = new GeneralImportConverter();
  	}
  
  	/**
  	 * {@inheritDoc}
  	 *
  	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#
  	 *      createConvRulesComposite(org.eclipse.swt.widgets.Composite)
  	 */
  	public Composite createConvRulesComposite(Composite parent) {
  		composite = new GeneralConversionRulesSelectionPageComposite(parent, SWT.NULL, this);
  
  		/*
  		 * The call to refreshFilePreview() is necessary, because this page is added dynamically to the wizard and thus
  		 * is initiated later than pages that had been added to the wizard in a static way. Thus the first time the page
  		 * is displayed, the file preview cannot be refreshed in the refreshSelectedData() method for the composite is
  		 * null - so it is refreshed after the composite is initialized in the createControl() method.
  		 */
  		refreshPage();
  		return composite;
  	}
  
  	/**
  	 * {@inheritDoc}
  	 *
  	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#canFinish()
  	 */
  	public boolean canFinish() {
  		if (!isComplete()) {
  			return false;
  		}
  		((GeneralImportConverter)converter).setConversionRules(sourceNodeRule, targetNodeRule, dateRule);
  		getImportProcess().setConverter(converter);
 		return true;
 	}
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------OVERRIDED METHODS-------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#isComplete()
 	 */
 	@Override
 	protected boolean isComplete() {
 		((GeneralImportConverter)converter).setConversionRules(sourceNodeRule, targetNodeRule, dateRule);
 		return converter.isComplete();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#refreshSelectedData()
 	 */
 	@Override
 	public void refreshSelectedData() {
 		TabularData data = getImportProcess().getParsedData().get(0);
 
 		boolean needsRefresh = false;
 		int previewSize = getPreviewSize(data);
 
 		if (data == null) {
 			refreshPreviewDataCache(data, previewSize);
 			needsRefresh = true;
 		} else {
 			TabularData previewData = data.retrieveDataPreview(previewSize);
 			if (previewData == null || !previewData.equals(previewDataCache)) {
 				refreshPreviewDataCache(previewData, previewSize);
 				needsRefresh = true;
 			}
 		}
 
 		if (composite != null && needsRefresh) {
 			refreshPage();
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#refreshConversionPreview()
 	 */
 	@Override
 	public void refreshConversionPreview() {
 		canFinish();
 		composite.refreshConversionPreview();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#showWarningMsgBox()
 	 */
 	@Override
 	public int showWarningMsgBox() {
 		int result = -1;
 		if (dateRule != null && !dateRule.isComplete()) {
 			result = MsgBoxHelper.showWarningQuestionBox(composite,
 			        Messages.GeneralConversionRulesSelectionPage_DateNotConfiguredWarningTitle, NLS.bind(
 			                Messages.GeneralConversionRulesSelectionPage_FieldNotConfiguredWarningMsg,
 			                Messages.GeneralConversionRulesSelectionPage_Date));
 		}
 		return result;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractConversionRulesSelectionPage#
 	 *      refreshCombosBlocking(java.util.List, java.util.List)
 	 */
 	@Override
 	public void refreshCombosBlocking(List<Combo> combosToBlock, List<Combo> combosToUnblock, IConversionRule newRule) {
 		if (combosToBlock != null && !combosToBlock.isEmpty()) {
 			this.composite.disableCombos(combosToBlock, newRule);
 		}
 
 		if (combosToUnblock != null && !combosToUnblock.isEmpty()) {
 			this.composite.enableCombos(combosToUnblock);
 		}
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------HELPER METHODS------------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	private void refreshPage() {
 		if (previewDataCache != null) {
 			composite.refreshFilePreview(previewDataCache);
 		}
 		if (sourceNodeRule != null) {
 			sourceNodeRule.clear();
 		}
 		if (targetNodeRule != null) {
 			targetNodeRule.clear();
 		}
 		if (dateRule != null) {
 			dateRule.clear();
 		}
 		refreshConversionPreview();
 	}
 
 	private void refreshPreviewDataCache(TabularData data, int previewSize) {
 		if (data == null) {
 			previewDataCache = null;
 			return;
 		}
 
 		previewDataCache = data.retrieveDataPreview(previewSize);
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------GETTERS AND SETTERS------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Retrieves the source node rule, given its identifier, and sets the resulting rule.
 	 *
 	 * @param ruleId
 	 *            the rule identifier
 	 */
 	public void setSourceNodeRule(String ruleId) {
 		ISourceNodeConversionRule rule = (ruleId == null) ? null
 		        : (ISourceNodeConversionRule)getConversionRuleInstance(ruleId);
 		setSourceNodeRule(rule);
 	}
 
 	/**
 	 * Sets the source node rule.
 	 *
 	 * @param rule
 	 *            the rule to set
 	 */
 	public void setSourceNodeRule(ISourceNodeConversionRule rule) {
 		this.sourceNodeRule = rule;
 		((GeneralImportConverter)converter).setSourceNodeRule(rule);
 	}
 
 	/**
 	 * Retrieves the target node rule, given its identifier, and sets the resulting rule.
 	 *
 	 * @param ruleId
 	 *            the rule identifier
 	 */
 	public void setTargetNodeRule(String ruleId) {
 		ITargetNodeConversionRule rule = (ruleId == null) ? null
 		        : (ITargetNodeConversionRule)getConversionRuleInstance(ruleId);
 		setTargetNodeRule(rule);
 	}
 
 	/**
 	 * Sets the target node rule.
 	 *
 	 * @param rule
 	 *            the rule to set
 	 */
 	public void setTargetNodeRule(ITargetNodeConversionRule rule) {
 		this.targetNodeRule = rule;
 		((GeneralImportConverter)converter).setTargetNodeRule(rule);
 	}
 
 	/**
 	 * Retrieves the date rule, given its identifier, and sets the resulting rule.
 	 *
 	 * @param ruleId
 	 *            the rule identifier
 	 */
 	public void setDateRule(String ruleId) {
 		IDateConversionRule rule = (ruleId == null) ? null : (IDateConversionRule)getConversionRuleInstance(ruleId);
 		setDateRule(rule);
 	}
 
 	/**
 	 * Sets the date rule.
 	 *
 	 * @param rule
 	 *            the rule to set
 	 */
 	public void setDateRule(IDateConversionRule rule) {
 		this.dateRule = rule;
 		((GeneralImportConverter)converter).setDateRule(rule);
 	}
 
 	public ISourceNodeConversionRule getSourceNodeRule() {
 		return sourceNodeRule;
 	}
 
 	public ITargetNodeConversionRule getTargetNodeRule() {
 		return targetNodeRule;
 	}
 
 	public IDateConversionRule getDateRule() {
 		return dateRule;
 	}
 
 	private int getPreviewSize(TabularData data) {
 		return (data.size() > AbstractWizardPageHelper.PREVIEW_ROWS_LIMIT_FOR_ANALYSIS) ? AbstractWizardPageHelper.PREVIEW_ROWS_LIMIT_FOR_ANALYSIS
 		        : data.size();
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 }