/*******************************************************************************
 * Copyright (c) 2007 VTT Technical Research Centre of Finland 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:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.proconf.g3d.base;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.dynamichelpers.ExtensionTracker;
import org.eclipse.core.runtime.dynamichelpers.IExtensionChangeHandler;
import org.eclipse.core.runtime.dynamichelpers.IExtensionTracker;
import org.eclipse.core.runtime.dynamichelpers.IFilter;
import org.simantics.db.Resource;
import org.simantics.layer0.utils.IEntity;
import org.simantics.utils.ui.ErrorLogger;

import com.jme.scene.Geometry;

public class GeometryProviderRegistry implements IExtensionChangeHandler {
    private static GeometryProviderRegistry instance;
    public final static String ELEMENT_NAME = "Geometry";
    public final static String NAMESPACE = "org.simantics.proconf.g3d";
    public final static String EP_NAME = "geometry";
    
    private ExtensionTracker tracker;
    
    private List<GeometryProviderExtension> extensions = new ArrayList<GeometryProviderExtension>();
    private Map<Resource,GeometryProvider> providers;
    
    private GeometryProviderRegistry() {
        providers = new HashMap<Resource,GeometryProvider>();
        
        tracker = new ExtensionTracker();
		
		IExtensionPoint ep = Platform.getExtensionRegistry().getExtensionPoint(NAMESPACE,EP_NAME);
		loadExtensions(ep.getConfigurationElements());
		
		IFilter filter = ExtensionTracker.createExtensionPointFilter(ep);
		tracker.registerHandler(this, filter);
    }
    
    private void close() {
		tracker.close();
		tracker = null;
		extensions = new ArrayList<GeometryProviderExtension>();
	}
    
    public static synchronized GeometryProviderRegistry getInstance() {
        if (instance==null) instance = new GeometryProviderRegistry();
        return instance;
    }
    
    public static synchronized void dispose() {
		if (instance != null) {
			instance.close();
			instance = null;
		}	
	}
    
    public synchronized List<GeometryProviderExtension> getExtensions() {
		return Collections.unmodifiableList(extensions);
	}
    
    private synchronized void loadExtensions(IConfigurationElement[] elements) {
		for (IConfigurationElement el : elements) {
			String id = el.getAttribute("id");
			try {
				Object o = el.createExecutableExtension("class");
				GeometryProviderExtension ext = new GeometryProviderExtension(id,(GeometryProvider)o);
				tracker.registerObject(el.getDeclaringExtension(), ext, IExtensionTracker.REF_STRONG);
				extensions.add(ext);
			} catch (CoreException e) {
				ErrorLogger.defaultLogError("Cannot create java interface for GeometryProvider " + id, e);
			}
		}
	}
    
    private Map<Resource,GeometryProvider> getProviderMap() {
        return providers;
    }
    
    public static Geometry[] getGeometry(IEntity thing, boolean transform) {
        GeometryProvider provider = getGeometryProvider(thing);
        return provider.getGeometryFromResource(thing, transform);
    }
    
    public static GeometryProvider getGeometryProvider(IEntity thing) {
    	Collection<IEntity> types = thing.getRelatedObjects(thing.getGraph().getBuiltins().InstanceOf);
        
    	//Resource types[] = OntologyUtils.getTypes(resource);
    	for (IEntity t : types) {
    		GeometryProvider provider = getInstance().getProviderMap().get(t.getResource());
        	if (provider == null) {
                //for (Extension<GeometryProvider> e : getInstance().getExtensions()) {
        		for (GeometryProviderExtension e : getInstance().getExtensions()) {
                    if (e.provider.canHandle(thing)) {
                        getInstance().getProviderMap().put(t.getResource(), e.provider);
                        return e.provider;
                    }
                }
                
            } else {
            	return provider;
            }
    	}
    	
    	throw new UnsupportedOperationException("Cannot handle resource " + thing);
    }
    
    @Override
    public void addExtension(IExtensionTracker tracker, IExtension extension) {
        loadExtensions(extension.getConfigurationElements());
    }
    
    @Override
	public synchronized void removeExtension(IExtension extension, Object[] objects) {
		for (Object o : objects) {
			GeometryProviderExtension ext = (GeometryProviderExtension) o;
			tracker.unregisterObject(extension, ext);
			extensions.remove(ext);
		}
	}
    
    public class GeometryProviderExtension {
		public String id;
		public GeometryProvider provider;
		
		public GeometryProviderExtension(String id, GeometryProvider provider) {
			this.id = id;
			this.provider = provider;
		}
	}
}