EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The content of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.io.wizard;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.UUID;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

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.DirectoryDialog;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Text;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.service.IClassificationService;

import eu.etaxonomy.cdm.io.cdmLight.CdmLightExportConfigurator;

import eu.etaxonomy.cdm.io.common.ExportConfiguratorBase;

import eu.etaxonomy.cdm.io.csv.caryophyllales.out.CsvNameExportConfigurator;

import eu.etaxonomy.cdm.io.csv.redlist.demo.CsvDemoExportConfigurator;

import eu.etaxonomy.cdm.io.dwca.out.DwcaTaxExportConfigurator;

import eu.etaxonomy.cdm.io.jaxb.JaxbExportConfigurator;

import eu.etaxonomy.cdm.io.sdd.out.SDDExportConfigurator;

import eu.etaxonomy.cdm.io.tcsxml.out.TcsXmlExportConfigurator;

import eu.etaxonomy.cdm.model.taxon.Classification;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

import eu.etaxonomy.taxeditor.datasource.CdmDataSourceRepository;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSourceException;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * <p>

 * ExportToFileDestinationWizardPage class.

 * </p>

 *

 * @author n.hoffmann

 * @created 15.06.2009

 * @version 1.0

 */

public class ExportToFileDestinationWizardPage extends WizardPage implements SelectionListener {

	/** Constant <code>DATE_FORMAT_NOW="yyyyMMddHHmm"</code> */

	public static final String DATE_FORMAT_NOW = "yyyyMMddHHmm";

	/** Constant <code>JAXB_EXPORT="JAXB_EXPORT"</code> */

	public static final String JAXB_EXPORT = "JAXB_EXPORT";

	/** Constant <code>TCS_EXPORT="TCS_EXPORT"</code> */

	public static final String TCS_EXPORT = "TCS_EXPORT";

	/** Constant <code>SDD_EXPORT="SDD_EXPORT"</code> */

	public static final String SDD_EXPORT = "SDD_EXPORT";

	public static final String DWCA_EXPORT = "DWCA_EXPORT";

	public static final String OUTPUT_MODEL_EXPORT = "CDM_LIGHT(CSV)";

	public static final String CSV_EXPORT = "CSV_EXPORT";

	public static final String CSV_NAME_EXPORT = "CSV_NAME_EXPORT";

	private static final String CSV_PRINT_EXPORT ="CSV_PRINT_EXPORT";

	private static final String EXPORT_FOLDER ="EXPORT_FOLDER";

	public static final String XML = "xml";

	public static final String CSV = "csv";

	public static final String ZIP = "zip";

    private boolean csvExport = false;

    private boolean csvNameExport = false;

	private boolean csvPrintExport = false;

	private boolean outputModelExport = false;

	private boolean dwcaExport = false;

	private DirectoryDialog folderDialog;

	private Text text_exportFileName;

	private Text text_folder;

	private final String type;

	private final String extension;

    private Combo classificationSelectionCombo;

    private List<Classification> classifications;

    private Classification selectedClassification;

    private Label classificationLabel;

    private ExportConfiguratorBase configurator;

    private Button checkUseSelectedtaxonNode;

    private Button checkUseSelectedClassification;

	protected ExportToFileDestinationWizardPage(String pageName, String type,

			String title, String description, String extension, ExportConfiguratorBase configurator) {

		super(pageName);

		this.configurator = configurator;

		this.type = type;

		switch(type) {

		   case CSV_EXPORT :

			   csvExport = true;

			   break;

		   case CSV_NAME_EXPORT:

			   csvNameExport = true;

			   break;

		   case OUTPUT_MODEL_EXPORT:

			   outputModelExport = true;

			   break;

		   case CSV_PRINT_EXPORT:

			   csvPrintExport = true;

			   break;

		   case DWCA_EXPORT:

			   dwcaExport = true;

			   break;

		}

		this.extension = extension;

		this.setTitle(title);

		this.setDescription(description);

	}

	public static ExportToFileDestinationWizardPage Jaxb(JaxbExportConfigurator configurator) {

		return new ExportToFileDestinationWizardPage(

				JAXB_EXPORT,

				"jaxb",

				"JAXB Export",

				"Exports the content of the currently selected database into the cdm jaxb format.",

				XML, configurator);

	}

	public static ExportToFileDestinationWizardPage Tcs(TcsXmlExportConfigurator config) {

		return new ExportToFileDestinationWizardPage(

				TCS_EXPORT,

				"tcs",

				"Tcs Export",

				"Export the content of the currently selected database into TCS format.",

				XML, config);

	}

	public static ExportToFileDestinationWizardPage Sdd(SDDExportConfigurator config) {

		return new ExportToFileDestinationWizardPage(

				SDD_EXPORT,

				"sdd",

				"Sdd Export",

				"Export the content of the currently selected database into SDD format.",

				XML, config);

	}

