/**
 * Allows generation of code from multiple resources in the most efficient way that is possible.
 */
public interface IBundleModelGenerator {

    /**
     * @return <code>true</code> if the builder should only load the resources contained in the
     *         context bundle directly, without dependencies (there will be unresolved proxies!),
     *         <code>false</code> if the contents of visible bundles should be loaded also.
     */
    public boolean isSlim();

    /**
     * @return the file extension of model files, used to find resources.
     */
    public String getFileExtension();

    /**
     * Generates code out of multiple resources within a bundle. Depending on the implementation of
     * {@link #isSlim()}, the passed {@link ResourceSet} will contain either only resources from the
     * bundle in context, or from all visible bundles also.
     * 
     * @param context
     *            the build context to allow determination of the bundle in context.
     * @param resources
     *            the rources loaded for this generator.
     * @param fsa
     *            the {@link IFileSystemAccess} to generate files through
     */
    public void doGenerate(IBuildContext context, ResourceSet resources, IFileSystemAccess fsa);
}

class BundleModelBuilderParticipant extends BuilderParticipant {

	@Inject private ResourceDescriptionsProvider descriptionsProvider
	@Inject private IContainer.Manager containerManager
	@Inject(optional=true) private IBundleModelGenerator bundleModelGenerator
	
	private val modelGeneratorLock = new AtomicBoolean

	override build(IBuildContext context, IProgressMonitor monitor) throws CoreException {
		modelGeneratorLock.set(true)
		super.build(context, monitor)
	}
	
	override protected handleChangedContents(Delta delta, IBuildContext context, EclipseResourceFileSystemAccess2 fsa) throws CoreException {
		super.handleChangedContents(delta, context, fsa)
		
		if (bundleModelGenerator != null && modelGeneratorLock.compareAndSet(true, false)) {
			val start = System.currentTimeMillis
			val set = context.resourceSet
			val resources = findModelResources(context.builtProject)
			System.err.println("finding resources took " + (System.currentTimeMillis - start))
			if (bundleModelGenerator.slim) {
				for (r : resources) {
					set.getResource(getResourcePlatformURI(r), true)
				}
			} else {
				// obtain the containers by querying for any of the resources in the bundle
				val index = descriptionsProvider.createResourceDescriptions
				val anyDesc = index.getResourceDescription(getResourcePlatformURI(resources.get(0)))
				val containers = containerManager.getVisibleContainers(anyDesc, index)
				
				for(c : containers) {
					for(rd : c.resourceDescriptions) {
						set.getResource(rd.URI, true)
					}
				}
			}
			System.err.println("loading resources took " + (System.currentTimeMillis - start))
			
			bundleModelGenerator.doGenerate(context, set, fsa)
			System.err.println("bundle model generator took " + (System.currentTimeMillis - start) + "ms")
		}
	}

	/**
	 * Retrieves the platform:/ URI for the given resource.
	 */
	private def getResourcePlatformURI(IResource r) {
		URI.createPlatformResourceURI(r.getProject().getName() + "/" + r.getProjectRelativePath().toPortableString(),
			true)
	}

	/**
	 * Find model resources in the given project. This yields only resources directly contained in the project.
	 */
	private def findModelResources(IProject project) {
		val files = newArrayList()

		project.accept(
			[ resource |
				if (resource.getFileExtension() != null &&
					resource.getFileExtension().equalsIgnoreCase(bundleModelGenerator.fileExtension)) {
					files.add(resource);
				}
				return true;
			]);

		files
	}
}