/*********************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
**********************************************************************/

package org.eclipse.virgo.ide.eclipse.wizards;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
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.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.corext.util.Messages;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.wizards.ClassPathDetector;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.wizards.JavaCapabilityConfigurationPage;
import org.eclipse.jdt.ui.wizards.NewJavaProjectWizardPageTwo;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;

/**
 * SpringSource Tool Suite Team - This class was copied from Eclipse 3.4 for use in 3.3-based distributions. Necessary
 * changes included porting all the NewJavaProjectWizard messages from the NewWizardMessages utility class to
 * NewJavaProjectWizardConstants.
 *
 * @deprecated As of release 2.0.0, STS only supports Eclipse 3.4 and above. Use {@link NewJavaProjectWizardPageTwo}
 *             instead. ----------------------------------------------------------------------------- The second page of
 *             the New Java project wizard. It allows to configure the build path and output location. As addition to
 *             the {@link JavaCapabilityConfigurationPage}, the wizard page does an early project creation (so that
 *             linked folders can be defined) and, if an existing external location was specified, detects the class
 *             path.
 *             <p>
 *             Clients may instantiate or subclass.
 *             </p>
 *             <p>
 *             <strong>EXPERIMENTAL</strong> This class or interface has been added as part of a work in progress. This
 *             API is under review and may still change when finalized. Please send your comments to bug 160985.
 *             </p>
 * @since 3.4
 */
@SuppressWarnings("restriction")
@Deprecated
public class NewJavaProjectWizardPageTwoCOPY extends JavaCapabilityConfigurationPage {

    private static final String FILENAME_PROJECT = ".project"; //$NON-NLS-1$

    private static final String FILENAME_CLASSPATH = ".classpath"; //$NON-NLS-1$

    private static URI getRealLocation(String projectName, URI location) {
        if (location == null) { // inside workspace
            try {
                URI rootLocation = ResourcesPlugin.getWorkspace().getRoot().getLocationURI();

                location = new URI(rootLocation.getScheme(), null, Path.fromPortableString(rootLocation.getPath()).append(projectName).toString(),
                    null);
            } catch (URISyntaxException e) {
                Assert.isTrue(false, "Can't happen"); //$NON-NLS-1$
            }
        }
        return location;
    }

    /**
     * Sets whether building automatically is enabled in the workspace or not and returns the old value.
     *
     * @param state <code>true</code> if automatically building is enabled, <code>false</code> otherwise
     * @return the old state
     * @throws CoreException thrown if the operation failed
     */
    public static boolean setAutoBuilding(boolean state) throws CoreException {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IWorkspaceDescription desc = workspace.getDescription();
        boolean isAutoBuilding = desc.isAutoBuilding();
        if (isAutoBuilding != state) {
            desc.setAutoBuilding(state);
            workspace.setDescription(desc);
        }
        return isAutoBuilding;
    }

    private final NewJavaProjectWizardPageOneCOPY fFirstPage;

    private URI fCurrProjectLocation; // null if location is platform location

    private IProject fCurrProject;

    private boolean fKeepContent;

    private File fDotProjectBackup;

    private File fDotClasspathBackup;

    private Boolean fIsAutobuild;

    private HashSet fOrginalFolders;

    /**
     * Constructor for the {@link NewJavaProjectWizardPageTwoCOPY}.
     *
     * @param mainPage the first page of the wizard
     */
    public NewJavaProjectWizardPageTwoCOPY(NewJavaProjectWizardPageOneCOPY mainPage) {
        this.fFirstPage = mainPage;
        this.fCurrProjectLocation = null;
        this.fCurrProject = null;
        this.fKeepContent = false;

        this.fDotProjectBackup = null;
        this.fDotClasspathBackup = null;
        this.fIsAutobuild = null;
    }