	public static ExportToFileDestinationWizardPage Dwca(DwcaTaxExportConfigurator config) {

		return new ExportToFileDestinationWizardPage(

				DWCA_EXPORT,

				DWCA_EXPORT,

				"DwC-Archive Export",

				"Export the content of the currently selected database into Darwin Core Archive format.",

				ZIP, config);

	}

    public static ExportToFileDestinationWizardPage OutputModel(CdmLightExportConfigurator config) {

        return new ExportToFileDestinationWizardPage(

                OUTPUT_MODEL_EXPORT,

                OUTPUT_MODEL_EXPORT,

                "CDM Light Export (csv)",

                "Export the content of the currently selected database into the CDM light (csv) format.",

                CSV,config);

    }

    public static ExportToFileDestinationWizardPage Csv(CsvDemoExportConfigurator config) {

        return new ExportToFileDestinationWizardPage(

                CSV_EXPORT,

                CSV_EXPORT,

                "CSV Export",

                "Export the content of the currently selected database into Comma Separated Value format.",

                CSV, config);

    }

    public static ExportToFileDestinationWizardPage CsvNames(CsvNameExportConfigurator config) {

        return new ExportToFileDestinationWizardPage(

                CSV_NAME_EXPORT,

                CSV_NAME_EXPORT,

                "CSV Name Export",

                "Export the names of the currently selected database into Semicolon Separated Value format.",

                CSV, config);

    }

    public static ExportToFileDestinationWizardPage CsvPrint(CsvNameExportConfigurator config) {

        return new ExportToFileDestinationWizardPage(

                CSV_PRINT_EXPORT,

                CSV_NAME_EXPORT,

                "CSV Print Export",

                "Export the content of the currently selected database into Semicolon Separated Value format.",

                CSV, config);

    }

	/** {@inheritDoc} */

	@Override

