package org.simantics.interop.test;

import java.util.ArrayList;
import java.util.Comparator;

import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.Statement;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.DoesNotContainValueException;
import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
import org.simantics.db.exception.ServiceException;
import org.simantics.db.exception.ValidationException;
import org.simantics.layer0.Layer0;

/**
 * Object comparator that uses type of objects to check if objects are comparable. 
 * 
 * Difference value is amount of properties that have different values.
 * 
 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
 *
 */
public class TypeComparator extends ResourceComparator {

	
	ArrayList<Resource> rs1 = new ArrayList<Resource>();
	ArrayList<Resource> rs2 = new ArrayList<Resource>();
	
	@Override
	public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{
		if (!compareType(g,o1, o2)) {
			return (Integer.MAX_VALUE);
		}
		return propsDiffCount(g,o1, o2);
	}
	
	protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws ServiceException, ManyObjectsForFunctionalRelationException {
		Layer0 l0 = Layer0.getInstance(g);
		rs1.addAll(g.getObjects(r1, l0.InstanceOf));
		rs2.addAll(g.getObjects(r2, l0.InstanceOf));
		if (rs1.size() != rs2.size()) {
			rs1.clear();
			rs2.clear();
			return false;
		}
		Comparator<Resource> rcomp = getComparator().getResourceComparator();
		getComparator().sortResource(rs1, rs2);

		for (int i = 0; i < rs1.size(); i++) {
			int c = rcomp.compare(rs1.get(i), rs2.get(i));
			if (c != 0) {
				rs1.clear();
				rs2.clear();
				return false;
			}
		}
		
		rs1.clear();
		rs2.clear();
		
		return true;
	}
	
	protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException {
		Layer0 l0 = Layer0.getInstance(g);
		ArrayList<Statement> ss1 = new ArrayList<Statement>();
		ArrayList<Statement> ss2 = new ArrayList<Statement>();
		ss1.addAll(g.getStatements(r1, l0.HasProperty));
		ss2.addAll(g.getStatements(r2, l0.HasProperty));
		
		if (ss1.size() == 0 && ss2.size() == 0)
			return 0;
		
		Comparator<Statement> scomp = getComparator().getStatementComparator();
		
		getComparator().sortStatement(ss1, ss2);
		
		int count = 1;
		
		int i1 = 0; 
		int i2 = 0;
		
		while (true) {
			if (i1 >= ss1.size()) {
				if (i2 >= ss2.size())
					break;
				else {
					while (i2 < ss2.size()) {
						count++;
						i2++;
					}
					break;
				}
			} else if (i2 >= ss2.size()) {
				while (i1 < ss1.size()) {
					count++;
					i1++;
				}
				break;
			}
			Statement s1 = ss1.get(i1);
			Statement s2 = ss2.get(i2);
			int c = scomp.compare(s1, s2);
			switch (c) {
				case 0:{
					boolean b1 = g.hasValue(s1.getObject());
					boolean b2 = g.hasValue(s2.getObject());
					if (b1 == b2) {
						if (b1) {
							Object v1 = g.getValue(s1.getObject());
							Object v2 = g.getValue(s2.getObject());
							boolean eq = GraphComparator.compareValue(v1, v2);
							
							if (!eq) {
								count++;
							}
							//System.out.println("Prop count values " + v1 + " " + v2);
						} else {
							count += propsDiffCount(g,s1.getObject(), s2.getObject());
						}
					} else {
						//System.out.println("Props count structural vs literal");
						count++;
					}
					i1++;
					i2++;
					break;
				}
				case -1:{
					count++;
					i1++;
					break;
				}
					
				case 1:{
					count++;
					i2++;
					break;
				}
			}

		}
		
		ss1.clear();
		ss2.clear();
		return count;
	}

}