    private IStatus changeToNewProject() {
        class UpdateRunnable implements IRunnableWithProgress {

            public IStatus infoStatus = Status.OK_STATUS;

            public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                try {
                    if (NewJavaProjectWizardPageTwoCOPY.this.fIsAutobuild == null) {
                        NewJavaProjectWizardPageTwoCOPY.this.fIsAutobuild = Boolean.valueOf(setAutoBuilding(false));
                    }
                    this.infoStatus = updateProject(monitor);
                } catch (CoreException e) {
                    throw new InvocationTargetException(e);
                } catch (OperationCanceledException e) {
                    throw new InterruptedException();
                } finally {
                    monitor.done();
                }
            }
        }
        UpdateRunnable op = new UpdateRunnable();
        try {
            getContainer().run(true, false, new WorkspaceModifyDelegatingOperation(op));
            return op.infoStatus;
        } catch (InvocationTargetException e) {
            final String title = NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_error_title;
            final String message = NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_error_message;
            ExceptionHandler.handle(e, getShell(), title, message);
        } catch (InterruptedException e) {
            // cancel pressed
        }
        return null;
    }

    private void copyFile(File source, IFileStore target, IProgressMonitor monitor) throws IOException, CoreException {
        FileInputStream is = new FileInputStream(source);
        OutputStream os = target.openOutputStream(EFS.NONE, monitor);
        copyFile(is, os);
    }

    private void copyFile(IFileStore source, File target) throws IOException, CoreException {
        InputStream is = source.openInputStream(EFS.NONE, null);
        FileOutputStream os = new FileOutputStream(target);
        copyFile(is, os);
    }

    private void copyFile(InputStream is, OutputStream os) throws IOException {
        try {
            byte[] buffer = new byte[8192];
            while (true) {
                int bytesRead = is.read(buffer);
                if (bytesRead == -1) {
                    break;
                }

                os.write(buffer, 0, bytesRead);
            }
        } finally {
            try {
                is.close();
            } finally {
                os.close();
            }
        }
    }

    private File createBackup(IFileStore source, String name) throws CoreException {
        try {
            File bak = File.createTempFile("eclipse-" + name, ".bak"); //$NON-NLS-1$//$NON-NLS-2$
            copyFile(source, bak);
            return bak;
        } catch (IOException e) {
            IStatus status = new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR,
                Messages.format(NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_problem_backup, name), e);
            throw new CoreException(status);
        }
    }

    /**
     * Creates the provisional project on which the wizard is working on. The provisional project is typically created
     * when the page is entered the first time. The early project creation is required to configure linked folders.
     *
     * @return the provisional project
     */
    protected IProject createProvisonalProject() {
        IStatus status = changeToNewProject();
        if (status != null && !status.isOK()) {
            ErrorDialog.openError(getShell(), NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_error_title, null, status);
        }
        return this.fCurrProject;
    }

    private void deleteProjectFile(URI projectLocation) throws CoreException {
        IFileStore file = EFS.getStore(projectLocation);
        if (file.fetchInfo().exists()) {
            IFileStore projectFile = file.getChild(FILENAME_PROJECT);
            if (projectFile.fetchInfo().exists()) {
                projectFile.delete(EFS.NONE, null);
            }
        }
    }

    private final void doRemoveProject(IProgressMonitor monitor) throws InvocationTargetException {
        final boolean noProgressMonitor = this.fCurrProjectLocation == null; // inside
        // workspace
        if (monitor == null || noProgressMonitor) {
            monitor = new NullProgressMonitor();
        }
        monitor.beginTask(NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_operation_remove, 3);
        try {
            try {
                URI projLoc = this.fCurrProject.getLocationURI();

                boolean removeContent = !this.fKeepContent && this.fCurrProject.isSynchronized(IResource.DEPTH_INFINITE);
                if (!removeContent) {
                    restoreExistingFolders(projLoc);
                }
                this.fCurrProject.delete(removeContent, false, new SubProgressMonitor(monitor, 2));

                restoreExistingFiles(projLoc, new SubProgressMonitor(monitor, 1));
            } finally {
                setAutoBuilding(this.fIsAutobuild.booleanValue()); // fIsAutobuild
                // must
                // be
                // set
                this.fIsAutobuild = null;
            }
        } catch (CoreException e) {
            throw new InvocationTargetException(e);
        } finally {
            monitor.done();
            this.fCurrProject = null;
            this.fKeepContent = false;
        }
    }

    private boolean hasExistingContent(URI realLocation) throws CoreException {
        IFileStore file = EFS.getStore(realLocation);
        return file.fetchInfo().exists();
    }

    /**
     * Evaluates the new build path and output folder according to the settings on the first page. The resulting build
     * path is set by calling {@link #init(IJavaProject, IPath, IClasspathEntry[], boolean)}. Clients can override this
     * method.
     *
     * @param javaProject the new project which is already created when this method is called.
     * @param monitor the progress monitor
     * @throws CoreException thrown when initializing the build path failed
     */
    @SuppressWarnings("unchecked")
    protected void initializeBuildPath(IJavaProject javaProject, IProgressMonitor monitor) throws CoreException {
        if (monitor == null) {
            monitor = new NullProgressMonitor();
        }
        monitor.beginTask(NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_monitor_init_build_path, 2);

        try {
            IClasspathEntry[] entries = null;
            IPath outputLocation = null;
            IProject project = javaProject.getProject();

            if (this.fKeepContent) {
                if (!project.getFile(FILENAME_CLASSPATH).exists()) {
                    final ClassPathDetector detector = new ClassPathDetector(this.fCurrProject, new SubProgressMonitor(monitor, 2));
                    entries = detector.getClasspath();
                    outputLocation = detector.getOutputLocation();
                    if (entries.length == 0) {
                        entries = null;
                    }
                } else {
                    monitor.worked(2);
                }
            } else {
                List cpEntries = new ArrayList();
                IWorkspaceRoot root = project.getWorkspace().getRoot();

                IClasspathEntry[] sourceClasspathEntries = this.fFirstPage.getSourceClasspathEntries();
                for (IClasspathEntry sourceClasspathEntrie : sourceClasspathEntries) {
                    IPath path = sourceClasspathEntrie.getPath();
                    if (path.segmentCount() > 1) {
                        IFolder folder = root.getFolder(path);
                        CoreUtility.createFolder(folder, true, true, new SubProgressMonitor(monitor, 1));
                    }
                    cpEntries.add(sourceClasspathEntrie);
                }

                cpEntries.addAll(Arrays.asList(this.fFirstPage.getDefaultClasspathEntries()));

                entries = (IClasspathEntry[]) cpEntries.toArray(new IClasspathEntry[cpEntries.size()]);

                outputLocation = this.fFirstPage.getOutputLocation();
                if (outputLocation.segmentCount() > 1) {
                    IFolder folder = root.getFolder(outputLocation);
                    CoreUtility.createDerivedFolder(folder, true, true, new SubProgressMonitor(monitor, 1));
                }
            }
            if (monitor.isCanceled()) {
                throw new OperationCanceledException();
            }

            init(javaProject, outputLocation, entries, false);
        } finally {
            monitor.done();
        }
    }

    /**
     * Called from the wizard on cancel.
     */
    public void performCancel() {
        if (this.fCurrProject != null) {
            removeProvisonalProject();
        }
    }

    /**
     * Called from the wizard on finish.
     *
     * @param monitor the progress monitor
     * @throws CoreException thrown when the project creation or configuration failed
     * @throws InterruptedException thrown when the user cancelled the project creation
     */
    @SuppressWarnings("unchecked")
    public void performFinish(IProgressMonitor monitor) throws CoreException, InterruptedException {
        try {
            monitor.beginTask(NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_operation_create, 3);
            if (this.fCurrProject == null) {
                updateProject(new SubProgressMonitor(monitor, 1));
            }
            configureJavaProject(new SubProgressMonitor(monitor, 2));

            if (!this.fKeepContent) {
                String compliance = this.fFirstPage.getCompilerCompliance();
                if (compliance != null) {
                    IJavaProject project = JavaCore.create(this.fCurrProject);
                    Map options = project.getOptions(false);
                    // JavaModelUtil.setCompilanceOptions(options, compliance);
                    JavaCore.setComplianceOptions(compliance, options);
                    JavaModelUtil.setDefaultClassfileOptions(options, compliance); // complete
                    // compliance
                    // options
                    project.setOptions(options);
                }
            }
        } finally {
            monitor.done();
            this.fCurrProject = null;
            if (this.fIsAutobuild != null) {
                setAutoBuilding(this.fIsAutobuild.booleanValue());
                this.fIsAutobuild = null;
            }
        }
    }

    @SuppressWarnings("unchecked")
    private void rememberExisitingFolders(URI projectLocation) {
        this.fOrginalFolders = new HashSet();

        try {
            IFileStore[] children = EFS.getStore(projectLocation).childStores(EFS.NONE, null);
            for (IFileStore child : children) {
                IFileInfo info = child.fetchInfo();
                if (info.isDirectory() && info.exists() && !this.fOrginalFolders.contains(child.getName())) {
                    this.fOrginalFolders.add(child);
                }
            }
        } catch (CoreException e) {
            JavaPlugin.log(e);
        }
    }

    private void rememberExistingFiles(URI projectLocation) throws CoreException {
        this.fDotProjectBackup = null;
        this.fDotClasspathBackup = null;

        IFileStore file = EFS.getStore(projectLocation);
        if (file.fetchInfo().exists()) {
            IFileStore projectFile = file.getChild(FILENAME_PROJECT);
            if (projectFile.fetchInfo().exists()) {
                this.fDotProjectBackup = createBackup(projectFile, "project-desc"); //$NON-NLS-1$
            }
            IFileStore classpathFile = file.getChild(FILENAME_CLASSPATH);
            if (classpathFile.fetchInfo().exists()) {
                this.fDotClasspathBackup = createBackup(classpathFile, "classpath-desc"); //$NON-NLS-1$
            }
        }
    }

    /**
     * Removes the provisional project. The provisional project is typically removed when the user cancels the wizard or
     * goes back to the first page.
     */
    protected void removeProvisonalProject() {
        if (!this.fCurrProject.exists()) {
            this.fCurrProject = null;
            return;
        }

        IRunnableWithProgress op = new IRunnableWithProgress() {

            public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
                doRemoveProject(monitor);
            }
        };

        try {
            getContainer().run(true, true, new WorkspaceModifyDelegatingOperation(op));
        } catch (InvocationTargetException e) {
            final String title = NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_error_remove_title;
            final String message = NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_error_remove_message;
            ExceptionHandler.handle(e, getShell(), title, message);
        } catch (InterruptedException e) {
            // cancel pressed
        }
    }

    private void restoreExistingFiles(URI projectLocation, IProgressMonitor monitor) throws CoreException {
        int ticks = ((this.fDotProjectBackup != null ? 1 : 0) + (this.fDotClasspathBackup != null ? 1 : 0)) * 2;
        monitor.beginTask("", ticks); //$NON-NLS-1$
        try {
            IFileStore projectFile = EFS.getStore(projectLocation).getChild(FILENAME_PROJECT);
            projectFile.delete(EFS.NONE, new SubProgressMonitor(monitor, 1));
            if (this.fDotProjectBackup != null) {
                copyFile(this.fDotProjectBackup, projectFile, new SubProgressMonitor(monitor, 1));
            }
        } catch (IOException e) {
            IStatus status = new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR,
                NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_problem_restore_project, e);
            throw new CoreException(status);
        }
        try {
            IFileStore classpathFile = EFS.getStore(projectLocation).getChild(FILENAME_CLASSPATH);
            classpathFile.delete(EFS.NONE, new SubProgressMonitor(monitor, 1));
            if (this.fDotClasspathBackup != null) {
                copyFile(this.fDotClasspathBackup, classpathFile, new SubProgressMonitor(monitor, 1));
            }
        } catch (IOException e) {
            IStatus status = new Status(IStatus.ERROR, JavaUI.ID_PLUGIN, IStatus.ERROR,
                NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_problem_restore_classpath, e);
            throw new CoreException(status);
        }
    }

    private void restoreExistingFolders(URI projectLocation) {
        try {
            IFileStore[] children = EFS.getStore(projectLocation).childStores(EFS.NONE, null);
            for (IFileStore child : children) {
                IFileInfo info = child.fetchInfo();
                if (info.isDirectory() && info.exists() && !this.fOrginalFolders.contains(child)) {
                    child.delete(EFS.NONE, null);
                    this.fOrginalFolders.remove(child);
                }
            }

            for (Iterator iterator = this.fOrginalFolders.iterator(); iterator.hasNext();) {
                IFileStore deleted = (IFileStore) iterator.next();
                deleted.mkdir(EFS.NONE, null);
            }
        } catch (CoreException e) {
            JavaPlugin.log(e);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.jface.dialogs.IDialogPage#setVisible(boolean)
     */
    @Override
    public void setVisible(boolean visible) {
        boolean isShownFirstTime = visible && this.fCurrProject == null;
        if (visible) {
            if (isShownFirstTime) { // entering from the first page
                createProvisonalProject();
            }
        } else {
            if (getContainer().getCurrentPage() == this.fFirstPage) { // leaving
                // back to
                // the first
                // page
                removeProvisonalProject();
            }
        }
        super.setVisible(visible);
        if (isShownFirstTime) {
            setFocus();
        }
    }

    private final IStatus updateProject(IProgressMonitor monitor) throws CoreException, InterruptedException {
        IStatus result = StatusInfo.OK_STATUS;
        if (monitor == null) {
            monitor = new NullProgressMonitor();
        }
        try {
            monitor.beginTask(NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_operation_initialize, 7);
            if (monitor.isCanceled()) {
                throw new OperationCanceledException();
            }

            String projectName = this.fFirstPage.getProjectName();

            this.fCurrProject = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
            this.fCurrProjectLocation = this.fFirstPage.getProjectLocationURI();

            URI realLocation = getRealLocation(projectName, this.fCurrProjectLocation);
            this.fKeepContent = hasExistingContent(realLocation);

            if (monitor.isCanceled()) {
                throw new OperationCanceledException();
            }

            if (this.fKeepContent) {
                rememberExistingFiles(realLocation);
                rememberExisitingFolders(realLocation);
            }

            if (monitor.isCanceled()) {
                throw new OperationCanceledException();
            }

            try {
                createProject(this.fCurrProject, this.fCurrProjectLocation, new SubProgressMonitor(monitor, 2));
            } catch (CoreException e) {
                if (e.getStatus().getCode() == IResourceStatus.FAILED_READ_METADATA) {
                    result = new StatusInfo(IStatus.INFO, Messages.format(
                        NewJavaProjectWizardConstants.NewJavaProjectWizardPageTwo_DeleteCorruptProjectFile_message, e.getLocalizedMessage()));

                    deleteProjectFile(realLocation);
                    if (this.fCurrProject.exists()) {
                        this.fCurrProject.delete(true, null);
                    }

                    createProject(this.fCurrProject, this.fCurrProjectLocation, null);
                } else {
                    throw e;
                }
            }

            if (monitor.isCanceled()) {
                throw new OperationCanceledException();
            }

            initializeBuildPath(JavaCore.create(this.fCurrProject), new SubProgressMonitor(monitor, 2));
            configureJavaProject(new SubProgressMonitor(monitor, 3)); // create
            // the
            // Java
            // project
            // to
            // allow
            // the
            // use
            // of
            // the
            // new
            // source
            // folder
            // page
        } finally {
            monitor.done();
        }
        return result;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.jdt.ui.wizards.JavaCapabilityConfigurationPage#useNewSourcePage ()
     */
    @Override
    protected final boolean useNewSourcePage() {
        return true;
    }
}