EDIT

package eu.etaxonomy.taxeditor.update;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.IJobChangeEvent;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.core.runtime.jobs.JobChangeAdapter;

import org.eclipse.equinox.internal.p2.ui.ProvUI;

import org.eclipse.equinox.internal.p2.ui.model.ElementUtils;

import org.eclipse.equinox.internal.p2.ui.model.MetadataRepositoryElement;

import org.eclipse.equinox.p2.core.IProvisioningAgent;

import org.eclipse.equinox.p2.core.ProvisionException;

import org.eclipse.equinox.p2.operations.ProvisioningJob;

import org.eclipse.equinox.p2.operations.ProvisioningSession;

import org.eclipse.equinox.p2.operations.Update;

import org.eclipse.equinox.p2.operations.UpdateOperation;

import org.eclipse.equinox.p2.repository.IRepository;

import org.eclipse.equinox.p2.repository.IRepositoryManager;

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepositoryManager;

import org.eclipse.equinox.p2.ui.ProvisioningUI;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.PlatformUI;

import org.osgi.framework.BundleContext;

import org.osgi.framework.ServiceReference;

import eu.etaxonomy.taxeditor.ApplicationUtil;

import eu.etaxonomy.taxeditor.TaxonomicEditorPlugin;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

/**

 * This class is a utility class for updating the editor from a p2 update site,

 * greatly inspired by the links given below.

 *

 *

 * To Do :

 * - Allow configurable update sites

 *

 * Notes :

 *

 *

 * @see http://wiki.eclipse.org/Equinox/p2/Adding_Self-Update_to_an_RCP_Application

 * @see http://bugs.eclipse.org/281226

 * @see http://www.vogella.com/tutorials/EclipseP2Update/article.html

 */

public class P2Util {

    //private static String LOCAL_UPDATE_SITE = "file:///path/.../to/Development/EDIT/taxeditor/eu.etaxonomy.taxeditor/target/repository/";

    private static String EDIT_NIGHTLY_UPDATE_SITE = "http://cybertaxonomy.eu/download/taxeditor/update/nightly/";

    private static String EDIT_NIGHTLY_UPDATE_SITE_NAME = "Taxonomic Editor Nightly";

    private static String EDIT_SNAPSHOT_UPDATE_SITE = "http://cybertaxonomy.eu/download/taxeditor/update/snapshot/";

    private static String EDIT_SNAPSHOT_UPDATE_SITE_NAME = "Taxonomic Editor Snapshot";

    private static String EDIT_STABLE_UPDATE_SITE = "http://cybertaxonomy.eu/download/taxeditor/update/stable/";

    private static String EDIT_STABLE_UPDATE_SITE_NAME = "Taxonomic Editor Stable";

    /**

     * Retrieve and load the saved list of repositories from the preference store,

     * making sure that at least the default repository is always loaded.

     */

    @SuppressWarnings("restriction")

    public static void setP2UpdateRepositories() {

        String updateSite = EDIT_NIGHTLY_UPDATE_SITE;

        String updateSiteName = EDIT_NIGHTLY_UPDATE_SITE_NAME;

        if(ApplicationUtil.isStable()) {

            updateSite = EDIT_STABLE_UPDATE_SITE;

            updateSiteName = EDIT_STABLE_UPDATE_SITE_NAME;

        }

        List<MetadataRepositoryElement> repoElements = new ArrayList<MetadataRepositoryElement>();

        List<MetadataRepositoryElement> savedRepoElements = PreferencesUtil.getP2Repositories();

        if(savedRepoElements.isEmpty()) {

            // we always need an update site, so we add the default one

            try {

                MetadataRepositoryElement element = new MetadataRepositoryElement(null, new URI(updateSite), true);

                element.setNickname(updateSiteName);

                repoElements.add(element);

            } catch (URISyntaxException e) {

                MessagingUtils.errorDialog("Invalid update site URI",

                        P2Util.class,

                        "The update site URI has an invalid syntax",

                        TaxonomicEditorPlugin.PLUGIN_ID,

                        e,

                        false);

            }

        }

        repoElements.addAll(savedRepoElements);

        ElementUtils.updateRepositoryUsingElements(ProvisioningUI.getDefaultUI(),repoElements

                .toArray(new MetadataRepositoryElement[]{} ), null);

    }

    /**

     * {@link org.eclipse.equinox.p2.ui.RepositoryManipulationPage} which handles the repsitory site list

     * in preferences does not create a preference store and hence the changes are not saved. This means

     * that we need to save it ourselves.

     *

     * This method saves the list of current repositories in the preference store as a string with

     * specific delimiters.

     */

    public static void saveP2RepositoryPreferences() {

        IMetadataRepositoryManager metaManager = ProvUI.getMetadataRepositoryManager(ProvisioningUI.getDefaultUI().getSession());

        URI[] currentlyEnabled = metaManager.getKnownRepositories(IRepositoryManager.REPOSITORIES_ALL);

        URI[] currentlyDisabled = metaManager.getKnownRepositories(IRepositoryManager.REPOSITORIES_DISABLED);

        List<MetadataRepositoryElement> repoElements = new ArrayList<MetadataRepositoryElement>();

        for(URI repo : currentlyEnabled) {

            boolean enabled = true;

            String nickname = metaManager.getRepositoryProperty(repo, IRepository.PROP_NICKNAME);

            MetadataRepositoryElement element = new MetadataRepositoryElement(null, repo, true);

            element.setNickname(nickname);

            element.setEnabled(enabled);

            repoElements.add(element);

        }

        for(URI repo : currentlyDisabled) {

            boolean enabled = false;

            String nickname = metaManager.getRepositoryProperty(repo, IRepository.PROP_NICKNAME);

            MetadataRepositoryElement element = new MetadataRepositoryElement(null, repo, true);

            element.setNickname(nickname);

            element.setEnabled(enabled);

            repoElements.add(element);

        }

        PreferencesUtil.setP2Repositories(repoElements);

    }

