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

import java.util.Collection;

import org.junit.Assert;
import org.junit.Test;
import org.simantics.scl.compiler.environment.filter.AcceptAllNamespaceFilter;
import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
import org.simantics.scl.compiler.environment.filter.NamespaceFilters;
import org.simantics.scl.compiler.environment.filter.NegativeNamespaceFilter;
import org.simantics.scl.compiler.environment.filter.PositiveNamespaceFilter;

import gnu.trove.set.hash.THashSet;

public class TestNamespaceFilter {
    
    private void testBooleanOperations(Collection<String> all, NamespaceFilter a, NamespaceFilter b) {
        {
            NamespaceFilter c = NamespaceFilters.union(a, b);
            //System.out.println("union(" + a + ", " + b + ") = " + c);
            for(String name : all)
                Assert.assertEquals(
                        a.isValueIncluded(name) || b.isValueIncluded(name),
                        c.isValueIncluded(name));
        }
        {
            NamespaceFilter c = NamespaceFilters.intersection(a, b);
            //System.out.println("intersection(" + a + ", " + b + ") = " + c);
            for(String name : all)
                Assert.assertEquals(
                        a.isValueIncluded(name) && b.isValueIncluded(name),
                        c.isValueIncluded(name));
        }
    }

    private void testBooleanOperations(THashSet<String> a, THashSet<String> b) {
        THashSet<String> all = new THashSet<String>();
        all.addAll(a);
        all.addAll(b);
        all.add("dummy");
        
        PositiveNamespaceFilter pa = new PositiveNamespaceFilter(a);
        NegativeNamespaceFilter na = new NegativeNamespaceFilter(a);
        PositiveNamespaceFilter pb = new PositiveNamespaceFilter(b);
        NegativeNamespaceFilter nb = new NegativeNamespaceFilter(b);
        testBooleanOperations(all, pa, pb);
        testBooleanOperations(all, na, pb);
        testBooleanOperations(all, pa, nb);
        testBooleanOperations(all, na, nb);
    }
    
    private void testBooleanOperations(THashSet<String> a) {
        THashSet<String> all = new THashSet<String>();
        all.addAll(a);
        all.add("dummy");
        
        PositiveNamespaceFilter pa = new PositiveNamespaceFilter(a);
        NegativeNamespaceFilter na = new NegativeNamespaceFilter(a);
        testBooleanOperations(all, pa, AcceptAllNamespaceFilter.INSTANCE);
        testBooleanOperations(all, na, AcceptAllNamespaceFilter.INSTANCE);
        testBooleanOperations(all, AcceptAllNamespaceFilter.INSTANCE, pa);
        testBooleanOperations(all, AcceptAllNamespaceFilter.INSTANCE, na);
        testBooleanOperations(all, AcceptAllNamespaceFilter.INSTANCE, AcceptAllNamespaceFilter.INSTANCE);
    }
    
    @Test
    public void testBooleanOperations() {
        for(int p=0;p<8;++p) {
            THashSet<String> a = new THashSet<String>();
            for(int i=0;i<3;++i)
                if(((p >> i) & 1) == 1)
                    a.add(String.valueOf(i));
            testBooleanOperations(a);
        }
        
        for(int p=0;p<64;++p) {
            THashSet<String> a = new THashSet<String>();
            THashSet<String> b = new THashSet<String>();
            for(int i=0;i<3;++i) {
                if(((p >> i) & 1) == 1)
                    a.add(String.valueOf(i));
                if(((p >> (i+3)) & 1) == 1)
                    b.add(String.valueOf(i));
            }
            testBooleanOperations(a, b);
        }
    }
    
}