/*
 * Copyright (c) 2014-2016 Eike Stepper (Loehne, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.oomph.p2.internal.core;

import org.eclipse.oomph.p2.ProfileDefinition;
import org.eclipse.oomph.p2.Repository;
import org.eclipse.oomph.p2.core.Agent;
import org.eclipse.oomph.p2.core.BundlePool;
import org.eclipse.oomph.p2.core.P2Util;
import org.eclipse.oomph.p2.core.Profile;
import org.eclipse.oomph.util.IORuntimeException;
import org.eclipse.oomph.util.IOUtil;
import org.eclipse.oomph.util.SubMonitor;

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.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.equinox.p2.core.ProvisionException;
import org.eclipse.equinox.p2.metadata.IArtifactKey;
import org.eclipse.equinox.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.p2.metadata.IProvidedCapability;
import org.eclipse.equinox.p2.metadata.Version;
import org.eclipse.equinox.p2.query.QueryUtil;
import org.eclipse.equinox.p2.repository.IRepositoryManager;
import org.eclipse.equinox.p2.repository.artifact.ArtifactKeyQuery;
import org.eclipse.equinox.p2.repository.artifact.IArtifactDescriptor;
import org.eclipse.equinox.p2.repository.artifact.IArtifactRepository;
import org.eclipse.equinox.p2.repository.artifact.IArtifactRepositoryManager;
import org.eclipse.equinox.p2.repository.artifact.IFileArtifactRepository;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * @author Eike Stepper
 */
public final class AgentAnalyzer
{
  private final Agent agent;

  private final Map<File, AnalyzedBundlePool> bundlePools = new HashMap<File, AnalyzedBundlePool>();

  private final CountDownLatch analyzeLatch;

  private final List<Job> analyzeProfileJobs = new ArrayList<Job>();

  private Set<URI> repositoryURIs;

  private Handler handler;

  public AgentAnalyzer(Agent agent, boolean analyzeDamage, Handler handler, IProgressMonitor monitor)
  {
    this.agent = agent;
    this.handler = handler;

    Collection<Profile> allProfiles = agent.getAllProfiles();
    monitor.beginTask("Loading profiles...", allProfiles.size());

    try
    {
      for (Profile p2Profile : allProfiles)
      {
        P2CorePlugin.checkCancelation(monitor);
        if (p2Profile.isValid())
        {
          monitor.subTask(p2Profile.getProfileId());

          BundlePool p2BundlePool = p2Profile.getBundlePool();
          if (p2BundlePool != null)
          {
            File installFolder = p2Profile.getInstallFolder();
            File location = p2BundlePool.getLocation();
            if (!location.equals(installFolder))
            {
              AnalyzedBundlePool bundlePool = bundlePools.get(location);
              if (bundlePool == null)
              {
                bundlePool = new AnalyzedBundlePool(this, location);
                bundlePools.put(location, bundlePool);
              }

              bundlePool.addProfile(p2Profile, installFolder);
            }
          }
        }

        monitor.worked(1);
      }
    }
    finally
    {
      monitor.done();
    }

    if (handler != null)
    {
      handler.analyzerChanged(this);
    }

    analyzeLatch = new CountDownLatch(bundlePools.size());

    for (AnalyzedBundlePool bundlePool : bundlePools.values())
    {
      Job job = bundlePool.analyze(analyzeLatch, analyzeDamage);
      analyzeProfileJobs.add(job);
    }
  }

  public void awaitAnalyzing(IProgressMonitor monitor)
  {
    int totalWork = bundlePools.size();
    SubMonitor progress = SubMonitor.convert(monitor, "Analyzing...", totalWork).detectCancelation();
    progress.subTask("Analyzing artifacts...");

    int work = totalWork - (int)analyzeLatch.getCount();
    if (work != 0)
    {
      progress.worked(work);
    }

    try
    {
      while (!analyzeLatch.await(100, TimeUnit.MILLISECONDS))
      {
        P2CorePlugin.checkCancelation(monitor);

        int newWork = totalWork - (int)analyzeLatch.getCount();
        if (newWork != work)
        {
          progress.worked(newWork - work);
          work = newWork;
        }
      }
    }
    catch (InterruptedException ex)
    {
      //$FALL-THROUGH$
    }
    finally
    {
      progress.done();
    }
  }

