/*******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.core.bundle;

import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import org.eclipse.core.runtime.*;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.eclipse.osgi.service.resolver.BundleSpecification;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.pde.core.*;
import org.eclipse.pde.core.plugin.*;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.ibundle.*;
import org.eclipse.pde.internal.core.plugin.*;
import org.eclipse.pde.internal.core.text.bundle.*;
import org.osgi.framework.*;

public class BundlePluginBase extends PlatformObject implements IBundlePluginBase, Serializable {

	private static final long serialVersionUID = 1L;
	protected IBundlePluginModelBase model;
	private ArrayList libraries;
	private ArrayList imports;
	private String fTarget;

	public void reset() {
		libraries = null;
		imports = null;
	}

	public String getSchemaVersion() {
		IExtensions root = getExtensionsRoot();
		if (root instanceof AbstractExtensions)
			return ((AbstractExtensions) root).getSchemaVersion();
		return (root instanceof IPluginBase) ? ((IPluginBase) root).getSchemaVersion() : null;
	}

	public void setSchemaVersion(String value) throws CoreException {
		IExtensions root = getExtensionsRoot();
		if (root == null)
			return;
		if (root instanceof AbstractExtensions)
			((AbstractExtensions) root).setSchemaVersion(value);
		if (root instanceof IPluginBase)
			((IPluginBase) root).setSchemaVersion(value);
	}

	public void modelChanged(IModelChangedEvent event) {
		if (event.getChangeType() == IModelChangedEvent.WORLD_CHANGED) {
			if (event.getChangeProvider().equals(model.getBundleModel())) {
				reset();
			}
			getModel().fireModelChanged(event);
		} else if (!event.getChangeProvider().equals(model.getBundleModel())) {
			getModel().fireModelChanged(event);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getBundle()
	 */
	public IBundle getBundle() {
		if (model != null) {
			IBundleModel bmodel = model.getBundleModel();
			return bmodel != null ? bmodel.getBundle() : null;
		}
		return null;
	}

	protected IManifestHeader getManifestHeader(String key) {
		IBundle bundle = getBundle();
		return (bundle != null) ? bundle.getManifestHeader(key) : null;
	}

	public ISharedPluginModel getModel() {
		return model;
	}

	void setModel(IBundlePluginModelBase model) {
		this.model = model;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getExtensionsRoot()
	 */
	public IExtensions getExtensionsRoot() {
		if (model != null) {
			ISharedExtensionsModel emodel = model.getExtensionsModel();
			return emodel != null ? emodel.getExtensions() : null;
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#add(org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public void add(IPluginLibrary library) throws CoreException {
		ensureModelEditable();
		if (libraries == null)
			// if libraries == null, initialize the libraries varible by calling getLibraries()
			getLibraries();
		libraries.add(library);
		IManifestHeader header = getManifestHeader(Constants.BUNDLE_CLASSPATH);
		if (header instanceof BundleClasspathHeader) {
			((BundleClasspathHeader) header).addLibrary(library.getName());
		} else {
			addLibrary(library, header);
		}
		fireStructureChanged(library, true);
	}

	/**
	 * @param library
	 * @param header
	 */
	private void addLibrary(IPluginLibrary library, IManifestHeader header) {
		String value = header == null ? null : header.getValue();
		StringBuffer buffer = new StringBuffer(value == null ? "" : value); //$NON-NLS-1$
		if (value != null)
			buffer.append(",\n "); //$NON-NLS-1$
		buffer.append(library.getName());
		getBundle().setHeader(Constants.BUNDLE_CLASSPATH, buffer.toString());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#remove(org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public void remove(IPluginLibrary library) throws CoreException {
		ensureModelEditable();
		if (libraries != null) {
			libraries.remove(library);
			Object header = getManifestHeader(Constants.BUNDLE_CLASSPATH);
			if (header instanceof BundleClasspathHeader) {
				((BundleClasspathHeader) header).removeLibrary(library.getName());
			}
			fireStructureChanged(library, false);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#add(org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public void add(IPluginImport iimport) throws CoreException {
		ensureModelEditable();
		if (iimport == null)
			return;
		if (imports == null)
			// if imports == null, intitialize the imports list by calling getImports()
			getImports();
		addImport(iimport);
		fireStructureChanged(iimport, true);
	}

	public void add(IPluginImport[] iimports) throws CoreException {
		ensureModelEditable();
		if (iimports != null && iimports.length > 0) {
			if (imports == null)
				// if imports == null, initialize the imports list by calling getImports()
				getImports();
			for (int i = 0; i < iimports.length; i++) {
				if (iimports[i] != null)
					addImport(iimports[i]);
			}
			fireStructureChanged(iimports, true);
		}
	}

	private void addImport(IPluginImport iimport) {
		imports.add(iimport);
		Object header = getManifestHeader(Constants.REQUIRE_BUNDLE);
		if (header instanceof RequireBundleHeader) {
			((RequireBundleHeader) header).addBundle(iimport);
		} else {
			String value = header == null ? null : ((IManifestHeader) header).getValue();
			StringBuffer buffer = new StringBuffer(value == null ? "" : value); //$NON-NLS-1$
			if (value != null)
				buffer.append(",\n "); //$NON-NLS-1$
			buffer.append(iimport.getId());
			int bundleManifestVersion = getBundleManifestVersion(getBundle());
			if (iimport.isOptional())
				if (bundleManifestVersion > 1)
					buffer.append(";" + Constants.RESOLUTION_DIRECTIVE + ":=" + Constants.RESOLUTION_OPTIONAL); //$NON-NLS-1$ //$NON-NLS-2$
				else
					buffer.append(";" + ICoreConstants.OPTIONAL_ATTRIBUTE + "=true"); //$NON-NLS-1$ //$NON-NLS-2$
			if (iimport.isReexported())
				if (bundleManifestVersion > 1)
					buffer.append(";" + Constants.VISIBILITY_DIRECTIVE + ":=" + Constants.VISIBILITY_REEXPORT); //$NON-NLS-1$ //$NON-NLS-2$
				else
					buffer.append(";" + ICoreConstants.REPROVIDE_ATTRIBUTE + "=true"); //$NON-NLS-1$ //$NON-NLS-2$
			String version = iimport.getVersion();
			if (version != null && version.trim().length() > 0)
				buffer.append(";" + Constants.BUNDLE_VERSION_ATTRIBUTE + "=\"" + version.trim() + "\""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			getBundle().setHeader(Constants.REQUIRE_BUNDLE, buffer.toString());
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#remove(org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public void remove(IPluginImport pluginImport) throws CoreException {
		ensureModelEditable();
		if (imports != null) {
			imports.remove(pluginImport);
			Object header = getManifestHeader(Constants.REQUIRE_BUNDLE);
			if (header instanceof RequireBundleHeader) {
				((RequireBundleHeader) header).removeBundle(pluginImport.getId());
			}
			fireStructureChanged(pluginImport, false);
		}
	}

	public void remove(IPluginImport[] pluginImports) throws CoreException {
		ensureModelEditable();
		if (imports != null) {
			for (int i = 0; i < pluginImports.length; i++) {
				imports.remove(pluginImports[i]);
				Object header = getManifestHeader(Constants.REQUIRE_BUNDLE);
				if (header instanceof RequireBundleHeader) {
					((RequireBundleHeader) header).removeBundle(pluginImports[i].getId());
				}
			}
			fireStructureChanged(pluginImports, false);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#getLibraries()
	 */
	public IPluginLibrary[] getLibraries() {
		IBundle bundle = getBundle();
		if (bundle == null)
			return new IPluginLibrary[0];
		if (libraries == null) {
			libraries = new ArrayList();
			String value = bundle.getHeader(Constants.BUNDLE_CLASSPATH);
			if (value != null) {
				try {
					ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_CLASSPATH, value);
					for (int i = 0; i < elements.length; i++) {
						PluginLibrary library = new PluginLibrary();
						library.setModel(getModel());
						library.setInTheModel(true);
						library.setParent(this);
						library.load(elements[i].getValue());
						libraries.add(library);
					}
				} catch (BundleException e) {
				}
			}
		}
		return (IPluginLibrary[]) libraries.toArray(new IPluginLibrary[libraries.size()]);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#getImports()
	 */
	public IPluginImport[] getImports() {
		if (imports == null) {
			imports = new ArrayList();
			BundleDescription description = model.getBundleDescription();
			if (description != null) {
				BundleSpecification[] required = description.getRequiredBundles();
				for (int i = 0; i < required.length; i++) {
					PluginImport importElement = new PluginImport();
					importElement.setModel(getModel());
					importElement.setInTheModel(true);
					importElement.setParent(this);
					imports.add(importElement);
					importElement.load(required[i]);
				}
				BundleDescription[] imported = PDEStateHelper.getImportedBundles(description);
				for (int i = 0; i < imported.length; i++) {
					PluginImport importElement = new PluginImport();
					importElement.setModel(getModel());
					importElement.setInTheModel(true);
					importElement.setParent(this);
					imports.add(importElement);
					importElement.load(imported[i]);
				}
			} else {
				IBundle bundle = getBundle();
				if (bundle != null) {
					try {
						String value = bundle.getHeader(Constants.REQUIRE_BUNDLE);
						int bundleManifestVersion = getBundleManifestVersion(bundle);
						if (value != null) {
							ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, value);
							for (int i = 0; i < elements.length; i++) {
								PluginImport importElement = new PluginImport();
								importElement.setModel(getModel());
								importElement.setInTheModel(true);
								importElement.setParent(this);
								imports.add(importElement);
								importElement.load(elements[i], bundleManifestVersion);
							}
						}
					} catch (BundleException e) {
					}
				}
			}
		}
		return (IPluginImport[]) imports.toArray(new IPluginImport[imports.size()]);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#getProviderName()
	 */
	public String getProviderName() {
		IBundle bundle = getBundle();
		return bundle == null ? null : bundle.getHeader(Constants.BUNDLE_VENDOR);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#setProviderName(java.lang.String)
	 */
	public void setProviderName(String providerName) throws CoreException {
		ensureModelEditable();
		IBundle bundle = getBundle();
		if (bundle != null) {
			String old = getProviderName();
			IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_VENDOR);
			if (header instanceof BundleVendorHeader)
				((BundleVendorHeader) header).setVendor(providerName);
			else
				bundle.setHeader(Constants.BUNDLE_VENDOR, providerName);
			model.fireModelObjectChanged(this, IPluginBase.P_PROVIDER, old, providerName);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#getVersion()
	 */
	public String getVersion() {
		BundleDescription desc = model.getBundleDescription();
		if (desc != null) {
			Version version = desc.getVersion();
			return (version != null) ? version.toString() : null;
		}
		return getValue(Constants.BUNDLE_VERSION, false);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#setVersion(java.lang.String)
	 */
	public void setVersion(String version) throws CoreException {
		ensureModelEditable();
		IBundle bundle = getBundle();
		if (bundle != null) {
			String old = getVersion();
			IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_VERSION);
			if (header instanceof BundleVersionHeader)
				((BundleVersionHeader) header).setVersionRange(version);
			else
				bundle.setHeader(Constants.BUNDLE_VERSION, version);
			model.fireModelObjectChanged(this, IPluginBase.P_VERSION, old, version);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginBase#swap(org.eclipse.pde.core.plugin.IPluginLibrary,
	 *      org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public void swap(IPluginLibrary l1, IPluginLibrary l2) throws CoreException {
		ensureModelEditable();
		if (libraries != null) {
			int index1 = libraries.indexOf(l1);
			int index2 = libraries.indexOf(l2);
			libraries.set(index1, l2);
			libraries.set(index2, l1);
			Object header = getManifestHeader(Constants.BUNDLE_CLASSPATH);
			if (header instanceof BundleClasspathHeader) {
				((BundleClasspathHeader) header).swap(index1, index2);
			}
			model.fireModelObjectChanged(this, P_IMPORT_ORDER, l1, l2);
		}
	}

	protected void fireStructureChanged(Object object, boolean added) {
		int type = (added) ? IModelChangedEvent.INSERT : IModelChangedEvent.REMOVE;
		model.fireModelChanged(new ModelChangedEvent(model, type, new Object[] {object}, null));
	}

	protected void fireStructureChanged(Object[] objects, boolean added) {
		int type = (added) ? IModelChangedEvent.INSERT : IModelChangedEvent.REMOVE;
		model.fireModelChanged(new ModelChangedEvent(model, type, objects, null));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#add(org.eclipse.pde.core.plugin.IPluginExtension)
	 */
	public void add(IPluginExtension extension) throws CoreException {
		ensureModelEditable();
		IExtensions extensions = getExtensionsRoot();
		if (extensions == null)
			return;
		extensions.add(extension);

		// reset singleton
		if (getExtensions().length == 1 && getExtensionPoints().length == 0)
			updateSingleton(true);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#add(org.eclipse.pde.core.plugin.IPluginExtensionPoint)
	 */
	public void add(IPluginExtensionPoint point) throws CoreException {
		ensureModelEditable();
		IExtensions extensions = getExtensionsRoot();
		if (extensions == null)
			return;
		extensions.add(point);

		//reset singleton
		if (getExtensions().length == 0 && getExtensionPoints().length == 1)
			updateSingleton(true);
	}

	public String getResourceString(String key) {
		return model.getResourceString(key);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#getExtensionPoints()
	 */
	public IPluginExtensionPoint[] getExtensionPoints() {
		IExtensions extensions = getExtensionsRoot();
		if (extensions == null)
			return new IPluginExtensionPoint[0];
		return extensions.getExtensionPoints();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#getExtensions()
	 */
	public IPluginExtension[] getExtensions() {
		IExtensions extensions = getExtensionsRoot();
		if (extensions == null)
			return new IPluginExtension[0];
		return extensions.getExtensions();
	}

	public int getIndexOf(IPluginExtension e) {
		IExtensions extensions = getExtensionsRoot();
		if (extensions == null)
			return -1;
		return extensions.getIndexOf(e);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#remove(org.eclipse.pde.core.plugin.IPluginExtension)
	 */
	public void remove(IPluginExtension extension) throws CoreException {
		ensureModelEditable();
		IExtensions extensions = getExtensionsRoot();
		if (extensions != null) {
			extensions.remove(extension);
			// reset singleton directive
			if (getExtensions().length == 0 && getExtensionPoints().length == 0)
				updateSingleton(false);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#remove(org.eclipse.pde.core.plugin.IPluginExtensionPoint)
	 */
	public void remove(IPluginExtensionPoint extensionPoint) throws CoreException {
		ensureModelEditable();
		IExtensions extensions = getExtensionsRoot();
		if (extensions != null) {
			extensions.remove(extensionPoint);
			// reset singleton directive
			if (getExtensions().length == 0 && getExtensionPoints().length == 0)
				updateSingleton(false);
		}
	}

	protected void updateSingleton(boolean singleton) {
		IManifestHeader header = getManifestHeader(Constants.BUNDLE_SYMBOLICNAME);
		if (header instanceof BundleSymbolicNameHeader)
			((BundleSymbolicNameHeader) header).setSingleton(singleton);
		else {
			if (singleton) {
				String version = getBundle().getHeader(Constants.BUNDLE_MANIFESTVERSION);
				if (version == null)
					version = "1"; //$NON-NLS-1$
				String value = header.getValue();
				String singletonValue = null;
				if (version != null && Integer.parseInt(version) >= 2)
					singletonValue = Constants.SINGLETON_DIRECTIVE + ":=true"; //$NON-NLS-1$
				else
					singletonValue = Constants.SINGLETON_DIRECTIVE + "=true"; //$NON-NLS-1$
				if (value.indexOf(singletonValue) != -1)
					return;
				getBundle().setHeader(Constants.BUNDLE_SYMBOLICNAME, value + "; " + singletonValue); //$NON-NLS-1$
			}
			// No current need to remove singleton directive outside of text model.
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IExtensions#swap(org.eclipse.pde.core.plugin.IPluginExtension,
	 *      org.eclipse.pde.core.plugin.IPluginExtension)
	 */
	public void swap(IPluginExtension e1, IPluginExtension e2) throws CoreException {
		ensureModelEditable();
		IExtensions extensions = getExtensionsRoot();
		if (extensions != null) {
			extensions.swap(e1, e2);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.core.plugin.IPluginBase#swap(org.eclipse.pde.core.plugin.IPluginImport, org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public void swap(IPluginImport import1, IPluginImport import2) throws CoreException {
		ensureModelEditable();
		if (imports != null) {
			int index1 = imports.indexOf(import1);
			int index2 = imports.indexOf(import2);
			imports.set(index1, import2);
			imports.set(index2, import1);
			Object header = getManifestHeader(Constants.REQUIRE_BUNDLE);
			if (header instanceof RequireBundleHeader) {
				((RequireBundleHeader) header).swap(index1, index2);
			}
			model.fireModelObjectChanged(this, P_IMPORT_ORDER, import1, import2);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.IIdentifiable#getId()
	 */
	public String getId() {
		return getValue(Constants.BUNDLE_SYMBOLICNAME, true);
	}

	// The key should be a manifest header key, and parse should be true if it needs to be parsed by ManifestElement.parseHeader() 
	protected String getValue(String key, boolean parse) {
		IBundle bundle = getBundle();
		if (bundle == null)
			return null;
		String value = bundle.getHeader(key);
		if (value == null || !parse)
			return value;
		try {
			ManifestElement[] elements = ManifestElement.parseHeader(key, value);
			if (elements.length > 0)
				return elements[0].getValue();
		} catch (BundleException e) {
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.IIdentifiable#setId(java.lang.String)
	 */
	public void setId(String id) throws CoreException {
		ensureModelEditable();
		IBundle bundle = getBundle();
		if (bundle != null) {
			String old = getId();
			IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_SYMBOLICNAME);
			if (header instanceof BundleSymbolicNameHeader)
				((BundleSymbolicNameHeader) header).setId(id);
			else
				bundle.setHeader(Constants.BUNDLE_SYMBOLICNAME, id);
			model.fireModelObjectChanged(this, IIdentifiable.P_ID, old, id);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#getPluginModel()
	 */
	public IPluginModelBase getPluginModel() {
		return model;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#getName()
	 */
	public String getName() {
		return getValue(Constants.BUNDLE_NAME, false);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#setName(java.lang.String)
	 */
	public void setName(String name) throws CoreException {
		ensureModelEditable();
		IBundle bundle = getBundle();
		if (bundle != null) {
			String old = getName();
			IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_NAME);
			if (header instanceof BundleNameHeader)
				((BundleNameHeader) header).setBundleName(name);
			else
				bundle.setHeader(Constants.BUNDLE_NAME, name);
			model.fireModelObjectChanged(this, IPluginObject.P_NAME, old, name);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#isInTheModel()
	 */
	public boolean isInTheModel() {
		return model != null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#getTranslatedName()
	 */
	public String getTranslatedName() {
		return getResourceString(getName());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#getParent()
	 */
	public IPluginObject getParent() {
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#getPluginBase()
	 */
	public IPluginBase getPluginBase() {
		return this;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.plugin.IPluginObject#isValid()
	 */
	public boolean isValid() {
		IExtensions extensions = getExtensionsRoot();
		return getBundle() != null && getBundle().getHeader(Constants.BUNDLE_SYMBOLICNAME) != null && (extensions == null || extensions.isValid());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.pde.core.IWritable#write(java.lang.String,
	 *      java.io.PrintWriter)
	 */
	public void write(String indent, PrintWriter writer) {
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.core.plugin.IPluginObject#setInTheModel(boolean)
	 */
	public void setInTheModel(boolean inModel) {
	}

	static public int getBundleManifestVersion(IBundle bundle) {
		String version = bundle.getHeader(Constants.BUNDLE_MANIFESTVERSION);
		if (version == null)
			return 1; // default to 1
		try {
			return Integer.parseInt(version);
		} catch (NumberFormatException e) {
			return 1; // default to 1
		}
	}

	public void updateImport(IPluginImport iimport) {
		Object header = getManifestHeader(Constants.REQUIRE_BUNDLE);
		if (header instanceof RequireBundleHeader && imports != null)
			((RequireBundleHeader) header).updateBundle(imports.indexOf(iimport), iimport);
	}

	public String getTargetVersion() {
		return fTarget != null ? fTarget : TargetPlatformHelper.getTargetVersionString();
	}

	public void setTargetVersion(String target) {
		fTarget = target;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getIndexOf(org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public int getIndexOf(IPluginImport targetImport) {
		if (imports == null) {
			return -1;
		}
		return imports.indexOf(targetImport);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getPreviousImport(org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public IPluginImport getPreviousImport(IPluginImport targetImport) {
		// Ensure we have imports
		if (imports == null) {
			return null;
		} else if (imports.size() <= 1) {
			return null;
		}
		// Get the index of the target import
		int targetIndex = getIndexOf(targetImport);
		// Validate index
		if (targetIndex < 0) {
			// Target import does not exist
			return null;
		} else if (targetIndex == 0) {
			// Target import has no previous import
			return null;
		}
		// 1 <= index < size()
		// Get the previous import
		IPluginImport previousImport = (IPluginImport) imports.get(targetIndex - 1);

		return previousImport;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getNextImport(org.eclipse.pde.core.plugin.IPluginImport)
	 */
	public IPluginImport getNextImport(IPluginImport targetImport) {
		// Ensure we have imports
		if (imports == null) {
			return null;
		} else if (imports.size() <= 1) {
			return null;
		}
		// Get the index of the target import
		int targetIndex = getIndexOf(targetImport);
		// Get the index of the last import
		int lastIndex = imports.size() - 1;
		// Validate index
		if (targetIndex < 0) {
			// Target import does not exist
			return null;
		} else if (targetIndex >= lastIndex) {
			// Target import has no next element
			return null;
		}
		// 0 <= index < last element < size()
		// Get the next element
		IPluginImport nextImport = (IPluginImport) imports.get(targetIndex + 1);

		return nextImport;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#add(org.eclipse.pde.core.plugin.IPluginImport, int)
	 */
	public void add(IPluginImport iimport, int index) throws CoreException {
		ensureModelEditable();
		int importCount = 0;
		if (imports != null) {
			importCount = imports.size();
		}
		// Validate index
		if (index < 0) {
			return;
		} else if (index > importCount) {
			return;
		}
		// 0 <= index <= importCount
		// Add the element to the list
		if (imports == null) {
			// Intitialize the imports list by calling getImports()
			getImports();
			// Add the import to the end of the list
			addImport(iimport);
		} else {
			// Add the import to the list at the specified index
			addImport(iimport, index);
		}
		// Fire event
		fireStructureChanged(iimport, true);
	}

	/**
	 * @param iimport
	 * @param index
	 */
	private void addImport(IPluginImport iimport, int index) {
		// Get the header
		IManifestHeader header = getManifestHeader(Constants.REQUIRE_BUNDLE);
		if ((header instanceof RequireBundleHeader) == false) {
			addImport(iimport);
		} else {
			// Add the import to the local container
			imports.add(index, iimport);
			// Add the import to the header
			((RequireBundleHeader) header).addBundle(iimport, index);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#add(org.eclipse.pde.core.plugin.IPluginLibrary, int)
	 */
	public void add(IPluginLibrary library, int index) throws CoreException {
		ensureModelEditable();
		int libraryCount = 0;
		if (libraries != null) {
			libraryCount = libraries.size();
		}
		// Validate index
		if (index < 0) {
			return;
		} else if (index > libraryCount) {
			return;
		}
		// 0 <= index <= libraryCount
		if (libraries == null) {
			// Intitialize the library list by calling getLibraries()
			getLibraries();
		}
		// Get the header
		IManifestHeader header = getManifestHeader(Constants.BUNDLE_CLASSPATH);
		if ((header instanceof BundleClasspathHeader) == false) {
			// Add the library to the local container
			libraries.add(library);
			// Add the library to a newly created header
			addLibrary(library, header);
		} else {
			// Add the library to the local container at the specified index
			libraries.add(index, library);
			// Add the library to the existing header at the specified index
			((BundleClasspathHeader) header).addLibrary(library.getName(), index);
		}
		// Fire event
		fireStructureChanged(library, true);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getIndexOf(org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public int getIndexOf(IPluginLibrary targetLibrary) {
		if (libraries == null) {
			return -1;
		}
		return libraries.indexOf(targetLibrary);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getNextLibrary(org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public IPluginLibrary getNextLibrary(IPluginLibrary targetLibrary) {
		// Ensure we have libraries
		if (libraries == null) {
			return null;
		} else if (libraries.size() <= 1) {
			return null;
		}
		// Get the index of the target library
		int targetIndex = getIndexOf(targetLibrary);
		// Get the index of the last library
		int lastIndex = libraries.size() - 1;
		// Validate index
		if (targetIndex < 0) {
			// Target library does not exist
			return null;
		} else if (targetIndex >= lastIndex) {
			// Target library has no next element
			return null;
		}
		// 0 <= index < last element < size()
		// Get the next library
		IPluginLibrary nextLibrary = (IPluginLibrary) libraries.get(targetIndex + 1);

		return nextLibrary;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.ibundle.IBundlePluginBase#getPreviousLibrary(org.eclipse.pde.core.plugin.IPluginLibrary)
	 */
	public IPluginLibrary getPreviousLibrary(IPluginLibrary targetLibrary) {
		// Ensure we have libraries
		if (libraries == null) {
			return null;
		} else if (libraries.size() <= 1) {
			return null;
		}
		// Get the index of the target library
		int targetIndex = getIndexOf(targetLibrary);
		// Validate index
		if (targetIndex < 0) {
			// Target library does not exist
			return null;
		} else if (targetIndex == 0) {
			// Target library has no previous library
			return null;
		}
		// 1 <= index < size()
		// Get the previous library
		IPluginLibrary previousLibrary = (IPluginLibrary) libraries.get(targetIndex - 1);

		return previousLibrary;
	}

	protected void ensureModelEditable() throws CoreException {
		if (!getModel().isEditable()) {
			throwCoreException(PDECoreMessages.PluginObject_readOnlyChange);
		}
	}

	protected void throwCoreException(String message) throws CoreException {
		Status status = new Status(IStatus.ERROR, PDECore.PLUGIN_ID, IStatus.OK, message, null);
		CoreException ce = new CoreException(status);
		ce.fillInStackTrace();
		throw ce;
	}

}
