package org.symbian.tools.tmw.internal.ui.importwizard;

import java.io.File;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashSet;

import java.util.Set;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRunnable;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IExecutableExtension;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IImportWizard;

import org.eclipse.ui.INewWizard;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.statushandlers.StatusManager;

import org.eclipse.ui.wizards.newresource.BasicNewProjectResourceWizard;

import org.eclipse.wst.common.project.facet.core.FacetedProjectFramework;

import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy;

import org.eclipse.wst.common.project.facet.core.IProjectFacet;

import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;

import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;

import org.symbian.tools.tmw.core.TMWCore;

import org.symbian.tools.tmw.core.runtimes.IMobileWebRuntime;

import org.symbian.tools.tmw.internal.util.OpenFilesRunnable;

import org.symbian.tools.tmw.ui.TMWCoreUI;

import org.symbian.tools.tmw.ui.project.IApplicationImporter;

public class ApplicationImportWizard extends Wizard implements IImportWizard, INewWizard, IExecutableExtension {

    public static final String RECENT_IMPORT_PATH = "application.import.path";

    private IFile file;

    private ApplicationImportWizardPage page;

    private IConfigurationElement config;

    public ApplicationImportWizard() {

        setWindowTitle("Import WRT Application Archive");

        //        setDefaultPageImageDescriptor(WRTImages.importWgzWizardBanner());

        setNeedsProgressMonitor(true);

    }

    @Override

    public void addPages() {

        page = new ApplicationImportWizardPage(file);

        addPage(page);

    }

    private IProject createProject(String archiveName, String projectName, URI uri, IApplicationImporter importer,

            IProgressMonitor monitor) throws CoreException {

        monitor.beginTask("Importing application archive", 50);

        final IFacetedProjectWorkingCopy project = FacetedProjectFramework.createNewProject();

        final File file = new File(archiveName);

        final IMobileWebRuntime applicationRuntime = importer.getApplicationRuntime(file);

        final IRuntime runtime = TMWCore.getFProjSupport().getRuntime(applicationRuntime);

        project.setTargetedRuntimes(Collections.singleton(runtime));

        project.setPrimaryRuntime(runtime);

        project.setProjectName(projectName);

        if (uri != null) {

            final File loc = new File(uri);

            Path path = new Path(loc.getAbsolutePath());

            if (!path.removeLastSegments(1).equals(ResourcesPlugin.getWorkspace().getRoot().getLocation())) {

                project.setProjectLocation(path);

            }

        }

        final Set<IProjectFacetVersion> facets = getProjectFacetVersion(file, importer, applicationRuntime);

        project.setProjectFacets(facets);

        final Set<IProjectFacet> fcoll = new HashSet<IProjectFacet>();

        for (IProjectFacetVersion facetVersion : facets) {

            fcoll.add(facetVersion.getProjectFacet());

        }

        project.setFixedProjectFacets(fcoll);

        project.commitChanges(new SubProgressMonitor(monitor, 10));

        boolean success = false;

        try {

            importer.extractFiles(file, applicationRuntime, project.getProject(), new SubProgressMonitor(monitor, 40));

            success = true;

        } finally {

            if (!success) {

                project.getProject().delete(true, true, new NullProgressMonitor());

            }

        }

        final IFile[] toOpen = importer.getFilesToOpen(project.getProject());

        project.detect(new NullProgressMonitor());

        project.commitChanges(new NullProgressMonitor());

        monitor.done();

        if (toOpen != null && toOpen.length > 0) {

            final OpenFilesRunnable runnable = new OpenFilesRunnable(new HashSet<IFile>(Arrays.asList(toOpen)));

            Display.getDefault().asyncExec(new Runnable() {

                public void run() {

                    try {

                        runnable.run(new NullProgressMonitor());

                    } catch (InvocationTargetException e) {

                        TMWCoreUI.log(e);

                    } catch (InterruptedException e) {

                        TMWCoreUI.log(e);

                    }

                }

            });

        }

        return project.getProject();

    }

    private Set<IProjectFacetVersion> getProjectFacetVersion(final File file, IApplicationImporter importer,

            final IMobileWebRuntime applicationRuntime) {

        final Set<IProjectFacetVersion> facets = new HashSet<IProjectFacetVersion>();

        facets.addAll(TMWCore.getFProjSupport().getFixedFacetsVersions(applicationRuntime));

        final IProjectFacetVersion[] f = importer.getConfiguredFacets(file);

        if (f != null && f.length > 0) {

            facets.addAll(Arrays.asList(f));

        }

        return facets;

    }

    @Override

    public boolean performFinish() {

        try {

            final String projectName = page.getProjectName();

            final URI uri = page.getLocationURI();

            final String archiveName = page.getArchiveFile();

            final IApplicationImporter importer = page.getImporter();

            final IProject[] holder = new IProject[1];

            getContainer().run(true, true, new IRunnableWithProgress() {

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

                    try {

                        ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {

                            public void run(IProgressMonitor monitor) throws CoreException {

                                holder[0] = createProject(archiveName, projectName, uri, importer, monitor);

                            }

                        }, monitor);

                    } catch (final CoreException e) {

                        getShell().getDisplay().asyncExec(new Runnable() {

                            public void run() {

                                StatusManager.getManager().handle(e.getStatus(),

                                        StatusManager.SHOW | StatusManager.BLOCK | StatusManager.LOG);

                            }

                        });

                    }

                }

            });

            if (holder[0] != null) {

                BasicNewProjectResourceWizard.updatePerspective(config);

                TMWCoreUI.getDefault().getPreferenceStore()

                        .setValue(RECENT_IMPORT_PATH, new File(archiveName).getParentFile().getAbsolutePath());

                //                ProjectUtils.focusOn(holder[0]);

            }

        } catch (InvocationTargetException e) {

            TMWCoreUI.log(e);

        } catch (InterruptedException e) {

            TMWCoreUI.log(e);

        }

        return true;

    }

    public void init(IWorkbench workbench, IStructuredSelection selection) {

        file = null;

        if (selection instanceof IStructuredSelection && !selection.isEmpty()) {

            Object element = (selection).getFirstElement();

            if (element instanceof IAdaptable) {

                IResource resource = (IResource) ((IAdaptable) element).getAdapter(IResource.class);

                if (resource != null && resource.getType() == IResource.FILE

                        && "wgz".equalsIgnoreCase(resource.getProjectRelativePath().getFileExtension())) {

                    file = (IFile) resource;

                }

            }

        }

    }

    public void setInitializationData(IConfigurationElement config, String propertyName, Object data)

            throws CoreException {

        this.config = config;

    }

}