/*
    * 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: AbstractConversionRulesSelectionPage.java
   * Created: 2009-04-29
   * Author: bmilos
   * $Id$
   */
  
  package pl.edu.agh.cast.importer.wizard.page;
  
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.layout.GridLayout;
  import org.eclipse.swt.widgets.Button;
  import org.eclipse.swt.widgets.Combo;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Label;
  
  import pl.edu.agh.cast.importer.base.converter.IImportConverter;
  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.util.ConversionRuleInfo;
  import pl.edu.agh.cast.importer.wizard.Activator;
  import pl.edu.agh.cast.importer.wizard.dialog.rule.AbstractConversionRuleConfigDialog;
  import pl.edu.agh.cast.importer.wizard.util.Messages;
  
  /**
   * Abstract class for conversion rules selection pages of the importer wizard.
   *
   * @author AGH CAST Team
   */
  public abstract class AbstractConversionRulesSelectionPage extends AbstractImportWizardPage {
  
  	private final Logger log = Activator.getLogger();
  
  	/**
  	 * The import converter responsible for the current domain model's data conversion.
  	 */
  	protected IImportConverter converter;
  
  	/**
  	 * The map of existing conversion rules to the comboboxes that handle their configuration.
  	 */
  	protected Map<Class<? extends IConversionRule>, Combo> ruleCombosMap;
  
  	/**
  	 * The conversion rules' information.
  	 */
  	protected List<ConversionRuleInfo> ruleInfos;
  
  	private Button saveTemplateBtn;
  
  	private boolean savePermamanetSelection;
  
  	protected AbstractConversionRulesSelectionPage(String pageName, String description) {
  		super(pageName, description);
  	}
  
  	/**
  	 * {@inheritDoc}
  	 *
  	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
  	 */
  	@Override
  	public void createControl(Composite parent) {
  		final Composite composite = new Composite(parent, SWT.NULL);
  		composite.setLayout(new GridLayout());
  
  		final Composite convRulesComposite = createConvRulesComposite(composite);
  
  		saveTemplateBtn = new Button(composite, SWT.CHECK);
  		saveTemplateBtn.setText(Messages.AbstractConversionRulesSelectionPage_SaveAsTemplate);
  		saveTemplateBtn.setLayoutData(new GridData(SWT.END, SWT.END, false, false, 0, 0));
  		saveTemplateBtn.addSelectionListener(new SelectionAdapter() {
  			@Override
  			public void widgetSelected(SelectionEvent e) {
  				widgetModified();
  			}
  		});
  
  		if (savePermamanetSelection) {
 			saveTemplateBtn.setSelection(true);
 			saveTemplateBtn.setEnabled(false);
 		}
 
 		convRulesComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 0, 0));
 		setControl(composite);
 	}
 
 	public boolean isSaveTemplateSelected() {
 		return saveTemplateBtn.getSelection();
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractImportWizardPage#canFlipToNextPage()
 	 */
 	@Override
 	public boolean canFlipToNextPage() {
 		return super.canFlipToNextPage() && saveTemplateBtn.getSelection();
 	}
 
 	/**
 	 * This method marks flag that template from import process must be saved.
 	 */
 	public void setMustSaveTemplate() {
 		savePermamanetSelection = true;
 	}
 
 	protected abstract Composite createConvRulesComposite(Composite parent);
 
 	/**
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see pl.edu.agh.cast.importer.wizard.page.AbstractImportWizardPage#initPage()
 	 */
 	@Override
 	public void initPage() {
 		refreshSelectedData();
 	}
 
 	/**
 	 * Method is a delegate of a protected method <code>WizardPage.isCurrentPage</code>. Returns whether this page is
 	 * the current one in the wizard's container.
 	 *
 	 * @return <code>true</code> if the page is active, and <code>false</code> otherwise
 	 */
 	public boolean isCurrentWizardPage() {
 		return isCurrentPage();
 	}
 
 	/**
 	 * Checks whether the comboboxes in the curent rules selection page should be blocked or unblocked due to the change
 	 * in rule selection.
 	 *
 	 * @param oldRule
 	 *            the rule that had been selected previously
 	 * @param newRule
 	 *            the rule that had been selected recently
 	 * @param ruleClazz
 	 *            the class of the selected rule
 	 */
 	public void checkBlocking(IConversionRule oldRule, IConversionRule newRule,
 	        Class<? extends IConversionRule> ruleClazz) {
 		if (oldRule == null && newRule == null) {
 			return;
 		}
 
 		List<Combo> combosToBlock = new LinkedList<Combo>();
 		List<Combo> combosToUnblock = new LinkedList<Combo>();
 
 		Class<? extends IConversionRule> newRuleClazz = null;
 		if (newRule != null) {
 			newRuleClazz = newRule.getClass();
 		}
 
 		Class<? extends IConversionRule> oldRuleClazz = null;
 		if (oldRule != null) {
 			oldRuleClazz = oldRule.getClass();
 		}
 
 		for (Class<? extends IConversionRule> ruleInterface : ruleCombosMap.keySet()) {
 			if (ruleInterface.equals(ruleClazz)) {
 				continue;
 			}
 
 			if (newRuleClazz != null && ruleInterface.isAssignableFrom(newRuleClazz)) {
 				combosToBlock.add(ruleCombosMap.get(ruleInterface));
 			} else if (oldRuleClazz != null && ruleInterface.isAssignableFrom(oldRuleClazz)) {
 				combosToUnblock.add(ruleCombosMap.get(ruleInterface));
 			}
 		}
 
 		refreshCombosBlocking(combosToBlock, combosToUnblock, newRule);
 	}
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------ABSTRACT METHODS--------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 	/**
 	 * Method called by the previous page to refresh the selected data.
 	 */
 	public abstract void refreshSelectedData();
 
 	/**
 	 * Refreshes the conversion preview table.
 	 */
 	public abstract void refreshConversionPreview();
 
 	/**
 	 * Refreshes the blocking of comboboxes on the current rules selection page.
 	 *
 	 * @param combosToBlock
 	 *            the comboboxes to block
 	 * @param combosToUnblock
 	 *            the comboboxes to unblock
 	 * @param newRule
 	 *            the newly selected conversion rule
 	 */
 	public abstract void refreshCombosBlocking(List<Combo> combosToBlock, List<Combo> combosToUnblock,
 	        IConversionRule newRule);
 
 	/**
 	 * Checks whether the wizard can finish the import process (using the helper method
 	 * {@link AbstractConversionRulesSelectionPage#isComplete()}), and when it is, creates an appropriate converter,
 	 * sets its conversion rule values, and sets the converter for the parent wizard.
 	 *
 	 * @return <code>true</code> if the wizard can finish the import process, <code>false</code> otherwise
 	 */
 	public abstract boolean canFinish();
 
 	/**
 	 * Displays a warning box before wizard finish with an appropriate message, if necessary.
 	 *
 	 * @return the message box result
 	 */
 	public abstract int showWarningMsgBox();
 
 	/**
 	 * Returns whether the current conversion rule selection page is complete - whether all its obligatory conversion
 	 * rules are complete (are entirely configured).
 	 *
 	 * @return <code>true</code> if the wizard can finish the import process, <code>false</code> otherwise
 	 */
 	protected abstract boolean isComplete();
 
 	/*----------------------------------------------------------------------------------------------------------*/
 
 	/*
 	 * -----------------------------------------------------------------------------------------------------------
 	 * --------------------------GETTERS AND SETTERS------------------------------------------------------
 	 * -----------------------------------------------------------------------------------------------------------
 	 */
 
 	/**
 	 * Sets data and items to display for the specified ombo with conversion rule implementing a specified interface
 	 * class.
 	 *
 	 * @param convRuleCombo
 	 *            the combo for conversion rule
 	 * @param convRuleClazz
 	 *            the interface class for conversion rule
 	 */
 	public void setRuleComboData(Combo convRuleCombo, Class<?> convRuleClazz) {
 		if (ruleInfos == null) {
 			getRuleInfos();
 		}
 
 		List<ConversionRuleInfo> convRuleInfos = new LinkedList<ConversionRuleInfo>();
 		for (ConversionRuleInfo ruleInfo : ruleInfos) {
 			Class<?> ruleClazz = ruleInfo.getRuleClass();
 
 			Class<?>[] ruleInterfaces = ruleClazz.getInterfaces();
 			for (Class<?> ruleInterface : ruleInterfaces) {
 				if (ruleInterface.isAssignableFrom(convRuleClazz)) {
 					convRuleInfos.add(ruleInfo);
 					break;
 				}
 			}
 		}
 
 		String[] ruleNames = new String[convRuleInfos.size() + 1];
 		String[] ruleIds = new String[convRuleInfos.size() + 1];
 
 		int i = 0;
 		ruleNames[0] = ""; //$NON-NLS-1$
 		ruleIds[0] = null;
 		for (ConversionRuleInfo ruleInfo : convRuleInfos) {
 			i++;
 			ruleNames[i] = ruleInfo.getName();
 			ruleIds[i] = ruleInfo.getRuleId();
 		}
 
 		convRuleCombo.setItems(ruleNames);
 		convRuleCombo.setData(ruleIds);
 	}
 
 	/**
 	 * Retrieves the conversion rule identifier selected in the specified combobox.
 	 *
 	 * @param combo
 	 *            the combo, from which the selection is to be retrieved
 	 * @return selected conversion rule id
 	 */
 	public String getSelectedRuleId(Combo combo) {
 		String[] ruleIds = (String[])combo.getData();
 		int selectedIndex = combo.getSelectionIndex();
 		if (selectedIndex == -1) {
 			return null;
 		}
 		return ruleIds[combo.getSelectionIndex()];
 	}
 
 	/**
 	 * Sets the specified description label for a conversion rule with specified identifier.
 	 *
 	 * @param ruleId
 	 *            the rule identifier
 	 * @param ruleDescriptionLbl
 	 *            the rule description label
 	 */
 	public void setRuleDescriptionLabel(String ruleId, Label ruleDescriptionLbl) {
 		// retrieve description
 		try {
 			String ruleDescription = (ruleId == null) ? "" : getConversionRuleDescription(ruleId); //$NON-NLS-1$
 			if (ruleDescription != null && ruleDescription.length() > 0) {
 				ruleDescriptionLbl.setText(ruleDescription);
 			} else {
 				ruleDescriptionLbl.setText(Messages.GeneralConversionRulesSelectionPageComposite_NoRuleDesc);
 			}
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving description of conversion rule with id: " //$NON-NLS-1$
 			        + ruleId;
 			log.error(errorMsg, e);
 			throw new RuntimeException(errorMsg, e);
 		}
 	}
 
 	/**
 	 * Retrieves conversion rule instance with specified identifier.
 	 *
 	 * @param ruleId
 	 *            the rule id
 	 * @return rule instance
 	 */
 	public IConversionRule getConversionRuleInstance(String ruleId) {
 		try {
 			return getImportWizard().getImporterUtil().getConversionRuleInstance(ruleId);
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving conversion rule instance for conversion " //$NON-NLS-1$
 			        + "rule with id: " + ruleId; //$NON-NLS-1$
 			log.error(errorMsg, e);
 			throw new RuntimeException(errorMsg, e);
 		}
 
 	}
 
 	/**
 	 * Retrieves conversion rule configuration dialog for conversion rule of the specified identifier.
 	 *
 	 * @param ruleId
 	 *            the rule id
 	 * @return rule description
 	 */
 	public AbstractConversionRuleConfigDialog getConversionRuleConfigDialog(String ruleId) {
 		try {
 			return getImportWizard().getWizardUtil().getConversionRuleConfigDialogInstance(ruleId);
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving conversion rule configuration dialog for " //$NON-NLS-1$
 			        + "conversion rule with id: " + ruleId; //$NON-NLS-1$
 			log.error(errorMsg, e);
 			throw new RuntimeException(errorMsg, e);
 		}
 	}
 
 	public void setRuleCombosMap(Map<Class<? extends IConversionRule>, Combo> ruleCombosMap) {
 		this.ruleCombosMap = ruleCombosMap;
 	}
 
 	/**
 	 * Delegated method.
 	 *
 	 * {@inheritDoc}
 	 *
 	 * @see IImportConverter#preview(List)
 	 */
 	public List<TabularData> getConversionPreview(TabularData data) {
 		List<TabularData> tabDatas = new LinkedList<TabularData>();
 		tabDatas.add(data);
 		return converter.preview(tabDatas);
 	}
 
 	private void getRuleInfos() {
 		try {
 			ruleInfos = getImportWizard().getImporterUtil().getConversionRuleInfos();
 			Collections.sort(ruleInfos);
 		} catch (CoreException e) {
 			String errorMsg = "CoreException while retrieving conversion rule infos from model util."; //$NON-NLS-1$
 			log.error(errorMsg, e);
 		}
 	}
 
 	/**
 	 * Retrieves description of a conversion rule of the specified identifier.
 	 *
 	 * @param ruleId
 	 *            the rule id
 	 * @return rule description
 	 * @throws CoreException
 	 */
 	private String getConversionRuleDescription(String ruleId) throws CoreException {
 		return getImportWizard().getImporterUtil().getConversionRuleDescription(ruleId);
 	}
 
 	/*----------------------------------------------------------------------------------------------------------*/
 }