package org.simantics.scl.compiler.tests.unit;

import java.util.ArrayList;

import org.junit.Assert;
import org.junit.Test;
import org.simantics.scl.compiler.errors.ErrorLog;
import org.simantics.scl.compiler.errors.Locations;
import org.simantics.scl.compiler.internal.elaboration.subsumption.Subsumption;
import org.simantics.scl.compiler.internal.elaboration.subsumption2.SubSolver2;
import org.simantics.scl.compiler.types.TMetaVar;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
import org.simantics.scl.compiler.types.kinds.Kinds;
import org.simantics.scl.compiler.types.util.Polarity;

public class TestSubSolver2 {
    ErrorLog errorLog = new ErrorLog();
    ArrayList<Subsumption> subsumptions = new ArrayList<Subsumption>(); 
    
    private void sub(Type a, Type b) {
        subsumptions.add(new Subsumption(Locations.NO_LOCATION, a, b));
    }
    
    private TMetaVar metaVar(Polarity p) {
        TMetaVar var = Types.metaVar(Kinds.EFFECT);
        var.addPolarity(p);
        return var;
    }
    
    @Test
    public void subFF() {
        TMetaVar a = metaVar(Polarity.NO_POLARITY);
        TMetaVar b = metaVar(Polarity.NO_POLARITY);
        sub(a, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(a, b);
    }
    
    @Test
    public void subPP() {
        TMetaVar a = metaVar(Polarity.POSITIVE);
        TMetaVar b = metaVar(Polarity.POSITIVE);
        sub(a, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(a, b);
    }
    
    @Test
    public void subNN() {
        TMetaVar a = metaVar(Polarity.NEGATIVE);
        TMetaVar b = metaVar(Polarity.NEGATIVE);
        sub(a, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(a, b);
    }
    
    @Test
    public void subPN() {
        TMetaVar a = metaVar(Polarity.POSITIVE);
        TMetaVar b = metaVar(Polarity.NEGATIVE);
        sub(a, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertNotEquals(a, b);
    }
    
    @Test
    public void subNP() {
        TMetaVar a = metaVar(Polarity.NEGATIVE);
        TMetaVar b = metaVar(Polarity.POSITIVE);
        sub(a, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(a, b);
    }
    
    @Test
    public void loop() {
        TMetaVar a = metaVar(Polarity.BIPOLAR);
        TMetaVar b = metaVar(Polarity.BIPOLAR);
        TMetaVar c = metaVar(Polarity.BIPOLAR);
        sub(a, b);
        sub(b, c);
        sub(c, a);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(a, b);
        Assert.assertEquals(a, c);
    }
    
    @Test
    public void union() {
        TMetaVar a = metaVar(Polarity.POSITIVE);
        TMetaVar b = metaVar(Polarity.POSITIVE);
        sub(a, Types.union(a, b));
        sub(Types.PROC, b);
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertEquals(Types.PROC, b);
    }
    
    @Test
    public void union2() {
        TMetaVar a = metaVar(Polarity.POSITIVE);
        TMetaVar b = metaVar(Polarity.POSITIVE);
        sub(Types.union(a, Types.PROC), Types.union(a, b));
        SubSolver2.solve(errorLog, subsumptions);
        Assert.assertEquals(0, errorLog.getErrorCount());
        Assert.assertNotEquals(Types.NO_EFFECTS, b);
    }
}