  public void dispose()
  {
    handler = null;

    for (Job job : analyzeProfileJobs)
    {
      job.cancel();
    }

    analyzeProfileJobs.clear();
    bundlePools.clear();
  }

  public Map<File, AnalyzedBundlePool> getBundlePools()
  {
    return bundlePools;
  }

  public Set<URI> getRepositoryURIs()
  {
    if (repositoryURIs == null)
    {
      repositoryURIs = new HashSet<URI>();

      IArtifactRepositoryManager repositoryManager = agent.getArtifactRepositoryManager();
      // addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_ALL);
      // addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_DISABLED);
      // addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_LOCAL);
      // addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_NON_LOCAL);
      // addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_SYSTEM);
      addURIs(repositoryURIs, repositoryManager, IRepositoryManager.REPOSITORIES_NON_SYSTEM);

      for (AnalyzedBundlePool bundlePool : bundlePools.values())
      {
        // Don't use possibly damaged local bundle pools for damage repair
        repositoryURIs.remove(bundlePool.getLocation().toURI());
      }
    }

    return repositoryURIs;
  }

  private void analyzerChanged(AgentAnalyzer analyzer)
  {
    if (handler != null)
    {
      handler.analyzerChanged(analyzer);
    }
  }

  private void bundlePoolChanged(AnalyzedBundlePool bundlePool, boolean artifacts, boolean profiles)
  {
    if (handler != null)
    {
      handler.bundlePoolChanged(bundlePool, artifacts, profiles);
    }
  }

  private void profileChanged(AnalyzedProfile profile)
  {
    if (handler != null)
    {
      handler.profileChanged(profile);
    }
  }

  private void artifactChanged(AnalyzedArtifact artifact)
  {
    if (handler != null)
    {
      handler.artifactChanged(artifact);
    }
  }

  private void addURIs(Set<URI> repos, IArtifactRepositoryManager repositoryManager, int flag)
  {
    for (URI uri : repositoryManager.getKnownRepositories(flag))
    {
      repos.add(uri);
    }
  }

  /**
   * @author Eike Stepper
   */
  public interface Handler
  {
    public void analyzerChanged(AgentAnalyzer analyzer);

    public void bundlePoolChanged(AnalyzedBundlePool bundlePool, boolean artifacts, boolean profiles);

    public void profileChanged(AnalyzedProfile profile);

    public void artifactChanged(AnalyzedArtifact artifact);
  }

  /**
   * @author Eike Stepper
   */
  public static final class AnalyzedBundlePool implements Comparable<AnalyzedBundlePool>
  {
    private final AgentAnalyzer analyzer;

    private final File location;

    private final Set<URI> repositoryURIs = new LinkedHashSet<URI>();

    private final List<AnalyzedProfile> profiles = new ArrayList<AnalyzedProfile>();

    private final Map<IArtifactKey, AnalyzedArtifact> artifacts = new HashMap<IArtifactKey, AnalyzedArtifact>();

    private final Set<AnalyzedArtifact> unusedArtifacts = new HashSet<AnalyzedArtifact>();

    private final Set<AnalyzedArtifact> damagedArtifacts = new HashSet<AnalyzedArtifact>();

    private int damagedArtifactsPercent;

    private AnalyzedArtifact[] artifactsArray;

    private AnalyzedArtifact[] unusedArtifactsArray;

    private AnalyzedArtifact[] damagedArtifactsArray;

    private IFileArtifactRepository p2BundlePool;

    private boolean analyzing = true;

    private boolean analyzingDamage = true;

    public AnalyzedBundlePool(AgentAnalyzer analyzer, File location)
    {
      this.analyzer = analyzer;
      this.location = location;
    }

    public boolean isAnalyzing()
    {
      return analyzing;
    }

    public AgentAnalyzer getAnalyzer()
    {
      return analyzer;
    }

    public File getLocation()
    {
      return location;
    }

