/**

 * Copyright (c) 2009 Symbian Foundation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Symbian Foundation - initial contribution.

 * Contributors:

 * Description:

 * Overview:

 * Details:

 * Platforms/Drives/Compatibility:

 * Assumptions/Requirement/Pre-requisites:

 * Failures and causes:

 */

package org.symbian.tools.wrttools.wizards.projectimport;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.dialogs.ErrorDialog;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.layout.PixelConverter;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.viewers.CheckStateChangedEvent;

import org.eclipse.jface.viewers.CheckboxTreeViewer;

import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.jface.viewers.IColorProvider;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.FocusAdapter;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.TraverseEvent;

import org.eclipse.swt.events.TraverseListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.DirectoryDialog;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.actions.WorkspaceModifyOperation;

import org.eclipse.ui.dialogs.IOverwriteQuery;

import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;

import org.eclipse.ui.internal.ide.StatusUtil;

import org.eclipse.ui.internal.wizards.datatransfer.ArchiveFileManipulations;

import org.eclipse.ui.internal.wizards.datatransfer.DataTransferMessages;

import org.eclipse.ui.internal.wizards.datatransfer.ILeveledImportStructureProvider;

import org.eclipse.ui.internal.wizards.datatransfer.TarException;

import org.eclipse.ui.internal.wizards.datatransfer.TarFile;

import org.eclipse.ui.internal.wizards.datatransfer.TarLeveledStructureProvider;

import org.eclipse.ui.internal.wizards.datatransfer.ZipLeveledStructureProvider;

import org.eclipse.ui.statushandlers.StatusManager;

import org.eclipse.ui.wizards.datatransfer.ImportOperation;

import org.symbian.tools.wrttools.Activator;

import org.symbian.tools.wrttools.util.CoreUtil;

import org.symbian.tools.wrttools.util.ProjectUtils;

@SuppressWarnings({ "restriction", "unchecked", "rawtypes" })

public class WrtProjectLocationWizardPage extends WizardPage implements IOverwriteQuery {

    private final class ProjectLabelProvider extends LabelProvider implements IColorProvider {

        public Color getBackground(Object element) {

            return null;

        }

        public Color getForeground(Object element) {

            ProjectRecord projectRecord = (ProjectRecord) element;

            if (projectRecord.hasConflicts()) {

                return getShell().getDisplay().getSystemColor(SWT.COLOR_GRAY);

            }

            return null;

        }

        public String getText(Object element) {

            return ((ProjectRecord) element).getProjectLabel();

        }

    }

    // constant from WizardArchiveFileResourceImportPage1

    private static final String[] FILE_IMPORT_MASK = { "*.zip;*.tar;*.tar.gz;*.tgz;*.wgz", "*.*" }; //$NON-NLS-1$ //$NON-NLS-2$

    /**

     * The name of the folder containing metadata information for the workspace.

     */

    public static final String METADATA_FOLDER = ".metadata"; //$NON-NLS-1$

    // Keep track of the archive that we browsed to last time

    // the wizard was invoked.

    private static String previouslyBrowsedArchive = ""; //$NON-NLS-1$

    // Keep track of the directory that we browsed to last time

    // the wizard was invoked.

    private static String previouslyBrowsedDirectory = ""; //$NON-NLS-1$

    private Text archivePathField;

    private Button browseArchivesButton;

    private Button browseDirectoriesButton;

    private Text directoryPathField;

    // The last time that the file or folder at the selected path was modified

    // to mimize searches

    private long lastModified;

    // The last selected path to minimize searches

    private String lastPath;

    private Button projectFromArchiveRadio;

    private Button projectFromDirectoryRadio;

    private CheckboxTreeViewer projectsList;

    private ProjectRecord[] selectedProjects = new ProjectRecord[0];

    /**

     * The import structure provider.

     * @since 3.4

     */

    private ILeveledImportStructureProvider structureProvider;

    private IProject[] wsProjects;

    public WrtProjectLocationWizardPage() {

        super("projectlocation", "Import WRT Projects", null);

        setDescription("Import existing WRT project created in any IDEs");

    }

    private void archiveRadioSelected() {

        if (projectFromArchiveRadio.getSelection()) {

            directoryPathField.setEnabled(false);

            browseDirectoriesButton.setEnabled(false);

            archivePathField.setEnabled(true);

            browseArchivesButton.setEnabled(true);

            updateProjectsList(archivePathField.getText());

            archivePathField.setFocus();

        }

    }

    public List<IProject> getCreatedProjects() {

        return createdProjects;

    }

    /**

     * Collect the list of .project files that are under directory into files.

     * @param files

     * @param directory

     * @param directoriesVisited

     *            Set of canonical paths of directories, used as recursion guard

     * @param monitor

     *            The monitor to report to

     * @return boolean <code>true</code> if the operation was completed.

     */