    /**

     *

     *

     */

    public static void checkForUpdates() {

        Job updateJob = new Job("Update Job") {

            @Override

            public IStatus run(IProgressMonitor monitor) {

                return doCheckForUpdates(monitor);

            }

        };

        updateJob.schedule();

    }

    /**

     * @param monitor

     * @return

     */

    private static IStatus doCheckForUpdates(IProgressMonitor monitor) {

     // force refresh all the caches before

        IMetadataRepositoryManager metaManager = ProvUI.getMetadataRepositoryManager(ProvisioningUI.getDefaultUI().getSession());

        URI[] repos = metaManager.getKnownRepositories(IRepositoryManager.REPOSITORIES_ALL);

        for(URI repo : repos) {

            try {

                metaManager.refreshRepository(repo, monitor);

            } catch (ProvisionException pe) {

                IStatus errorStatus = new Status(IStatus.ERROR, TaxonomicEditorPlugin.PLUGIN_ID,

                        "Error occured while reloading cache.", pe);

            } catch (OperationCanceledException oce) {

                IStatus errorStatus = new Status(IStatus.ERROR, TaxonomicEditorPlugin.PLUGIN_ID,

                        "Error occured while reloading cache.", oce);

            }

        }

        BundleContext bundleContext = TaxonomicEditorPlugin.getContext();

        ServiceReference reference = bundleContext.getServiceReference(IProvisioningAgent.SERVICE_NAME);

        if (reference == null) {

            IStatus errorStatus = new Status(IStatus.ERROR, TaxonomicEditorPlugin.PLUGIN_ID,

                    "No provisioning agent found.  This application is not set up for updates.");

            return errorStatus;

        }

        final IProvisioningAgent agent = (IProvisioningAgent) bundleContext.getService(reference);

        IStatus updateStatus;

        try {

            updateStatus = P2Util.checkForUpdates(agent, monitor);

            MessagingUtils.info(updateStatus);

        } finally {

            bundleContext.ungetService(reference);

        }

        return updateStatus;

    }

    /**

     * @param agent

     * @param monitor

     * @return

     * @throws OperationCanceledException

     */

    static IStatus checkForUpdates(IProvisioningAgent agent, final IProgressMonitor monitor) {

        ProvisioningSession session = new ProvisioningSession(agent);

        // the default update operation looks for updates to the currently

        // running profile, using the default profile root marker. To change

        // which installable units are being updated, use the more detailed

        // constructors.

        final UpdateOperation operation = new UpdateOperation(session);

//        try {

//            setUpdateRepositories(operation);

//        } catch (URISyntaxException e) {

//            MessagingUtils.errorDialog("Invalid update site URI",

//                    operation,

//                    "The update site URI has an invalid syntax",

//                    TaxonomicEditorPlugin.PLUGIN_ID,

//                    e,

//                    false);

//            return null;

//        }

        final IStatus status = operation.resolveModal(monitor);

        if (status.getCode() == UpdateOperation.STATUS_NOTHING_TO_UPDATE) {

            return status;

        }

        if (status.isOK() && status.getSeverity() != IStatus.ERROR) {

            // We need this block of code to be in async execution

            // since the confirm dialogs work only on the UI thread

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

                @Override

                public void run() {

                    String updates = "";

                    Update[] possibleUpdates = operation

                            .getPossibleUpdates();

                    for (Update update : possibleUpdates) {

                        updates += update + "\n";

                    }

                    boolean doInstall = MessagingUtils.confirmDialog("Updates available", "Do you want to install the available updates ?");

                    // We may need to think whether we still run in async mode once

                    // the user agrees to update. Maybe be reasonable to change to blocking

                    // from this point until the update is complete.

                    // More complex status handling might include showing the user what

                    // updates are available if there are multiples, differentiating

                    // patches vs. updates, etc. In this example, we simply update as

                    // suggested by the operation.

                    if(doInstall) {

                        ProvisioningJob provisioningJob = operation.getProvisioningJob(monitor);

                        if (provisioningJob == null) {

                            MessagingUtils.messageDialog("Error in performing update",

                                    operation,

                                    "ProvisioningJob could not be created." + System.getProperty("line.separator") +

                                    "Either this application does not support p2 software installation or this application has been launched from within the Eclipse IDE",

                                    null,

                                    false);

                        } else {

                            // register a job change listener to track

                            // installation progress and notify user upon success

                            provisioningJob

                            .addJobChangeListener(new JobChangeAdapter() {

                                @Override

                                public void done(IJobChangeEvent event) {

                                    if (event.getResult().isOK()) {

                                        // We need this block of code to be in async execution

                                        // since the confirm dialogs work only on the UI thread

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

                                            @Override

                                            public void run() {

                                                boolean restart = MessagingUtils.confirmDialog(

                                                        "Updates installed, restart?",

                                                        "Updates have been installed successfully, do you want to restart?");

                                                if (restart) {

                                                    PlatformUI.getWorkbench().restart();

                                                }

                                            }

                                        });

                                    }

                                    super.done(event);

                                }

                            });

                            provisioningJob.schedule();

                        }

                    }

                }

            });

        }

        return status;

    }

}