    public Set<URI> getRepositoryURIs()
    {
      return repositoryURIs;
    }

    public int getProfilesCount()
    {
      synchronized (this)
      {
        return profiles.size();
      }
    }

    public AnalyzedProfile[] getProfiles()
    {
      synchronized (this)
      {
        return profiles.toArray(new AnalyzedProfile[profiles.size()]);
      }
    }

    public AnalyzedProfile[] getUnusedProfiles()
    {
      List<AnalyzedProfile> unusedProfiles = new ArrayList<AnalyzedProfile>();

      synchronized (this)
      {
        for (AnalyzedProfile profile : profiles)
        {
          if (profile.isUnused())
          {
            unusedProfiles.add(profile);
          }
        }
      }

      return unusedProfiles.toArray(new AnalyzedProfile[unusedProfiles.size()]);
    }

    public int getUnusedProfilesCount()
    {
      int count = 0;

      synchronized (this)
      {
        for (AnalyzedProfile profile : profiles)
        {
          if (profile.isUnused())
          {
            ++count;
          }
        }
      }

      return count;
    }

    public int getArtifactCount()
    {
      synchronized (this)
      {
        return artifacts.size();
      }
    }

    public AnalyzedArtifact[] getArtifacts()
    {
      synchronized (this)
      {
        if (artifactsArray == null)
        {
          artifactsArray = artifacts.values().toArray(new AnalyzedArtifact[artifacts.size()]);
          Arrays.sort(artifactsArray);
        }

        return artifactsArray;
      }
    }

    public AnalyzedArtifact getArtifact(IArtifactKey key)
    {
      synchronized (this)
      {
        return artifacts.get(key);
      }
    }

    public int getUnusedArtifactsCount()
    {
      synchronized (this)
      {
        return unusedArtifacts.size();
      }
    }

    public AnalyzedArtifact[] getUnusedArtifacts()
    {
      synchronized (this)
      {
        if (unusedArtifactsArray == null)
        {
          unusedArtifactsArray = unusedArtifacts.toArray(new AnalyzedArtifact[unusedArtifacts.size()]);
          Arrays.sort(unusedArtifactsArray);
        }

        return unusedArtifactsArray;
      }
    }

    public int getDamagedArtifactsPercent()
    {
      return damagedArtifactsPercent;
    }

    public int getDamagedArtifactsCount()
    {
      synchronized (damagedArtifacts)
      {
        return damagedArtifacts.size();
      }
    }

    public AnalyzedArtifact[] getDamagedArtifacts()
    {
      synchronized (this)
      {
        if (damagedArtifactsArray == null)
        {
          damagedArtifactsArray = damagedArtifacts.toArray(new AnalyzedArtifact[damagedArtifacts.size()]);
          Arrays.sort(damagedArtifactsArray);
        }

        return damagedArtifactsArray;
      }
    }

    public boolean isAnalyzingDamage()
    {
      return analyzingDamage;
    }

    public int compareTo(AnalyzedBundlePool o)
    {
      return location.getAbsolutePath().compareTo(o.getLocation().getAbsolutePath());
    }

    @Override
    public String toString()
    {
      return location.toString();
    }

    synchronized IFileArtifactRepository getP2BundlePool(IProgressMonitor monitor)
    {
      if (p2BundlePool == null)
      {
        try
        {
          IArtifactRepositoryManager repositoryManager = analyzer.agent.getArtifactRepositoryManager();
          p2BundlePool = (IFileArtifactRepository)repositoryManager.loadRepository(location.toURI(), monitor);
        }
        catch (ProvisionException ex)
        {
          throw new IllegalStateException(ex);
        }
      }

      return p2BundlePool;
    }

    AnalyzedProfile addProfile(Profile p2Profile, File installFolder)
    {
      AnalyzedProfile profile = new AnalyzedProfile(this, p2Profile, installFolder);
      repositoryURIs.addAll(profile.getRepositoryURIs());

      synchronized (this)
      {
        profiles.add(profile);
        Collections.sort(profiles);
      }

      return profile;
    }

