package org.simantics.db.layer0.variable;

import java.util.Collection;
import java.util.Set;

import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.binding.mutable.Variant;
import org.simantics.databoard.type.Datatype;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.WriteGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.variable.RVI.RVIPart;

/**
 * @deprecated this implementation is pretty much useless, it is too
 *             straightforward and requires extenders to override pretty much
 *             everything in it to work correctly. Do not use.
 * @see ValueProxyVariable
 */
@Deprecated
public abstract class ProxyVariable implements Variable {

    protected final Variable proxy;
    protected final Variable parent;

    public ProxyVariable(Variable proxy, Variable parent) {
        if (proxy == null)
            throw new NullPointerException("null proxy");
        if (parent == null)
            throw new NullPointerException("null parent");
        this.parent = parent;
        this.proxy = proxy;
    }

    @Override
    public <T> T getPropertyValue(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getPropertyValue(graph, name);
    }

    @Override
    public <T> T getPropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
        return proxy.getPropertyValue(graph, property);
    }

    @Override
    public <T> T getPossiblePropertyValue(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getPossiblePropertyValue(graph, name);
    }

    @Override
    public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
        return proxy.getPossiblePropertyValue(graph, property);
    }

    @Override
    public <T> T getPropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
        return proxy.getPropertyValue(graph, name, binding);
    }

    @Override
    public <T> T getPropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
        return proxy.getPropertyValue(graph, property, binding);
    }

    @Override
    public <T> T getPossiblePropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
        return proxy.getPossiblePropertyValue(graph, name, binding);
    }

    @Override
    public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
        return proxy.getPossiblePropertyValue(graph, property, binding);
    }

    @Override
    public <T> T getValue(ReadGraph graph) throws DatabaseException {
        return proxy.getValue(graph);
    }

    @Override
    public <T> T getPossibleValue(ReadGraph graph) throws DatabaseException {
        return proxy.getPossibleValue(graph);
    }

    @Override
    public <T> T getValue(ReadGraph graph, Binding binding) throws DatabaseException {
        return proxy.getValue(graph, binding);
    }

    @Override
    public <T> T getPossibleValue(ReadGraph graph, Binding binding) throws DatabaseException {
        return proxy.getPossibleValue(graph, binding);
    }

    @Override
    public void setValue(WriteGraph graph, Object value, Binding binding) throws DatabaseException {
        proxy.setValue(graph, value, binding);
    }

    @Override
    public void setValue(WriteGraph graph, Object value) throws DatabaseException {
        proxy.setValue(graph, value);
    }

    @Override
    public void setPropertyValue(WriteGraph graph, String name, Object value, Binding binding) throws DatabaseException {
        proxy.setPropertyValue(graph, name, value, binding);
    }

    @Override
    public void setPropertyValue(WriteGraph graph, Resource property, Object value, Binding binding) throws DatabaseException {
        proxy.setPropertyValue(graph, property, value, binding);
    }

    @Override
    public void setPropertyValue(WriteGraph graph, String name, Object value) throws DatabaseException {
        proxy.setPropertyValue(graph, name, value);
    }

    @Override
    public void setPropertyValue(WriteGraph graph, Resource property, Object value) throws DatabaseException {
        proxy.setPropertyValue(graph, property, value);
    }

    @Override
    public Variable getChild(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getChild(graph, name);
    }

    @Override
    public Variable getPossibleChild(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getPossibleChild(graph, name);
    }

    @Override
    public Variable getProperty(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getProperty(graph, name);
    }

    @Override
    public Variable getProperty(ReadGraph graph, Resource property) throws DatabaseException {
        return proxy.getProperty(graph, property);
    }

    @Override
    public Variable getPossibleProperty(ReadGraph graph, String name) throws DatabaseException {
        return proxy.getPossibleProperty(graph, name);
    }

    @Override
    public Variable getPossibleProperty(ReadGraph graph, Resource property) throws DatabaseException {
        return proxy.getPossibleProperty(graph, property);
    }

    @Override
    public Collection<Variable> browseChildren(ReadGraph graph) throws DatabaseException {
        return proxy.browseChildren(graph);
    }

    @Override
    public Collection<Variable> getChildren(ReadGraph graph) throws DatabaseException {
        return proxy.getChildren(graph);
    }

    @Override
    public Collection<Variable> browseProperties(ReadGraph graph) throws DatabaseException {
        return proxy.browseProperties(graph);
    }

    @Override
    public Collection<Variable> getProperties(ReadGraph graph) throws DatabaseException {
        return proxy.getProperties(graph);
    }

    @Override
    public Collection<Variable> getProperties(ReadGraph graph, String classification) throws DatabaseException {
        return proxy.getProperties(graph, classification);
    }

    @Override
    public Collection<Variable> getProperties(ReadGraph graph, Resource classification) throws DatabaseException {
        return proxy.getProperties(graph, classification);
    }

    @Override
    public Variable browse(ReadGraph graph, String suffix) throws DatabaseException {
        if (suffix.isEmpty())
            return this;
        return proxy.browse(graph, suffix);
    }

    @Override
    public Variable browsePossible(ReadGraph graph, String suffix) throws DatabaseException {
        if (suffix.isEmpty())
            return this;
        return proxy.browsePossible(graph, suffix);
    }

    @Override
    public Variable browse(ReadGraph graph, Resource config) throws DatabaseException {
        return proxy.browse(graph, config);
    }

    @Override
    public Variable browsePossible(ReadGraph graph, Resource config) throws DatabaseException {
        return proxy.browsePossible(graph, config);
    }

    @Override
    public <T> T getInterface(ReadGraph graph, Class<T> clazz) throws DatabaseException {
        return proxy.getInterface(graph, clazz);
    }

    @Override
    public <T> T adapt(ReadGraph graph, Class<T> clazz) throws DatabaseException {
        return proxy.adapt(graph, clazz);
    }

    @Override
    public <T> T adaptPossible(ReadGraph graph, Class<T> clazz) throws DatabaseException {
        return proxy.adaptPossible(graph, clazz);
    }

    @Override
    public String getURI(ReadGraph graph) throws DatabaseException {
        return proxy.getURI(graph);
    }

    @Override
    public abstract int hashCode();

    @Override
    public abstract boolean equals(Object obj);

    @Override
    public Variable resolve(ReadGraph graph, RVIPart part) throws DatabaseException {
        return proxy.resolve(graph, part);
    }

    @Override
    public Variable resolvePossible(ReadGraph graph, RVIPart part) throws DatabaseException {
        return proxy.resolvePossible(graph, part);
    }

    @Override
    public String getName(ReadGraph graph) throws DatabaseException {
        return proxy.getName(graph);
    }

    @Override
    public String getLabel(ReadGraph graph) throws DatabaseException {
        return proxy.getLabel(graph);
    }

    @Override
    public Datatype getDatatype(ReadGraph graph) throws DatabaseException {
        return proxy.getDatatype(graph);
    }

    @Override
    public Datatype getPossibleDatatype(ReadGraph graph) throws DatabaseException {
        return proxy.getPossibleDatatype(graph);
    }

    @Override
    public Variable getPredicate(ReadGraph graph) throws DatabaseException {
        return proxy.getPredicate(graph);
    }

    @Override
    public Variable getPossiblePredicate(ReadGraph graph) throws DatabaseException {
        return proxy.getPossiblePredicate(graph);
    }

    @Override
    public Resource getPredicateResource(ReadGraph graph) throws DatabaseException {
        return proxy.getPredicateResource(graph);
    }

    @Override
    public Resource getPossiblePredicateResource(ReadGraph graph) throws DatabaseException {
        return proxy.getPossiblePredicateResource(graph);
    }
    
    @Override
    public Variable getParent(ReadGraph graph) throws DatabaseException {
        return parent;
    }

    @Override
    public Resource getRepresents(ReadGraph graph) throws DatabaseException {
        return proxy.getRepresents(graph);
    }

    @Override
    public Resource getPossibleRepresents(ReadGraph graph) throws DatabaseException {
        return proxy.getPossibleRepresents(graph);
    }

    @Override
    public Resource getType(ReadGraph graph) throws DatabaseException {
        return proxy.getType(graph);
    }

    @Override
    public Resource getPossibleType(ReadGraph graph) throws DatabaseException {
        return proxy.getPossibleType(graph);
    }

    @Override
    public RVI getRVI(ReadGraph graph) throws DatabaseException {
        return proxy.getRVI(graph);
    }

    @Override
    public RVI getPossibleRVI(ReadGraph graph) throws DatabaseException {
        return proxy.getPossibleRVI(graph);
    }

    @Override
    public Set<String> getClassifications(ReadGraph graph) throws DatabaseException {
    	return proxy.getClassifications(graph);
    }

    public Variant getVariantValue(ReadGraph graph) throws DatabaseException {
        return proxy.getVariantValue(graph);
    }

	@Override
	public Resource getType(ReadGraph graph, Resource baseType) throws DatabaseException {
		return proxy.getType(graph, baseType);
	}

	@Override
	public Resource getPossibleType(ReadGraph graph, Resource baseType) throws DatabaseException {
		return proxy.getPossibleType(graph, baseType);
	}
}