package org.simantics.interop.update.model;

import org.simantics.db.Resource;
import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
import org.simantics.db.exception.DatabaseException;
import org.simantics.interop.test.GraphChanges;
import org.simantics.layer0.Layer0;
import org.simantics.utils.datastructures.Pair;

public class PropertyChange {
	protected GraphChanges changes;
	protected Resource leftSubject;
	protected Resource rightSubject;
	protected Pair<Statement, Statement> pair;
	protected boolean applied = false;
	protected boolean selected = false;
	protected boolean visible = true;
	protected boolean enabled = true;
	protected Object customValue = null;
	
	
	public PropertyChange(GraphChanges changes, Resource left, Statement first, Resource right, Statement second) {
		if (first == null && second == null)
			throw new IllegalArgumentException("At least one of the stamenents must be non null.");
		if (left == null || right == null)
			throw new IllegalArgumentException("Subject resources cannot be null.");
		this.pair = new Pair<Statement, Statement>(first, second);
		this.changes = changes;
		this.leftSubject = left;
		this.rightSubject = right;
	}
	
	public PropertyChange(GraphChanges changes, Resource left, Resource right, Pair<Statement, Statement> change) {
		if (change == null || (change.first == null && change.second == null))
			throw new IllegalArgumentException("At least one of the stamenents must be non null.");
		if (left == null || right == null)
			throw new IllegalArgumentException("Subject resources cannot be null.");
		this.pair = change;
		this.changes = changes;
		this.leftSubject = left;
		this.rightSubject = right;
	}
	
	
	public Resource getFirstSubject() {
		return leftSubject;
	}
	
	public Statement getFirst() {
		return pair.first;
	}
	
	public Resource getSecondSubject() {
		return rightSubject;
	}
	
	public Statement getSecond() {
		return pair.second;
	}
	
	public Resource getPredicate() {
	    if (pair.first != null)
	        return pair.first.getPredicate();
	    return pair.second.getPredicate();
	}
	
	public GraphChanges getChanges() {
		return changes;
	}
	
	@Override
	public int hashCode() {
		return pair.hashCode();
	}
	
	@Override
	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		if (obj.getClass() != this.getClass())
			return false;
		PropertyChange c = (PropertyChange)obj;
		if (!leftSubject.equals(c.leftSubject))
			return false;
		if (!rightSubject.equals(c.rightSubject))
			return false;
		if (pair.first != null && pair.first.equals(c.pair.first))
			return true;
		if (pair.second != null && pair.second.equals(c.pair.second))
			return true;
		return false;
	}
	
	public void apply(WriteGraph graph) throws DatabaseException {
		if (applied)
			return;
		if (pair.second == null) {
			graph.deny(leftSubject, pair.first.getPredicate(),pair.first.getObject());
			return;
		} 
		Layer0 L0 = Layer0.getInstance(graph);
		Resource s = leftSubject;
		if (graph.isInstanceOf(pair.second.getObject(), L0.Literal)) {
			Object value = null;
			if (customValue != null)
				value = customValue;
			else if (graph.hasValue(pair.second.getObject())) {
				value = graph.getValue(pair.second.getObject());
			}
			Resource pred = pair.second.getPredicate();
			if (getChanges().getComparable().containsRight(pred))
				pred = getChanges().getComparable().getLeft(pred);
			
			if (value != null) {
				graph.deny(s, pred);
				graph.claimLiteral(s, pred, value);
			} else {
				graph.deny(s,pred);
			}
		} else if (graph.isInstanceOf(pair.second.getObject(), L0.SCLValue)) {
			Resource pred = pair.second.getPredicate();
			graph.deny(s, pred);
			Resource valueResource = graph.newResource();
			graph.claim(valueResource, L0.InstanceOf, graph.getSingleObject(pair.second.getObject(), L0.InstanceOf));
			AddDeleteUpdateOp.copyProperties(graph, pair.second.getObject(), valueResource);
			graph.claim(s, pred, valueResource);
		}
		applied = true;
	}
	
	/**
	 * Sets selected state. 
	 * @param select
	 * @return true if selection state was changed
	 */
	public boolean select(boolean select) {
	    if (!enabled)
	        return false;
		if (applied)
			return false;
		this.selected = select;
		return true;
	}
	
	/**
	 * Is change selected.
	 * @return
	 */
	public boolean selected() {
		return selected;
	}
	
	/**
	 * Has change been applied
	 * @return
	 */
	public boolean applied() {
		return applied;
	}
	
	/**
	 * Is change visible
	 * @return
	 */
	public boolean isVisible() {
		return visible;
	}
	
	public void setVisible(boolean visible) {
		this.visible = visible;
	}
	
	/**
	 * Is change enabled. Disabled changes do not allow changing selected state.
	 * @return
	 */
	public boolean enabled() {
        return enabled;
    }
	
	public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }
	
	@Override
	public String toString() {
		String s = "PropertyChange";
		if (pair.first != null)
			s += " L(" + (leftSubject) + " , " + pair.first.getPredicate() + " , " + pair.first.getObject() + ")";
		if (pair.second != null)
			s += " R(" + (rightSubject) + " , " + pair.second.getPredicate() + " , " + pair.second.getObject() + ")";
		if (selected)
		    s += " selected";
		if (enabled)
		    s += " enabled";
		if (visible)
            s += " visible";
		if (applied)
		    s += " applied";
		return s;
	}
	
	public Object getCustomValue() {
		return customValue;
	}
	
	public void setCustomValue(Object customValue) {
		if (applied) {
			throw new RuntimeException("Cannot change already applied value");
		}
		this.customValue = customValue;
	}
	
}