    Job analyze(final CountDownLatch analyzeLatch, final boolean analyzeDamage)
    {
      Job job = new Job("Analyzing bundle pool " + location)
      {
        @Override
        protected IStatus run(IProgressMonitor monitor)
        {
          analyze(analyzeDamage, monitor);
          analyzeLatch.countDown();
          return Status.OK_STATUS;
        }
      };

      job.schedule();
      return job;
    }

    private void analyze(boolean analyzeDamage, IProgressMonitor monitor)
    {
      Random random = new Random(System.currentTimeMillis());

      IFileArtifactRepository p2BundlePool = getP2BundlePool(monitor);
      for (IArtifactKey key : P2Util.asIterable(p2BundlePool.query(ArtifactKeyQuery.ALL_KEYS, monitor)))
      {
        P2CorePlugin.checkCancelation(monitor);

        File file = p2BundlePool.getArtifactFile(key);
        AnalyzedArtifact artifact = new AnalyzedArtifact(this, key, file);

        synchronized (this)
        {
          artifacts.put(key, artifact);
          artifactsArray = null;
        }

        if (random.nextInt(100) < 2)
        {
          analyzer.bundlePoolChanged(this, false, false);
        }
      }

      analyzer.bundlePoolChanged(this, true, false);

      for (AnalyzedProfile profile : getProfiles())
      {
        P2CorePlugin.checkCancelation(monitor);
        profile.analyze(monitor);
      }

      analyzer.analyzerChanged(analyzer);

      analyzeUnusedArtifacts(monitor);
      analyzing = false;

      if (analyzeDamage)
      {
        analyzeDamagedArtifacts(monitor);
      }
    }

    private void analyzeUnusedArtifacts(IProgressMonitor monitor)
    {
      for (AnalyzedArtifact artifact : getArtifacts())
      {
        P2CorePlugin.checkCancelation(monitor);
        if (analyzeUnusedArtifact(artifact, monitor))
        {
          synchronized (this)
          {
            unusedArtifacts.add(artifact);
            unusedArtifactsArray = null;
          }

          analyzer.bundlePoolChanged(this, false, false);
        }
      }

      analyzer.bundlePoolChanged(this, true, false);
    }

    private boolean analyzeUnusedArtifact(AnalyzedArtifact artifact, IProgressMonitor monitor)
    {
      for (AnalyzedProfile profile : getProfiles())
      {
        P2CorePlugin.checkCancelation(monitor);
        if (profile.getArtifacts().contains(artifact))
        {
          return false;
        }
      }

      return true;
    }

    private void analyzeDamagedArtifacts(IProgressMonitor monitor)
    {
      AnalyzedArtifact[] artifacts = getArtifacts();
      int total = artifacts.length;
      int i = 0;

      for (AnalyzedArtifact artifact : artifacts)
      {
        P2CorePlugin.checkCancelation(monitor);

        int percent = ++i * 100 / total;
        if (percent != damagedArtifactsPercent)
        {
          damagedArtifactsPercent = percent;
          analyzer.bundlePoolChanged(this, false, false);
        }

        synchronized (artifact)
        {
          IArtifactKey key = artifact.getKey();
          if (getArtifact(key) == null)
          {
            // Continue with next artifact if this artifact was deleted meanwhile
            continue;
          }
        }

        monitor.subTask("Validating " + artifact);
        if (isDamaged(artifact))
        {
          synchronized (this)
          {
            damagedArtifacts.add(artifact);
            damagedArtifactsArray = null;
          }

          analyzer.bundlePoolChanged(this, false, false);

          artifact.setDamaged();
          analyzer.artifactChanged(artifact);
        }
      }

      analyzer.bundlePoolChanged(this, false, false);
      analyzingDamage = false;
    }

