package org.simantics.structural.synchronization.base;

import java.util.Collection;
import java.util.Collections;
import java.util.Map;

import org.simantics.databoard.binding.mutable.Variant;
import org.simantics.structural.synchronization.protocol.Connection;
import org.simantics.structural.synchronization.protocol.SerializedVariable;
import org.simantics.structural.synchronization.utils.ComponentBase;

import gnu.trove.map.hash.THashMap;

abstract public class ModuleUpdaterBase<T extends ComponentBase<T>> {

    public String moduleType;
    public THashMap<String, PropertyUpdateRule<T>> propertyUpdateRules =
            new THashMap<String, PropertyUpdateRule<T>>();
    public THashMap<String, ConnectionUpdateRule<T>> connectionUpdateRules =
            new THashMap<String, ConnectionUpdateRule<T>>();
    public boolean isUserComponent;
    public boolean isComposite;
    public String subprocessType;
    
    public ModuleUpdaterBase(String moduleType) {
        this.moduleType = moduleType;
    }
    
    public void addPropertyUpdateRule(PropertyUpdateRule<T> rule) {
        propertyUpdateRules.put(rule.getPropertyName(), rule);
    }
    
    public void addConnectionUpdateRule(ConnectionUpdateRule<T> rule) {
        connectionUpdateRules.put(rule.getConnectionPointName(), rule);
    }

    public void create(ModuleUpdateContext<T> context, Collection<SerializedVariable> properties, Collection<Connection> connections) {
        context.command = createAddCommandBuilder(context.getModuleName()); 
        applyRules(context, true, properties, connections);
    }
    
    abstract public CommandBuilder createAddCommandBuilder(String name);

    public void update(ModuleUpdateContext<T> context, Collection<SerializedVariable> properties, Collection<Connection> connections) {
        // Check that the module type matches
        int moduleTypeId = context.getSolver().getModuleType(context.getModuleId());
        String moduleTypeName = context.getSolver().getName(moduleTypeId);
        if(!moduleTypeName.equals(moduleType)) {
            context.getSolver().remove(context.getModuleId());
            context.component.componentId = -1;
            context.setModuleId(-1);
            create(context, properties, connections);
        }
        
        // Update
        else {
            context.command = createUpdateCommandBuilder(context.getModuleName());
            applyRules(context, false, properties, connections);
        }
    }
    
    abstract public CommandBuilder createUpdateCommandBuilder(String name);
    
    private void applyRules(ModuleUpdateContext<T> context, boolean inCreate,
            Collection<SerializedVariable> properties, Collection<Connection> connections) {
        THashMap<String, Variant> propertyMap = new THashMap<String, Variant>(properties.size());
        Map<String, Collection<String>> connectionMap = connections.isEmpty()
                ? Collections.<String, Collection<String>>emptyMap()
                : new THashMap<String, Collection<String>>(connections.size());
        for(SerializedVariable property : properties)
            propertyMap.put(property.name, property.value);
        for(Connection connection : connections)
            connectionMap.put(connection.relation, connection.connectionPoints);

        context.incPendingCount(); // To prevent premature execution of the command
        for(SerializedVariable property : properties) {
            PropertyUpdateRule<T> rule = propertyUpdateRules.get(property.name);
            if(rule != null)
                rule.apply(context, inCreate, propertyMap, connectionMap, property.value);
            else if(property.name.equals("IsAttached"))
                ;
            else
                if(SynchronizationEventHandlerBase.TRACE_EVENTS)
                    System.out.println("    skipped property " + property.name + " " + property.toString());
        }
        if(inCreate) {
            for(Connection connection : connections) {
                ConnectionUpdateRule<T> rule = connectionUpdateRules.get(connection.relation);
                if(rule != null)
                    rule.apply(context, propertyMap, connection.connectionPoints);
                else
                	if(SynchronizationEventHandlerBase.TRACE_EVENTS)
                	    System.out.println("    skipped connection " + connection.relation + " " + connection.connectionPoints);
            }
        }
        else {
            THashMap<String, ConnectionUpdateRule<T>> unusedConnectionUpdateRules =
                    new THashMap<String, ConnectionUpdateRule<T>>(connectionUpdateRules);
            for(Connection connection : connections) {
                ConnectionUpdateRule<T> rule = unusedConnectionUpdateRules.remove(connection.relation);
                if(rule != null)
                    rule.apply(context, propertyMap, connection.connectionPoints);
                else
                    if(SynchronizationEventHandlerBase.TRACE_EVENTS)
                        System.out.println("    skipped connection " + connection.relation + " " + connection.connectionPoints);
            }
            for(ConnectionUpdateRule<T> rule : unusedConnectionUpdateRules.values())
                rule.apply(context, propertyMap, Collections.<String>emptyList());
        }
        context.decPendingCount();
    }

}