    private boolean collectProjectFilesFromDirectory(Collection files, File directory, Set directoriesVisited,

            IProgressMonitor monitor) {

        if (monitor.isCanceled()) {

            return false;

        }

        monitor.subTask(NLS.bind(DataTransferMessages.WizardProjectsImportPage_CheckingMessage, directory.getPath()));

        File[] contents = directory.listFiles();

        if (contents == null) {

            return false;

        }

        // Initialize recursion guard for recursive symbolic links

        if (directoriesVisited == null) {

            directoriesVisited = new HashSet();

            try {

                directoriesVisited.add(directory.getCanonicalPath());

            } catch (IOException exception) {

                StatusManager.getManager().handle(

                        StatusUtil.newStatus(IStatus.ERROR, exception.getLocalizedMessage(), exception));

            }

        }

        File dotProjectFile = ProjectUtils.isWrtProject(contents);

        if (dotProjectFile != null) {

            files.add(dotProjectFile);

            // don't search sub-directories since we can't have nested

            // projects

            return true;

        }

        // no project description found, so recurse into sub-directories

        for (int i = 0; i < contents.length; i++) {

            if (contents[i].isDirectory()) {

                if (!contents[i].getName().equals(METADATA_FOLDER)) {

                    try {

                        String canonicalPath = contents[i].getCanonicalPath();

                        if (!directoriesVisited.add(canonicalPath)) {

                            // already been here --> do not recurse

                            continue;

                        }

                    } catch (IOException exception) {

                        StatusManager.getManager().handle(

                                StatusUtil.newStatus(IStatus.ERROR, exception.getLocalizedMessage(), exception));

                    }

                    collectProjectFilesFromDirectory(files, contents[i], directoriesVisited, monitor);

                }

            }

        }

        return true;

    }

    /**

     * Collect the list of .project files that are under directory into files.

     * @param files

     * @param monitor

     *            The monitor to report to

     * @return boolean <code>true</code> if the operation was completed.

     */

    private boolean collectProjectFilesFromProvider(Collection files, Object entry, int level, IProgressMonitor monitor) {

        if (monitor.isCanceled()) {

            return false;

        }

        monitor.subTask(NLS.bind(DataTransferMessages.WizardProjectsImportPage_CheckingMessage,

                structureProvider.getLabel(entry)));

        List children = structureProvider.getChildren(entry);

        if (children == null) {

            children = new ArrayList(1);

        }

        Iterator childrenEnum = children.iterator();

        ProjectRecord projectRecord = null;

        Object infoPlist = null;

        Object dotProject = null;

        while (childrenEnum.hasNext()) {

            Object child = childrenEnum.next();

            String elementLabel = structureProvider.getLabel(child);

            if (structureProvider.isFolder(child)) {

                collectProjectFilesFromProvider(files, child, level + 1, monitor);

            } else if (elementLabel.equalsIgnoreCase(IProjectDescription.DESCRIPTION_FILE_NAME)) {

                dotProject = child;

            } else if (elementLabel.equalsIgnoreCase(CoreUtil.METADATA_FILE)) {

                infoPlist = child;

            }

        }

        if (infoPlist != null) {

            projectRecord = new ArchivedProject(infoPlist, dotProject, entry, level, structureProvider);

            files.add(projectRecord);

        }

        return true;

    }

    public void createControl(Composite parent) {

        initializeDialogUnits(parent);

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

        setControl(workArea);

        workArea.setLayout(new GridLayout());

        workArea.setLayoutData(new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL));

        createProjectsRoot(workArea);

        createProjectsList(workArea);

        restoreWidgetValues();

        Dialog.applyDialogFont(workArea);