    @SuppressWarnings("restriction")
    private static boolean isDamaged(AnalyzedArtifact artifact)
    {
      File file = artifact.getFile();
      if (file == null || !file.exists())
      {
        return true;
      }

      if (file.isFile())
      {
        ZipFile zipFile = null;

        try
        {
          zipFile = new ZipFile(file);
          Enumeration<? extends ZipEntry> entries = zipFile.entries();
          if (!entries.hasMoreElements())
          {
            return true;
          }

          do
          {
            ZipEntry entry = entries.nextElement();

            entry.getName();
            entry.getCompressedSize();
            entry.getCrc();

            InputStream inputStream = null;

            try
            {
              inputStream = zipFile.getInputStream(entry);
              if (inputStream == null)
              {
                return true;
              }
            }
            finally
            {
              IOUtil.close(inputStream);
            }
          } while (entries.hasMoreElements());
        }
        catch (Exception ex)
        {
          return true;
        }
        finally
        {
          try
          {
            if (zipFile != null)
            {
              zipFile.close();
            }
          }
          catch (IOException ex)
          {
            throw new IORuntimeException(ex);
          }
        }
      }

      try
      {
        String type = artifact.getType();
        org.eclipse.equinox.p2.publisher.AbstractPublisherAction action;
        String namespace;
        if (AnalyzedArtifact.TYPE_FEATURE.equals(type))
        {
          action = new org.eclipse.equinox.p2.publisher.eclipse.FeaturesAction(new File[] { file });
          namespace = "org.eclipse.update.feature";
        }
        else if (AnalyzedArtifact.TYPE_PLUGIN.equals(type))
        {
          action = new org.eclipse.equinox.p2.publisher.eclipse.BundlesAction(new File[] { file });
          namespace = "osgi.bundle";
        }
        else
        {
          return false;
        }

        org.eclipse.equinox.p2.publisher.PublisherInfo info = new org.eclipse.equinox.p2.publisher.PublisherInfo();
        org.eclipse.equinox.p2.publisher.PublisherResult result = new org.eclipse.equinox.p2.publisher.PublisherResult();
        action.perform(info, result, new NullProgressMonitor());
        IArtifactKey key = artifact.getKey();
        String id = key.getId();
        Version version = key.getVersion();
        for (Iterator<IInstallableUnit> it = result.everything(); it.hasNext();)
        {
          IInstallableUnit iu = it.next();
          for (IProvidedCapability capability : iu.getProvidedCapabilities())
          {
            String name = capability.getName();
            String capabilityNamespace = capability.getNamespace();
            Version capabilityVersion = capability.getVersion();
            if (namespace.equals(capabilityNamespace) && id.equals(name) && version.equals(capabilityVersion))
            {
              return false;
            }
          }
        }
      }
      catch (Exception exception)
      {
        return true;
      }

      return true;
    }
  }

  /**
   * @author Eike Stepper
   */
  public static final class AnalyzedProfile implements Comparable<AnalyzedProfile>
  {
    public static final String ECLIPSE = "Eclipse";

    public static final String TARGLET = "Targlet";

    public static final String UNKNOWN = "Unknown";

    @Deprecated
    private static final String PROP_TARGLET_CONTAINER_ID = "targlet.container.id";

    private final AnalyzedBundlePool bundlePool;

    private final Profile p2Profile;

    private final File installFolder;

    private final String type;

    private final int roots;

    private final Set<URI> repositoryURIs = new LinkedHashSet<URI>();

    private final Set<AnalyzedArtifact> artifacts = new HashSet<AnalyzedArtifact>();

    private final Set<AnalyzedArtifact> damagedArtifacts = new HashSet<AnalyzedArtifact>();

    private AnalyzedArtifact[] damagedArtifactsArray;

    public AnalyzedProfile(AnalyzedBundlePool bundlePool, Profile p2Profile, File installFolder)
    {
      this.bundlePool = bundlePool;
      this.p2Profile = p2Profile;
      this.installFolder = installFolder;

      if (p2Profile.getProperty(PROP_TARGLET_CONTAINER_ID) != null)
      {
        type = TARGLET;
      }
      else if (installFolder != null)
      {
        type = ECLIPSE;
      }
      else
      {
        type = UNKNOWN;
      }

      ProfileDefinition profileDefinition = p2Profile.getDefinition();
      roots = profileDefinition.getRequirements().size();

      for (Repository repository : profileDefinition.getRepositories())
      {
        try
        {
          repositoryURIs.add(new URI(repository.getURL()));
        }
        catch (URISyntaxException ex)
        {
          P2CorePlugin.INSTANCE.log(ex);
        }
      }
    }