    public void createControl(Composite parent) {

		setPageComplete(false);

		Composite composite = new Composite(parent, SWT.NONE);

		GridLayout gridLayout = new GridLayout();

		gridLayout.numColumns = 2;

		TaxonNode node = null;

		composite.setLayout(gridLayout);

		if(classifications == null){

			classifications = CdmStore.getService(IClassificationService.class).list(null, null, null, null, null);

			Collections.sort(classifications, new Comparator<Classification>() {

                @Override

                public int compare(Classification o1, Classification o2) {

                    if (o1.equals(o2)){

                        return 0;

                    }

                    int result = o1.getTitleCache().compareTo(o2.getTitleCache());

                    if (result == 0){

                        return o1.getUuid().compareTo(o2.getUuid());

                    }

                    return result;

                }

            });

			if (!configurator.getTaxonNodeFilter().getClassificationFilter().isEmpty()){

				selectedClassification = CdmStore.getService(IClassificationService.class).load(configurator.getTaxonNodeFilter().getClassificationFilter().get(0).getUuid());

			}else{

				selectedClassification = classifications.iterator().next();

			}

		}

		if(csvExport || csvPrintExport || outputModelExport|| csvNameExport || dwcaExport){

			if ((outputModelExport || dwcaExport)&& !configurator.getTaxonNodeFilter().getSubtreeFilter().isEmpty()){

				Composite selectNodeOrClassification = new Composite(composite, SWT.NONE);

				GridLayout grid = new GridLayout();

				grid.numColumns = 1;

				selectNodeOrClassification.setLayout(grid);

				checkUseSelectedtaxonNode= new Button(selectNodeOrClassification,  SWT.RADIO);

				String taxonStr = "";

				node = CdmApplicationState.getCurrentAppConfig().getTaxonNodeService().load(configurator.getTaxonNodeFilter().getSubtreeFilter().get(0).getUuid());

				if (node.hasTaxon()){

					taxonStr = node.getTaxon().getName().getTitleCache();

				}

				checkUseSelectedtaxonNode.setText("Export selected subtree ("+  taxonStr+")");

				checkUseSelectedtaxonNode.addListener(SWT.Selection, new Listener() {

					@Override

					public void handleEvent(Event e) {

						Button b = (Button) e.widget;

		                GridData data = (GridData)  classificationSelectionCombo.getLayoutData();

		                data.exclude = b.getSelection();

		                classificationSelectionCombo.setVisible(!data.exclude);

		                classificationLabel.setVisible(!data.exclude);

		            	}

		        	});

				  checkUseSelectedtaxonNode.setSelection(true);

				  checkUseSelectedClassification= new Button(selectNodeOrClassification,  SWT.RADIO);

				  checkUseSelectedClassification.setText("Export complete classification");

				  checkUseSelectedClassification.addListener(SWT.Selection, new Listener() {

		               @Override

		               public void handleEvent(Event e) {

		            	   Button b = (Button) e.widget;

		                   GridData data = (GridData)  classificationSelectionCombo.getLayoutData();

		                   data.exclude = b.getSelection();

		                   classificationSelectionCombo.setVisible(data.exclude);

		                   classificationLabel.setVisible(data.exclude);

		                  }

				  	});

			}

			if (node!= null){

				selectedClassification = node.getClassification();

			}

			createClassificationSelectionCombo(composite);

			classificationSelectionCombo.setLayoutData(new GridData(SWT.FILL, SWT.FILL,

			                true, false, 2, 1));

			if (checkUseSelectedtaxonNode != null){

				if (checkUseSelectedtaxonNode.getSelection()){

					 classificationSelectionCombo.setVisible(false);

	                 classificationLabel.setVisible(false);

				}

			}

		}

		Label folderLabel = new Label(composite, SWT.NONE);

		folderLabel.setText("Select Folder for exported files");

		folderLabel.setLayoutData(new GridData(SWT.FILL, SWT.FILL,

        true, false, 2, 1));

		folderDialog = new DirectoryDialog(parent.getShell());

		folderDialog.setFilterPath(PreferencesUtil.getPreferenceStore().getString(EXPORT_FOLDER));

		text_folder = new Text(composite, SWT.BORDER);

		text_folder.setEditable(false);

		text_folder.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true,

				false));

		if (PreferencesUtil.getPreferenceStore().getString(EXPORT_FOLDER) != null){

			text_folder.setText(PreferencesUtil.getPreferenceStore().getString(EXPORT_FOLDER));

			setPageComplete(true);

		}

		Button button = new Button(composite, SWT.PUSH);

		button.setText("Browse...");

		button.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				super.widgetSelected(e);

				String path = folderDialog.open();

				if (path != null) { // a folder was selected

					text_folder.setText(path);

					PreferencesUtil.getPreferenceStore().setValue(EXPORT_FOLDER, path);

					setPageComplete(true);

				}

			}

		});

		if (!outputModelExport){

			 Label fileLabel = new Label(composite, SWT.NONE);

		        fileLabel.setText("File");

	    		text_exportFileName = new Text(composite, SWT.BORDER);

	    		text_exportFileName.setText(generateFilename());

	    		text_exportFileName.setLayoutData(new GridData(SWT.FILL, SWT.FILL,

	    				true, false));

		}

		// make the composite the wizard pages control

		setControl(composite);

	}

	protected String generateFilename() {

		StringBuffer buffer = new StringBuffer();

		Calendar cal = Calendar.getInstance();

		SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);

		buffer.append(sdf.format(cal.getTime()));

		buffer.append("-");

		buffer.append(type + "_export-");

		try {

			buffer.append(CdmDataSourceRepository.getCurrentCdmSource());

		} catch (CdmRemoteSourceException e) {

			buffer.append("Unknown");

		}

		buffer.append(".");

		buffer.append(extension);

		return buffer.toString();

	}

	public String getExportFileName() {

		return text_exportFileName.getText();

	}

	public String getFolderText() {

		return text_folder.getText();

	}

	public Text getFolderComposite() {

		return text_folder;

	}

	private void createClassificationSelectionCombo(Composite parent){

		Composite classificationSelection = new Composite(parent, SWT.NULL);

		classificationSelection.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, false, 2, 1));

		GridLayout layout = new GridLayout();

		classificationSelection.setLayout(layout);

		classificationLabel = new Label(classificationSelection, SWT.NULL);

		// TODO not working is not really true but leave it here to remind everyone that this is under construction

		classificationLabel.setText("Export complete classification");

		classificationSelectionCombo = new Combo(classificationSelection, SWT.BORDER | SWT.READ_ONLY);

		classificationSelectionCombo.setLayoutData(new GridData(SWT.FILL, SWT.TOP, true, true, 2,1));

		for(Classification tree : classifications){

			classificationSelectionCombo.add(tree.getName().getText(), classifications.indexOf(tree));

		}

		classificationSelectionCombo.select(classifications.indexOf(selectedClassification));

		// TODO remember last selection

		classificationSelectionCombo.addSelectionListener(this);

		//return classificationSelection;

	}

	public Combo getCombo(){

	    return classificationSelectionCombo;

	}

	@Override

	public void widgetSelected(SelectionEvent e) {

		selectedClassification = classifications.get(classificationSelectionCombo.getSelectionIndex());

	}

	@Override

	public void widgetDefaultSelected(SelectionEvent e) {

		//not needed here

	}

	public UUID getSelectedClassificationUUID() {

		return selectedClassification.getUuid();

	}

	public boolean getCheckUseSelectedTaxonNode() {

		if (checkUseSelectedtaxonNode== null){

			return false;

		}

		return checkUseSelectedtaxonNode.getSelection();

	}

	@Override

	public boolean canFlipToNextPage() {

        return  getFolderText() != null;

    }

}