/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * 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.db.impl.query;

import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.serialization.Serializer;
import org.simantics.db.ObjectResourceIdMap;
import org.simantics.db.common.WriteBindings;
import org.simantics.db.common.exception.DebugException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.impl.graph.ReadGraphImpl;
import org.simantics.db.impl.procedure.InternalProcedure;
import org.simantics.db.service.CollectionSupport;

final public class ChildMap extends UnaryQuery<InternalProcedure<ObjectResourceIdMap<String>>> {
	
    ChildMap(final int r) {
        super(r);
    }
    
 	@Override
 	final public void removeEntry(QueryProcessor provider) {
 		provider.cache.remove(this);
 	}
	
    //@Override
 	public Object compute(ReadGraphImpl graph, final InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
		computeForEach(graph, id, this, procedure);
		return getResult();
    }

	public static void computeForEach(ReadGraphImpl graph, final int root, final ChildMap entry, final InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
		
		if(root == 0) {
			if(entry != null)
				entry.add2(graph, null);
            procedure.execute(graph, null);
            return;
		}

		QueryProcessor processor = graph.processor;
		
		final int consistsOf = processor.getConsistsOf();
		final int hasName = processor.getHasName();
        
		ObjectResourceIdMap<String> result = graph.getService(CollectionSupport.class).createObjectResourceMap(String.class);
        
        QueryCache.runnerObjects(graph, root, consistsOf, entry, null, new SyncIntProcedure() {
        	
        	@Override
			public void run(ReadGraphImpl graph) throws DatabaseException {
        		
        		if(entry != null) entry.add2(graph, result);
        		procedure.execute(graph, result);
				
			}

			@Override
			public void finished(ReadGraphImpl graph) throws DatabaseException {
				dec(graph);
			}

        	@Override
        	public void execute(ReadGraphImpl graph, final int obj) throws DatabaseException {

        		inc();
        		
        		QueryCache.runnerObjects(graph, obj, hasName, entry, null, new IntProcedure() {
                	
                	@Override
                	public void execute(ReadGraphImpl graph, int i) throws DatabaseException {

                		inc();

                		QueryCache.runnerValueQuery(graph, i, entry, null, new InternalProcedure<byte[]>() {
                			
                			@Override
                			public void execute(ReadGraphImpl graph, byte[] value) throws DatabaseException {
                				
                				if(value != null) {

	                                try {

	                                	Binding b = WriteBindings.STRING;
	                                    Serializer serializer = b.serializer();
	                                    final String part = (String)serializer.deserialize(value);
	                                    result.putId(part, obj);
	                                    
	                	        	} catch (Throwable e) {
	                                    if(DebugException.DEBUG) new DebugException(e).printStackTrace();
	                                }
	                	        	
                				}
                				
                	        	dec(graph);
                	        	
                			}
                			
                			@Override
                			public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
        	 					if(entry != null) entry.except(t);
                				dec(graph);
                            }

                		});
                		
                	}
                	
                	@Override
                	public void finished(ReadGraphImpl graph) throws DatabaseException {
                		dec(graph);
                	}
        			
        			@Override
        			public void exception(ReadGraphImpl graph, Throwable t) throws DatabaseException {
        				if(entry != null) entry.except(t);
                        dec(graph);
                    }

                });

        	}
        	
        });
        
    }

    @Override
    public String toString() {
    	return "ChildMap[" + id + "]";
    }

    private void add2(ReadGraphImpl graph, ObjectResourceIdMap<String> result) {
    	
    	assert(isPending());

        synchronized(this) {

            setResult(result);
        	setReady();
        
        }
    	
    }
    
    @Override
    public Object performFromCache(ReadGraphImpl graph, InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
        
        assert(isReady());
        
    	if(handleException(graph, procedure)) return (Throwable)statusOrException;
        
    	ObjectResourceIdMap<String> result = (ObjectResourceIdMap<String>)getResult();
    	
        procedure.execute(graph, result);
        
        return result;
        
    }
    
    @Override
    public void recompute(ReadGraphImpl graph) throws DatabaseException {
        
        compute(graph, new InternalProcedure<ObjectResourceIdMap<String>>() {

            @Override
            public void execute(ReadGraphImpl graph, ObjectResourceIdMap<String> result) {
            }
			
			@Override
			public void exception(ReadGraphImpl graph, Throwable t) {
                if(DebugException.DEBUG) new DebugException(t).printStackTrace();
				throw new Error("Error in recompute.", t);
            }

        });
        
    }
    
}