    public AnalyzedBundlePool getBundlePool()
    {
      return bundlePool;
    }

    public Profile getP2Profile()
    {
      return p2Profile;
    }

    public boolean isUnused()
    {
      return !p2Profile.isUsed();
    }

    public String getID()
    {
      return p2Profile.getProfileId();
    }

    public File getInstallFolder()
    {
      return installFolder;
    }

    public String getType()
    {
      return type;
    }

    public final int getRoots()
    {
      return roots;
    }

    public Set<URI> getRepositoryURIs()
    {
      return repositoryURIs;
    }

    public Set<AnalyzedArtifact> getArtifacts()
    {
      return artifacts;
    }

    public boolean isDamaged()
    {
      synchronized (bundlePool)
      {
        return !damagedArtifacts.isEmpty();
      }
    }

    public int getDamagedArtifactsCount()
    {
      synchronized (bundlePool)
      {
        return damagedArtifacts.size();
      }
    }

    public AnalyzedArtifact[] getDamagedArtifacts()
    {
      synchronized (bundlePool)
      {
        if (damagedArtifactsArray == null)
        {
          damagedArtifactsArray = damagedArtifacts.toArray(new AnalyzedArtifact[damagedArtifacts.size()]);
          Arrays.sort(damagedArtifactsArray);
        }

        return damagedArtifactsArray;
      }
    }

    public int compareTo(AnalyzedProfile o)
    {
      return getID().compareTo(o.getID());
    }

    @Override
    public String toString()
    {
      return getID();
    }

    void analyze(IProgressMonitor monitor)
    {
      for (IInstallableUnit iu : P2Util.asIterable(p2Profile.query(QueryUtil.createIUAnyQuery(), monitor)))
      {
        for (IArtifactKey key : iu.getArtifacts())
        {
          AnalyzedArtifact artifact = bundlePool.getArtifact(key);
          if (artifact != null)
          {
            synchronized (bundlePool)
            {
              artifacts.add(artifact);
              artifact.addProfile(this);
            }

            bundlePool.analyzer.profileChanged(this);
          }
        }
      }
    }