        updateProjectsList(directoryPathField.getText().trim());

    }

    /**

     * Create the project described in record. If it is successful return true.

     * @param record

     * @return boolean <code>true</code> if successful

     * @throws InterruptedException

     */

    private boolean createExistingProject(final ProjectRecord record, IProgressMonitor monitor)

            throws InvocationTargetException, InterruptedException {

        monitor.beginTask(MessageFormat.format("Creating {0}", record.getProjectName()), IProgressMonitor.UNKNOWN);

        try {

            IProject project = ProjectUtils.createWrtProject(record.getProjectName(), null, new SubProgressMonitor(

                    monitor, 10));

            createdProjects.add(project);

            ImportOperation operation = record.getImportOperation(project, structureProvider, this);

            if (operation != null) {

                operation.setContext(getShell());

                operation.run(monitor);

            }

            return true;

        } catch (CoreException e) {

            Activator.log(e);

            return false;

        } finally {

            monitor.done();

        }

    }

    /**

     * Create the selected projects

     * @return boolean <code>true</code> if all project creations were

     *         successful.

     */

    public boolean createProjects() {

        saveWidgetValues();

        final Object[] selected = projectsList.getCheckedElements();

        createdProjects = new ArrayList();

        WorkspaceModifyOperation op = new WorkspaceModifyOperation() {

            protected void execute(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {

                try {

                    monitor.beginTask("", selected.length);

                    if (monitor.isCanceled()) {

                        throw new OperationCanceledException();

                    }

                    for (int i = 0; i < selected.length; i++) {

                        createExistingProject((ProjectRecord) selected[i], new SubProgressMonitor(monitor, 1));

                    }

                } finally {

                    monitor.done();

                }

            }

        };

        // run the new project creation operation

        try {

            getContainer().run(true, true, op);

        } catch (InterruptedException e) {

            return false;

        } catch (InvocationTargetException e) {

            // one of the steps resulted in a core exception

            Throwable t = e.getTargetException();

            String message = DataTransferMessages.WizardExternalProjectImportPage_errorMessage;

            IStatus status;

            if (t instanceof CoreException) {

                status = ((CoreException) t).getStatus();

            } else {

                status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, 1, message, t);

            }

            ErrorDialog.openError(getShell(), message, null, status);

            return false;

        }

        ArchiveFileManipulations.closeStructureProvider(structureProvider, getShell());

        return true;

    }

    /**

     * Create the checkbox list for the found projects.

     * @param workArea

     */

    private void createProjectsList(Composite workArea) {

        Label title = new Label(workArea, SWT.NONE);

        title.setText(DataTransferMessages.WizardProjectsImportPage_ProjectsListTitle);

        Composite listComposite = new Composite(workArea, SWT.NONE);

        GridLayout layout = new GridLayout();

        layout.numColumns = 2;

        layout.marginWidth = 0;

        layout.makeColumnsEqualWidth = false;

        listComposite.setLayout(layout);

        listComposite

                .setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_BOTH));

        projectsList = new CheckboxTreeViewer(listComposite, SWT.BORDER);

        GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);

        gridData.widthHint = new PixelConverter(projectsList.getControl()).convertWidthInCharsToPixels(25);

        gridData.heightHint = new PixelConverter(projectsList.getControl()).convertHeightInCharsToPixels(10);

        projectsList.getControl().setLayoutData(gridData);

        projectsList.setContentProvider(new ITreeContentProvider() {

            public void dispose() {

            }

            public Object[] getChildren(Object parentElement) {

                return null;

            }

            public Object[] getElements(Object inputElement) {

                return getProjectRecords();

            }

            public Object getParent(Object element) {

                return null;

            }

            public boolean hasChildren(Object element) {

                return false;

            }

            public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

            }

        });

        projectsList.setLabelProvider(new ProjectLabelProvider());

        projectsList.addCheckStateListener(new ICheckStateListener() {

            public void checkStateChanged(CheckStateChangedEvent event) {

                ProjectRecord element = (ProjectRecord) event.getElement();

                if (element.hasConflicts()) {

                    projectsList.setChecked(element, false);

                }

                setPageComplete(projectsList.getCheckedElements().length > 0);

            }

        });

        projectsList.setInput(this);

        projectsList.setComparator(new ViewerComparator());

        createSelectionButtons(listComposite);

    }

    /**

     * Create the area where you select the root directory for the projects.

     * @param workArea

     *            Composite

     */

    private void createProjectsRoot(Composite workArea) {

        // project specification group

        Composite projectGroup = new Composite(workArea, SWT.NONE);

        GridLayout layout = new GridLayout();

        layout.numColumns = 3;

        layout.makeColumnsEqualWidth = false;

        layout.marginWidth = 0;

        projectGroup.setLayout(layout);

        projectGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

        // new project from directory radio button

        projectFromDirectoryRadio = new Button(projectGroup, SWT.RADIO);

        projectFromDirectoryRadio.setText(DataTransferMessages.WizardProjectsImportPage_RootSelectTitle);

        // project location entry field

        this.directoryPathField = new Text(projectGroup, SWT.BORDER);

        GridData directoryPathData = new GridData(SWT.FILL, SWT.NONE, true, false);

        directoryPathData.widthHint = new PixelConverter(directoryPathField).convertWidthInCharsToPixels(25);

        directoryPathField.setLayoutData(directoryPathData);

        directoryPathField.setText(ProjectUtils.getDefaultAptanaLocation());

        // browse button

        browseDirectoriesButton = new Button(projectGroup, SWT.PUSH);

        browseDirectoriesButton.setText(DataTransferMessages.DataTransfer_browse);

        setButtonLayoutData(browseDirectoriesButton);

        // new project from archive radio button

        projectFromArchiveRadio = new Button(projectGroup, SWT.RADIO);

        projectFromArchiveRadio.setText(DataTransferMessages.WizardProjectsImportPage_ArchiveSelectTitle);

        // project location entry field

        archivePathField = new Text(projectGroup, SWT.BORDER);

        GridData archivePathData = new GridData(SWT.FILL, SWT.NONE, true, false);

        archivePathData.widthHint = new PixelConverter(archivePathField).convertWidthInCharsToPixels(25);

        archivePathField.setLayoutData(archivePathData); // browse button

        browseArchivesButton = new Button(projectGroup, SWT.PUSH);

        browseArchivesButton.setText(DataTransferMessages.DataTransfer_browse);

        setButtonLayoutData(browseArchivesButton);

        projectFromDirectoryRadio.setSelection(true);

        archivePathField.setEnabled(false);