    public synchronized void delete(IProgressMonitor monitor)
    {
      if (isUnused())
      {
        monitor.subTask("Deleting " + this);
        p2Profile.delete();

        boolean artifactsChanged = false;
        synchronized (bundlePool)
        {
          for (AnalyzedArtifact artifact : artifacts)
          {
            if (artifact.profiles.remove(this))
            {
              artifactsChanged = true;

              if (artifact.profiles.isEmpty())
              {
                bundlePool.unusedArtifacts.add(artifact);
                bundlePool.unusedArtifactsArray = null;
              }
            }
          }

          bundlePool.profiles.remove(this);
        }

        bundlePool.analyzer.bundlePoolChanged(bundlePool, true, true);
        bundlePool.analyzer.profileChanged(this);

        if (artifactsChanged)
        {
          bundlePool.analyzer.artifactChanged(null);
        }
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  public static final class AnalyzedArtifact implements Comparable<AnalyzedArtifact>
  {
    public static final String REPAIR_TASK_NAME = "Repairing artifacts";

    public static final String TYPE_FEATURE = "Feature";

    public static final String TYPE_PLUGIN = "Plugin";

    public static final String TYPE_BINARY = "Binary";

    private final AnalyzedBundlePool bundlePool;

    private final IArtifactKey key;

    private final String type;

    private final File file;

    private final List<AnalyzedProfile> profiles = new ArrayList<AnalyzedProfile>();

    private boolean damaged;

    public AnalyzedArtifact(AnalyzedBundlePool bundlePool, IArtifactKey key, File file)
    {
      this.bundlePool = bundlePool;
      this.key = key;
      this.file = file;

      String classifier = key.getClassifier();
      if ("org.eclipse.update.feature".equals(classifier))
      {
        type = TYPE_FEATURE;
      }
      else if ("osgi.bundle".equals(classifier))
      {
        type = TYPE_PLUGIN;
      }
      else
      {
        type = TYPE_BINARY;
      }
    }

    public boolean isUnused()
    {
      return profiles.isEmpty();
    }

    public boolean isDamaged()
    {
      return damaged;
    }

    public AnalyzedBundlePool getBundlePool()
    {
      return bundlePool;
    }

    public IArtifactKey getKey()
    {
      return key;
    }

    public String getType()
    {
      return type;
    }

    public String getID()
    {
      return key.getId();
    }

    public String getVersion()
    {
      return key.getVersion().toString();
    }

    public File getFile()
    {
      return file;
    }

    public List<AnalyzedProfile> getProfiles()
    {
      return profiles;
    }

    public int compareTo(AnalyzedArtifact o)
    {
      int result = key.getId().compareTo(o.key.getId());
      if (result == 0)
      {
        result = key.getVersion().compareTo(o.key.getVersion());
        if (result == 0)
        {
          result = type.compareTo(o.type);
        }
      }

      return result;
    }

    @Override
    public int hashCode()
    {
      final int prime = 31;
      int result = 1;
      result = prime * result + (key == null ? 0 : key.hashCode());
      return result;
    }

    @Override
    public boolean equals(Object obj)
    {
      if (this == obj)
      {
        return true;
      }

      if (obj == null)
      {
        return false;
      }

      if (getClass() != obj.getClass())
      {
        return false;
      }

      AnalyzedArtifact other = (AnalyzedArtifact)obj;
      if (key == null)
      {
        if (other.key != null)
        {
          return false;
        }
      }
      else if (!key.equals(other.key))
      {
        return false;
      }

      return true;
    }

    @Override
    public String toString()
    {
      return key.getId() + " " + key.getVersion();
    }

    void addProfile(AnalyzedProfile profile)
    {
      profiles.add(profile);
    }

    void setDamaged()
    {
      damaged = true;
      for (AnalyzedProfile profile : profiles)
      {
        synchronized (bundlePool)
        {
          profile.damagedArtifacts.add(this);
          profile.damagedArtifactsArray = null;
        }

        bundlePool.analyzer.handler.profileChanged(profile);
      }
    }

    public synchronized void delete(IProgressMonitor monitor)
    {
      if (isUnused())
      {
        deleteUnused(monitor);
      }
      else
      {
        monitor.subTask("Deleting " + this);
        IOUtil.deleteBestEffort(file);
        damaged = true;

        synchronized (bundlePool)
        {
          bundlePool.damagedArtifacts.add(this);
          bundlePool.damagedArtifactsArray = null;
        }

        bundlePool.analyzer.bundlePoolChanged(bundlePool, false, false);
        bundlePool.analyzer.artifactChanged(this);

        for (AnalyzedProfile profile : profiles)
        {
          synchronized (bundlePool)
          {
            profile.damagedArtifacts.add(this);
            profile.damagedArtifactsArray = null;
          }

          bundlePool.analyzer.profileChanged(profile);
        }
      }
    }

    private void deleteUnused(IProgressMonitor monitor)
    {
      monitor.subTask("Deleting " + this);
      IFileArtifactRepository p2BundlePool = bundlePool.getP2BundlePool(monitor);
      p2BundlePool.removeDescriptor(key, monitor);
      damaged = false;

      synchronized (bundlePool)
      {
        bundlePool.artifacts.remove(key);
        bundlePool.artifactsArray = null;

        bundlePool.unusedArtifacts.remove(this);
        bundlePool.unusedArtifactsArray = null;

        bundlePool.damagedArtifacts.remove(this);
        bundlePool.damagedArtifactsArray = null;
      }

      bundlePool.analyzer.bundlePoolChanged(bundlePool, true, false);
    }

    public synchronized boolean repair(Set<URI> repositoryURIs, IProgressMonitor monitor)
    {
      if (!damaged)
      {
        return false;
      }

      if (isUnused())
      {
        deleteUnused(monitor);
        return true;
      }

      monitor.subTask("Repairing " + this);
      if (repositoryURIs == null ? doRepair(monitor) : doRepair(repositoryURIs, monitor))
      {
        damaged = false;
        bundlePool.analyzer.artifactChanged(this);

        synchronized (bundlePool)
        {
          bundlePool.damagedArtifacts.remove(this);
          bundlePool.damagedArtifactsArray = null;
        }

        for (AnalyzedProfile profile : profiles)
        {
          synchronized (bundlePool)
          {
            profile.damagedArtifacts.remove(this);
            profile.damagedArtifactsArray = null;
          }

          bundlePool.analyzer.profileChanged(profile);
        }

        bundlePool.analyzer.bundlePoolChanged(bundlePool, false, false);
        return true;
      }

      return false;
    }

    private boolean doRepair(IProgressMonitor monitor)
    {
      Set<URI> repositoryURIs = bundlePool.getRepositoryURIs();
      SubMonitor progress = SubMonitor.convert(monitor, 1 + repositoryURIs.size()).detectCancelation();

      Set<URI> poolURIs = new HashSet<URI>();
      for (AnalyzedBundlePool pool : bundlePool.analyzer.getBundlePools().values())
      {
        if (pool != bundlePool)
        {
          AnalyzedArtifact otherArtifact = pool.getArtifact(key);
          if (otherArtifact != null && !otherArtifact.isDamaged())
          {
            URI uri = pool.getLocation().toURI();
            poolURIs.add(uri);
          }
        }
      }

      if (!poolURIs.isEmpty())
      {
        if (doRepair(poolURIs, progress))
        {
          return true;
        }
      }

      if (!repositoryURIs.isEmpty())
      {
        if (doRepair(repositoryURIs, progress))
        {
          return true;
        }
      }

      return false;
    }

    private boolean doRepair(Set<URI> repositoryURIs, IProgressMonitor monitor)
    {
      SubMonitor progress = SubMonitor.convert(monitor, repositoryURIs.size()).detectCancelation();
      for (URI uri : repositoryURIs)
      {
        if (doRepair(uri, progress.newChild()))
        {
          return true;
        }
      }

      return false;
    }

    private boolean doRepair(URI repositoryURI, SubMonitor progress)
    {
      IFileArtifactRepository p2BundlePool = bundlePool.getP2BundlePool(progress.newChild());
      IArtifactDescriptor[] localDescriptors = null;

      try
      {
        localDescriptors = p2BundlePool.getArtifactDescriptors(key);
        if (localDescriptors == null || localDescriptors.length == 0)
        {
          return false;
        }

        p2BundlePool.removeDescriptors(localDescriptors, progress.newChild());

        IArtifactRepositoryManager repositoryManager = bundlePool.analyzer.agent.getArtifactRepositoryManager();
        IArtifactRepository repository = repositoryManager.loadRepository(repositoryURI, progress.newChild());
        progress.setTaskName(REPAIR_TASK_NAME);

        IArtifactDescriptor[] remoteDescriptors = repository.getArtifactDescriptors(key);
        for (IArtifactDescriptor remoteDescriptor : remoteDescriptors)
        {
          OutputStream destination = null;

          try
          {
            destination = p2BundlePool.getOutputStream(localDescriptors[0]);

            IStatus status = repository.getArtifact(remoteDescriptor, destination, progress.newChild());
            if (status.getSeverity() == IStatus.OK)
            {
              localDescriptors = null;
              return true;
            }
          }
          finally
          {
            IOUtil.close(destination);
          }
        }
      }
      catch (OperationCanceledException ex)
      {
        throw ex;
      }
      catch (Error err)
      {
        throw err;
      }
      catch (Exception ex)
      {
        P2CorePlugin.INSTANCE.log(ex);
      }
      finally
      {
        restoreDescriptors(p2BundlePool, localDescriptors);
      }

      return false;
    }

    private void restoreDescriptors(IFileArtifactRepository p2BundlePool, IArtifactDescriptor[] oldDescriptors)
    {
      if (oldDescriptors != null && oldDescriptors.length != 0)
      {
        try
        {
          p2BundlePool.addDescriptors(oldDescriptors, new NullProgressMonitor());
        }
        catch (Exception ex)
        {
          P2CorePlugin.INSTANCE.log(ex);
        }
      }
    }
  }
}